PostgreSQL Source Code git master
Loading...
Searching...
No Matches
Macros | Functions | Variables
md5.c File Reference
#include "postgres.h"
#include "md5_int.h"
Include dependency graph for md5.c:

Go to the source code of this file.

Macros

#define SHIFT(X, s)   (((X) << (s)) | ((X) >> (32 - (s))))
 
#define F(X, Y, Z)   (((X) & (Y)) | ((~X) & (Z)))
 
#define G(X, Y, Z)   (((X) & (Z)) | ((Y) & (~Z)))
 
#define H(X, Y, Z)   ((X) ^ (Y) ^ (Z))
 
#define I(X, Y, Z)   ((Y) ^ ((X) | (~Z)))
 
#define ROUND1(a, b, c, d, k, s, i)
 
#define ROUND2(a, b, c, d, k, s, i)
 
#define ROUND3(a, b, c, d, k, s, i)
 
#define ROUND4(a, b, c, d, k, s, i)
 
#define Sa   7
 
#define Sb   12
 
#define Sc   17
 
#define Sd   22
 
#define Se   5
 
#define Sf   9
 
#define Sg   14
 
#define Sh   20
 
#define Si   4
 
#define Sj   11
 
#define Sk   16
 
#define Sl   23
 
#define Sm   6
 
#define Sn   10
 
#define So   15
 
#define Sp   21
 
#define MD5_A0   0x67452301
 
#define MD5_B0   0xefcdab89
 
#define MD5_C0   0x98badcfe
 
#define MD5_D0   0x10325476
 

Functions

static void md5_calc (const uint8 *b64, pg_md5_ctx *ctx)
 
static void md5_pad (pg_md5_ctx *ctx)
 
static void md5_result (uint8 *digest, pg_md5_ctx *ctx)
 
void pg_md5_init (pg_md5_ctx *ctx)
 
void pg_md5_update (pg_md5_ctx *ctx, const uint8 *data, size_t len)
 
void pg_md5_final (pg_md5_ctx *ctx, uint8 *dest)
 

Variables

static const uint32 T [65]
 
static const uint8 md5_paddat [MD5_BUFLEN]
 

Macro Definition Documentation

◆ F

#define F (   X,
  Y,
  Z 
)    (((X) & (Y)) | ((~X) & (Z)))

Definition at line 60 of file md5.c.

◆ G

#define G (   X,
  Y,
  Z 
)    (((X) & (Z)) | ((Y) & (~Z)))

Definition at line 61 of file md5.c.

◆ H

#define H (   X,
  Y,
  Z 
)    ((X) ^ (Y) ^ (Z))

Definition at line 62 of file md5.c.

◆ I

#define I (   X,
  Y,
  Z 
)    ((Y) ^ ((X) | (~Z)))

Definition at line 63 of file md5.c.

◆ MD5_A0

#define MD5_A0   0x67452301

Definition at line 113 of file md5.c.

◆ MD5_B0

#define MD5_B0   0xefcdab89

Definition at line 114 of file md5.c.

◆ MD5_C0

#define MD5_C0   0x98badcfe

Definition at line 115 of file md5.c.

◆ MD5_D0

#define MD5_D0   0x10325476

Definition at line 116 of file md5.c.

◆ ROUND1

#define ROUND1 (   a,
  b,
  c,
  d,
  k,
  s,
  i 
)
Value:
do { \
(a) = (a) + F((b), (c), (d)) + X[(k)] + T[(i)]; \
(a) = SHIFT((a), (s)); \
(a) = (b) + (a); \
} while (0)
b
int b
Definition isn.c:74
a
int a
Definition isn.c:73
i
int i
Definition isn.c:77
SHIFT
#define SHIFT(X, s)
Definition md5.c:58
T
static const uint32 T[65]
Definition md5.c:119
F
#define F(X, Y, Z)
Definition md5.c:60
c
char * c
Definition preproc-cursor.c:31
fb
static int fb(int x)
Definition preproc-init.c:92

Definition at line 65 of file md5.c.

66 { \
67 (a) = (a) + F((b), (c), (d)) + X[(k)] + T[(i)]; \
68 (a) = SHIFT((a), (s)); \
69 (a) = (b) + (a); \
70} while (0)

◆ ROUND2

#define ROUND2 (   a,
  b,
  c,
  d,
  k,
  s,
  i 
)
Value:
do { \
(a) = (a) + G((b), (c), (d)) + X[(k)] + T[(i)]; \
(a) = SHIFT((a), (s)); \
(a) = (b) + (a); \
} while (0)
G
#define G(X, Y, Z)
Definition md5.c:61

Definition at line 72 of file md5.c.

73 { \
74 (a) = (a) + G((b), (c), (d)) + X[(k)] + T[(i)]; \
75 (a) = SHIFT((a), (s)); \
76 (a) = (b) + (a); \
77} while (0)

◆ ROUND3

#define ROUND3 (   a,
  b,
  c,
  d,
  k,
  s,
  i 
)
Value:
do { \
(a) = (a) + H((b), (c), (d)) + X[(k)] + T[(i)]; \
(a) = SHIFT((a), (s)); \
(a) = (b) + (a); \
} while (0)
H
#define H(X, Y, Z)
Definition md5.c:62

Definition at line 79 of file md5.c.

80 { \
81 (a) = (a) + H((b), (c), (d)) + X[(k)] + T[(i)]; \
82 (a) = SHIFT((a), (s)); \
83 (a) = (b) + (a); \
84} while (0)

◆ ROUND4

#define ROUND4 (   a,
  b,
  c,
  d,
  k,
  s,
  i 
)
Value:
do { \
(a) = (a) + I((b), (c), (d)) + X[(k)] + T[(i)]; \
(a) = SHIFT((a), (s)); \
(a) = (b) + (a); \
} while (0)
I
#define I(X, Y, Z)
Definition md5.c:63

Definition at line 86 of file md5.c.

87 { \
88 (a) = (a) + I((b), (c), (d)) + X[(k)] + T[(i)]; \
89 (a) = SHIFT((a), (s)); \
90 (a) = (b) + (a); \
91} while (0)

◆ Sa

#define Sa   7

Definition at line 93 of file md5.c.

◆ Sb

#define Sb   12

Definition at line 94 of file md5.c.

◆ Sc

#define Sc   17

Definition at line 95 of file md5.c.

◆ Sd

#define Sd   22

Definition at line 96 of file md5.c.

◆ Se

#define Se   5

Definition at line 98 of file md5.c.

◆ Sf

#define Sf   9

Definition at line 99 of file md5.c.

◆ Sg

#define Sg   14

Definition at line 100 of file md5.c.

◆ Sh

#define Sh   20

Definition at line 101 of file md5.c.

◆ SHIFT

#define SHIFT (   X,
  s 
)    (((X) << (s)) | ((X) >> (32 - (s))))

Definition at line 58 of file md5.c.

◆ Si

#define Si   4

Definition at line 103 of file md5.c.

◆ Sj

#define Sj   11

Definition at line 104 of file md5.c.

◆ Sk

#define Sk   16

Definition at line 105 of file md5.c.

◆ Sl

#define Sl   23

Definition at line 106 of file md5.c.

◆ Sm

#define Sm   6

Definition at line 108 of file md5.c.

◆ Sn

#define Sn   10

Definition at line 109 of file md5.c.

◆ So

#define So   15

Definition at line 110 of file md5.c.

◆ Sp

#define Sp   21

Definition at line 111 of file md5.c.

Function Documentation

◆ md5_calc()

static void md5_calc ( const uint8 *  b64,
pg_md5_ctx *  ctx 
)
static

Definition at line 154 of file md5.c.

155{
156 uint32 A = ctx->md5_sta;
157 uint32 B = ctx->md5_stb;
158 uint32 C = ctx->md5_stc;
159 uint32 D = ctx->md5_std;
160
161#ifndef WORDS_BIGENDIAN
162 const uint32 *X = (const uint32 *) b64;
163#else
164 /* 4 byte words */
165 /* what a brute force but fast! */
166 uint32 X[16];
167 uint8 *y = (uint8 *) X;
168
169 y[0] = b64[3];
170 y[1] = b64[2];
171 y[2] = b64[1];
172 y[3] = b64[0];
173 y[4] = b64[7];
174 y[5] = b64[6];
175 y[6] = b64[5];
176 y[7] = b64[4];
177 y[8] = b64[11];
178 y[9] = b64[10];
179 y[10] = b64[9];
180 y[11] = b64[8];
181 y[12] = b64[15];
182 y[13] = b64[14];
183 y[14] = b64[13];
184 y[15] = b64[12];
185 y[16] = b64[19];
186 y[17] = b64[18];
187 y[18] = b64[17];
188 y[19] = b64[16];
189 y[20] = b64[23];
190 y[21] = b64[22];
191 y[22] = b64[21];
192 y[23] = b64[20];
193 y[24] = b64[27];
194 y[25] = b64[26];
195 y[26] = b64[25];
196 y[27] = b64[24];
197 y[28] = b64[31];
198 y[29] = b64[30];
199 y[30] = b64[29];
200 y[31] = b64[28];
201 y[32] = b64[35];
202 y[33] = b64[34];
203 y[34] = b64[33];
204 y[35] = b64[32];
205 y[36] = b64[39];
206 y[37] = b64[38];
207 y[38] = b64[37];
208 y[39] = b64[36];
209 y[40] = b64[43];
210 y[41] = b64[42];
211 y[42] = b64[41];
212 y[43] = b64[40];
213 y[44] = b64[47];
214 y[45] = b64[46];
215 y[46] = b64[45];
216 y[47] = b64[44];
217 y[48] = b64[51];
218 y[49] = b64[50];
219 y[50] = b64[49];
220 y[51] = b64[48];
221 y[52] = b64[55];
222 y[53] = b64[54];
223 y[54] = b64[53];
224 y[55] = b64[52];
225 y[56] = b64[59];
226 y[57] = b64[58];
227 y[58] = b64[57];
228 y[59] = b64[56];
229 y[60] = b64[63];
230 y[61] = b64[62];
231 y[62] = b64[61];
232 y[63] = b64[60];
233#endif
234
235 ROUND1(A, B, C, D, 0, Sa, 1);
236 ROUND1(D, A, B, C, 1, Sb, 2);
237 ROUND1(C, D, A, B, 2, Sc, 3);
238 ROUND1(B, C, D, A, 3, Sd, 4);
239 ROUND1(A, B, C, D, 4, Sa, 5);
240 ROUND1(D, A, B, C, 5, Sb, 6);
241 ROUND1(C, D, A, B, 6, Sc, 7);
242 ROUND1(B, C, D, A, 7, Sd, 8);
243 ROUND1(A, B, C, D, 8, Sa, 9);
244 ROUND1(D, A, B, C, 9, Sb, 10);
245 ROUND1(C, D, A, B, 10, Sc, 11);
246 ROUND1(B, C, D, A, 11, Sd, 12);
247 ROUND1(A, B, C, D, 12, Sa, 13);
248 ROUND1(D, A, B, C, 13, Sb, 14);
249 ROUND1(C, D, A, B, 14, Sc, 15);
250 ROUND1(B, C, D, A, 15, Sd, 16);
251
252 ROUND2(A, B, C, D, 1, Se, 17);
253 ROUND2(D, A, B, C, 6, Sf, 18);
254 ROUND2(C, D, A, B, 11, Sg, 19);
255 ROUND2(B, C, D, A, 0, Sh, 20);
256 ROUND2(A, B, C, D, 5, Se, 21);
257 ROUND2(D, A, B, C, 10, Sf, 22);
258 ROUND2(C, D, A, B, 15, Sg, 23);
259 ROUND2(B, C, D, A, 4, Sh, 24);
260 ROUND2(A, B, C, D, 9, Se, 25);
261 ROUND2(D, A, B, C, 14, Sf, 26);
262 ROUND2(C, D, A, B, 3, Sg, 27);
263 ROUND2(B, C, D, A, 8, Sh, 28);
264 ROUND2(A, B, C, D, 13, Se, 29);
265 ROUND2(D, A, B, C, 2, Sf, 30);
266 ROUND2(C, D, A, B, 7, Sg, 31);
267 ROUND2(B, C, D, A, 12, Sh, 32);
268
269 ROUND3(A, B, C, D, 5, Si, 33);
270 ROUND3(D, A, B, C, 8, Sj, 34);
271 ROUND3(C, D, A, B, 11, Sk, 35);
272 ROUND3(B, C, D, A, 14, Sl, 36);
273 ROUND3(A, B, C, D, 1, Si, 37);
274 ROUND3(D, A, B, C, 4, Sj, 38);
275 ROUND3(C, D, A, B, 7, Sk, 39);
276 ROUND3(B, C, D, A, 10, Sl, 40);
277 ROUND3(A, B, C, D, 13, Si, 41);
278 ROUND3(D, A, B, C, 0, Sj, 42);
279 ROUND3(C, D, A, B, 3, Sk, 43);
280 ROUND3(B, C, D, A, 6, Sl, 44);
281 ROUND3(A, B, C, D, 9, Si, 45);
282 ROUND3(D, A, B, C, 12, Sj, 46);
283 ROUND3(C, D, A, B, 15, Sk, 47);
284 ROUND3(B, C, D, A, 2, Sl, 48);
285
286 ROUND4(A, B, C, D, 0, Sm, 49);
287 ROUND4(D, A, B, C, 7, Sn, 50);
288 ROUND4(C, D, A, B, 14, So, 51);
289 ROUND4(B, C, D, A, 5, Sp, 52);
290 ROUND4(A, B, C, D, 12, Sm, 53);
291 ROUND4(D, A, B, C, 3, Sn, 54);
292 ROUND4(C, D, A, B, 10, So, 55);
293 ROUND4(B, C, D, A, 1, Sp, 56);
294 ROUND4(A, B, C, D, 8, Sm, 57);
295 ROUND4(D, A, B, C, 15, Sn, 58);
296 ROUND4(C, D, A, B, 6, So, 59);
297 ROUND4(B, C, D, A, 13, Sp, 60);
298 ROUND4(A, B, C, D, 4, Sm, 61);
299 ROUND4(D, A, B, C, 11, Sn, 62);
300 ROUND4(C, D, A, B, 2, So, 63);
301 ROUND4(B, C, D, A, 9, Sp, 64);
302
303 ctx->md5_sta += A;
304 ctx->md5_stb += B;
305 ctx->md5_stc += C;
306 ctx->md5_std += D;
307}
uint8
uint8_t uint8
Definition c.h:544
uint32
uint32_t uint32
Definition c.h:546
y
int y
Definition isn.c:76
Sj
#define Sj
Definition md5.c:104
Sc
#define Sc
Definition md5.c:95
Sd
#define Sd
Definition md5.c:96
ROUND2
#define ROUND2(a, b, c, d, k, s, i)
Definition md5.c:72
Sn
#define Sn
Definition md5.c:109
Sh
#define Sh
Definition md5.c:101
Sa
#define Sa
Definition md5.c:93
Se
#define Se
Definition md5.c:98
ROUND3
#define ROUND3(a, b, c, d, k, s, i)
Definition md5.c:79
Sg
#define Sg
Definition md5.c:100
Sk
#define Sk
Definition md5.c:105
Si
#define Si
Definition md5.c:103
ROUND1
#define ROUND1(a, b, c, d, k, s, i)
Definition md5.c:65
Sp
#define Sp
Definition md5.c:111
Sf
#define Sf
Definition md5.c:99
ROUND4
#define ROUND4(a, b, c, d, k, s, i)
Definition md5.c:86
Sb
#define Sb
Definition md5.c:94
Sl
#define Sl
Definition md5.c:106
Sm
#define Sm
Definition md5.c:108
So
#define So
Definition md5.c:110

References fb(), ROUND1, ROUND2, ROUND3, ROUND4, Sa, Sb, Sc, Sd, Se, Sf, Sg, Sh, Si, Sj, Sk, Sl, Sm, Sn, So, Sp, and y.

Referenced by md5_pad(), and pg_md5_update().

◆ md5_pad()

static void md5_pad ( pg_md5_ctx *  ctx)
static

Definition at line 310 of file md5.c.

311{
312 unsigned int gap;
313
314 /* Don't count up padding. Keep md5_n. */
315 gap = MD5_BUFLEN - ctx->md5_i;
316 if (gap > 8)
317 {
318 memmove(ctx->md5_buf + ctx->md5_i, md5_paddat,
319 gap - sizeof(ctx->md5_n));
320 }
321 else
322 {
323 /* including gap == 8 */
324 memmove(ctx->md5_buf + ctx->md5_i, md5_paddat, gap);
325 md5_calc(ctx->md5_buf, ctx);
326 memmove(ctx->md5_buf, md5_paddat + gap,
327 MD5_BUFLEN - sizeof(ctx->md5_n));
328 }
329
330 /* 8 byte word */
331#ifndef WORDS_BIGENDIAN
332 memmove(&ctx->md5_buf[56], &ctx->md5_n8[0], 8);
333#else
334 ctx->md5_buf[56] = ctx->md5_n8[7];
335 ctx->md5_buf[57] = ctx->md5_n8[6];
336 ctx->md5_buf[58] = ctx->md5_n8[5];
337 ctx->md5_buf[59] = ctx->md5_n8[4];
338 ctx->md5_buf[60] = ctx->md5_n8[3];
339 ctx->md5_buf[61] = ctx->md5_n8[2];
340 ctx->md5_buf[62] = ctx->md5_n8[1];
341 ctx->md5_buf[63] = ctx->md5_n8[0];
342#endif
343
344 md5_calc(ctx->md5_buf, ctx);
345}
md5_paddat
static const uint8 md5_paddat[MD5_BUFLEN]
Definition md5.c:142
md5_calc
static void md5_calc(const uint8 *b64, pg_md5_ctx *ctx)
Definition md5.c:154
MD5_BUFLEN
#define MD5_BUFLEN
Definition md5_int.h:51
pg_md5_ctx::md5_i
unsigned int md5_i
Definition md5_int.h:76
pg_md5_ctx::md5_buf
uint8 md5_buf[MD5_BUFLEN]
Definition md5_int.h:77

References fb(), pg_md5_ctx::md5_buf, MD5_BUFLEN, md5_calc(), pg_md5_ctx::md5_i, and md5_paddat.

Referenced by pg_md5_final().

◆ md5_result()

static void md5_result ( uint8 *  digest,
pg_md5_ctx *  ctx 
)
static

Definition at line 348 of file md5.c.

349{
350 /* 4 byte words */
351#ifndef WORDS_BIGENDIAN
352 memmove(digest, &ctx->md5_st8[0], 16);
353#else
354 digest[0] = ctx->md5_st8[3];
355 digest[1] = ctx->md5_st8[2];
356 digest[2] = ctx->md5_st8[1];
357 digest[3] = ctx->md5_st8[0];
358 digest[4] = ctx->md5_st8[7];
359 digest[5] = ctx->md5_st8[6];
360 digest[6] = ctx->md5_st8[5];
361 digest[7] = ctx->md5_st8[4];
362 digest[8] = ctx->md5_st8[11];
363 digest[9] = ctx->md5_st8[10];
364 digest[10] = ctx->md5_st8[9];
365 digest[11] = ctx->md5_st8[8];
366 digest[12] = ctx->md5_st8[15];
367 digest[13] = ctx->md5_st8[14];
368 digest[14] = ctx->md5_st8[13];
369 digest[15] = ctx->md5_st8[12];
370#endif
371}

References fb().

Referenced by pg_md5_final().

◆ pg_md5_final()

void pg_md5_final ( pg_md5_ctx *  ctx,
uint8 *  dest 
)

Definition at line 432 of file md5.c.

433{
434 md5_pad(ctx);
435 md5_result(dest, ctx);
436}
md5_result
static void md5_result(uint8 *digest, pg_md5_ctx *ctx)
Definition md5.c:348
md5_pad
static void md5_pad(pg_md5_ctx *ctx)
Definition md5.c:310

References md5_pad(), and md5_result().

Referenced by pg_cryptohash_final().

◆ pg_md5_init()

void pg_md5_init ( pg_md5_ctx *  ctx)

Definition at line 382 of file md5.c.

383{
384 ctx->md5_n = 0;
385 ctx->md5_i = 0;
386 ctx->md5_sta = MD5_A0;
387 ctx->md5_stb = MD5_B0;
388 ctx->md5_stc = MD5_C0;
389 ctx->md5_std = MD5_D0;
390 memset(ctx->md5_buf, 0, sizeof(ctx->md5_buf));
391}
MD5_B0
#define MD5_B0
Definition md5.c:114
MD5_C0
#define MD5_C0
Definition md5.c:115
MD5_D0
#define MD5_D0
Definition md5.c:116
MD5_A0
#define MD5_A0
Definition md5.c:113

References fb(), MD5_A0, MD5_B0, pg_md5_ctx::md5_buf, MD5_C0, MD5_D0, and pg_md5_ctx::md5_i.

Referenced by pg_cryptohash_init().

◆ pg_md5_update()

void pg_md5_update ( pg_md5_ctx *  ctx,
const uint8 *  data,
size_t  len 
)

Definition at line 400 of file md5.c.

401{
402 unsigned int gap,
403 i;
404
405 ctx->md5_n += len * 8; /* byte to bit */
406 gap = MD5_BUFLEN - ctx->md5_i;
407
408 if (len >= gap)
409 {
410 memmove(ctx->md5_buf + ctx->md5_i, data, gap);
411 md5_calc(ctx->md5_buf, ctx);
412
413 for (i = gap; i + MD5_BUFLEN <= len; i += MD5_BUFLEN)
414 md5_calc(data + i, ctx);
415
416 ctx->md5_i = len - i;
417 memmove(ctx->md5_buf, data + i, ctx->md5_i);
418 }
419 else
420 {
421 memmove(ctx->md5_buf + ctx->md5_i, data, len);
422 ctx->md5_i += len;
423 }
424}
len
const void size_t len
Definition pg_crc32c_sse42.c:28
data
const void * data
Definition pg_crc32c_sse42.c:27

References data, fb(), i, len, pg_md5_ctx::md5_buf, MD5_BUFLEN, md5_calc(), and pg_md5_ctx::md5_i.

Referenced by pg_cryptohash_update().

Variable Documentation

◆ md5_paddat

const uint8 md5_paddat[MD5_BUFLEN]
static
Initial value:
= {
0x80, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
}

Definition at line 142 of file md5.c.

142 {
143 0x80, 0, 0, 0, 0, 0, 0, 0,
144 0, 0, 0, 0, 0, 0, 0, 0,
145 0, 0, 0, 0, 0, 0, 0, 0,
146 0, 0, 0, 0, 0, 0, 0, 0,
147 0, 0, 0, 0, 0, 0, 0, 0,
148 0, 0, 0, 0, 0, 0, 0, 0,
149 0, 0, 0, 0, 0, 0, 0, 0,
150 0, 0, 0, 0, 0, 0, 0, 0,
151};

Referenced by md5_pad().

◆ T

const uint32 T[65]
static
Initial value:
= {
0,
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
}

Definition at line 119 of file md5.c.

119 {
120 0,
121 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
122 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
123 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
124 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
125
126 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
127 0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,
128 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
129 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
130
131 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
132 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
133 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
134 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
135
136 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
137 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
138 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
139 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
140};

Referenced by compute_bitmap_pages(), cost_bitmap_heap_scan(), fetch_att(), index_pages_fetched(), and store_att_byval().