ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/utils.C
(Generate patch)

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.36 by pippijn, Sat Jan 6 14:42:29 2007 UTC vs.
Revision 1.57 by root, Mon May 28 21:21:40 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * This file is part of Crossfire TRT, the Multiplayer Online Role Playing Game.
3 3 *
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 7 *
8 This program is free software; you can redistribute it and/or modify 8 * Crossfire TRT is free software; you can redistribute it and/or modify it
9 it under the terms of the GNU General Public License as published by 9 * under the terms of the GNU General Public License as published by the Free
10 the Free Software Foundation; either version 2 of the License, or 10 * Software Foundation; either version 2 of the License, or (at your option)
11 (at your option) any later version. 11 * any later version.
12 12 *
13 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful, but
14 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 GNU General Public License for more details. 16 * for more details.
17 17 *
18 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License along
19 along with this program; if not, write to the Free Software 19 * with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 21 *
22 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail to <crossfire@schmorp.de>
23*/ 23 */
24 24
25/* 25/*
26 * General convenience functions for crossfire. 26 * General convenience functions for crossfire.
27 */ 27 */
28
29#include <cstdlib>
30#include <sys/types.h>
31#include <unistd.h>
32#include <sys/time.h>
33#include <time.h>
34#include <signal.h>
28 35
29#include <global.h> 36#include <global.h>
30#include <funcpoint.h> 37#include <funcpoint.h>
31#include <material.h> 38#include <material.h>
32 39
33#include <sys/time.h>
34#include <time.h>
35#include <glib.h> 40#include <glib.h>
41
42rand_gen rndm;
43
44void
45tausworthe_random_generator::seed (uint32_t seed)
46{
47 state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
48 state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;
49 state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;
50 state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U;
51
52 for (int i = 11; --i; )
53 operator ()();
54}
55
56uint32_t
57tausworthe_random_generator::next ()
58{
59 state [0] = ((state [0] & 0xFFFFFFFEU) << 18U) ^ (((state [0] << 6U) ^ state [0]) >> 13U);
60 state [1] = ((state [1] & 0xFFFFFFF8U) << 2U) ^ (((state [1] << 2U) ^ state [1]) >> 27U);
61 state [2] = ((state [2] & 0xFFFFFFF0U) << 7U) ^ (((state [2] << 13U) ^ state [2]) >> 21U);
62 state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] << 3U) ^ state [3]) >> 12U);
63
64 return state [0] ^ state [1] ^ state [2] ^ state [3];
65}
66
67uint32_t
68tausworthe_random_generator::get_range (uint32_t num)
69{
70 return (next () * (uint64_t)num) >> 32U;
71}
72
73// return a number within (min .. max)
74int
75tausworthe_random_generator::get_range (int r_min, int r_max)
76{
77 return r_min + get_range (max (r_max - r_min + 1, 0));
78}
36 79
37/* 80/*
38 * The random functions here take luck into account when rolling random 81 * The random functions here take luck into account when rolling random
39 * dice or numbers. This function has less of an impact the larger the 82 * dice or numbers. This function has less of an impact the larger the
40 * difference becomes in the random numbers. IE, the effect is lessened 83 * difference becomes in the random numbers. IE, the effect is lessened
… …
47 * Roll a random number between min and max. Uses op to determine luck, 90 * Roll a random number between min and max. Uses op to determine luck,
48 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases. 91 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
49 * Generally, op should be the player/caster/hitter requesting the roll, 92 * Generally, op should be the player/caster/hitter requesting the roll,
50 * not the recipient (ie, the poor slob getting hit). [garbled 20010916] 93 * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
51 */ 94 */
52
53int 95int
54random_roll (int min, int max, const object *op, int goodbad) 96random_roll (int r_min, int r_max, const object *op, int goodbad)
55{ 97{
56 int omin, diff, luck, base, ran; 98 int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
57 99
58 omin = min; 100 if (r_max < r_min)
59 diff = max - min + 1;
60 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
61
62 if (max < 1 || diff < 1)
63 { 101 {
64 LOG (llevError, "Calling random_roll with min=%d max=%d\n", min, max); 102 LOG (llevError | logBacktrace, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
103 return r_min;
104 }
105
106 if (op->type == PLAYER)
107 {
108 int luck = op->stats.luck;
109
110 if (rndm (base) < min (10, abs (luck)))
111 {
112 //TODO: take luck into account
113 }
114 }
115
116 return rndm (r_min, r_max);
117}
118
119/*
120 * This is a 64 bit version of random_roll above. This is needed
121 * for exp loss calculations for players changing religions.
122 */
123sint64
124random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
125{
126 sint64 omin = min;
127 sint64 diff = max - min + 1;
128 int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
129
130 if (diff < 0)
131 {
132 LOG (llevError | logBacktrace, "Calling random_roll64 with min=%" PRId64 " max=%" PRId64 "\n", min, max);
65 return (min); /* avoids a float exception */ 133 return (min); /* avoids a float exception */
66 } 134 }
67 135
68 ran = RANDOM (); 136 /*
137 * Make a call to get two 32 bit unsigned random numbers, and just to
138 * a little bitshifting.
139 */
140 sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
69 141
70 if (op->type != PLAYER) 142 if (op->type != PLAYER)
71 return ((ran % diff) + min); 143 return ((ran % diff) + min);
72 144
73 luck = op->stats.luck; 145 int luck = op->stats.luck;
146
74 if (RANDOM () % base < MIN (10, abs (luck))) 147 if (rndm (base) < MIN (10, abs (luck)))
75 { 148 {
76 /* we have a winner */ 149 /* we have a winner */
77 ((luck > 0) ? (luck = 1) : (luck = -1)); 150 ((luck > 0) ? (luck = 1) : (luck = -1));
78 diff -= luck; 151 diff -= luck;
79 if (diff < 1) 152 if (diff < 1)
80 return (omin); /*check again */ 153 return (omin); /*check again */
154
81 ((goodbad) ? (min += luck) : (diff)); 155 ((goodbad) ? (min += luck) : (diff));
82 156
83 return (MAX (omin, MIN (max, (ran % diff) + min))); 157 return (MAX (omin, MIN (max, (ran % diff) + min)));
84 } 158 }
159
85 return ((ran % diff) + min); 160 return ran % diff + min;
86}
87
88/*
89 * This is a 64 bit version of random_roll above. This is needed
90 * for exp loss calculations for players changing religions.
91 */
92
93sint64
94random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
95{
96 sint64 omin, diff, luck, ran;
97 int base;
98
99 omin = min;
100 diff = max - min + 1;
101 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
102
103 if (max < 1 || diff < 1)
104 {
105 LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
106 return (min); /* avoids a float exception */
107 }
108
109 /* Don't know of a portable call to get 64 bit random values.
110 * So make a call to get two 32 bit random numbers, and just to
111 * a little byteshifting. Do make sure the first one is only
112 * 32 bit, so we don't get skewed results
113 */
114 ran = (RANDOM () & 0xffffffff) | ((sint64) RANDOM () << 32);
115
116 if (op->type != PLAYER)
117 return ((ran % diff) + min);
118
119 luck = op->stats.luck;
120 if (RANDOM () % base < MIN (10, abs (luck)))
121 {
122 /* we have a winner */
123 ((luck > 0) ? (luck = 1) : (luck = -1));
124 diff -= luck;
125 if (diff < 1)
126 return (omin); /*check again */
127 ((goodbad) ? (min += luck) : (diff));
128
129 return (MAX (omin, MIN (max, (ran % diff) + min)));
130 }
131 return ((ran % diff) + min);
132} 161}
133 162
134/* 163/*
135 * Roll a number of dice (2d3, 4d6). Uses op to determine luck, 164 * Roll a number of dice (2d3, 4d6). Uses op to determine luck,
136 * If goodbad is non-zero, luck increases the roll, if zero, it decreases. 165 * If goodbad is non-zero, luck increases the roll, if zero, it decreases.
137 * Generally, op should be the player/caster/hitter requesting the roll, 166 * Generally, op should be the player/caster/hitter requesting the roll,
138 * not the recipient (ie, the poor slob getting hit). 167 * not the recipient (ie, the poor slob getting hit).
139 * The args are num D size (ie 4d6) [garbled 20010916] 168 * The args are num D size (ie 4d6) [garbled 20010916]
140 */ 169 */
141
142int 170int
143die_roll (int num, int size, const object *op, int goodbad) 171die_roll (int num, int size, const object *op, int goodbad)
144{ 172{
145 int min, diff, luck, total, i, gotlucky, base, ran; 173 int min, luck, total, i, gotlucky;
146 174
147 diff = size; 175 int diff = size;
148 min = 1; 176 min = 1;
149 luck = total = gotlucky = 0; 177 luck = total = gotlucky = 0;
150 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ 178 int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
179
151 if (size < 2 || diff < 1) 180 if (size < 2 || diff < 1)
152 { 181 {
153 LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size); 182 LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
154 return (num); /* avoids a float exception */ 183 return num; /* avoids a float exception */
155 } 184 }
156 185
157 if (op->type == PLAYER) 186 if (op->type == PLAYER)
158 luck = op->stats.luck; 187 luck = op->stats.luck;
159 188
160 for (i = 0; i < num; i++) 189 for (i = 0; i < num; i++)
161 { 190 {
162 if (RANDOM () % base < MIN (10, abs (luck)) && !gotlucky) 191 if (rndm (base) < MIN (10, abs (luck)) && !gotlucky)
163 { 192 {
164 /* we have a winner */ 193 /* we have a winner */
165 gotlucky++; 194 gotlucky++;
166 ((luck > 0) ? (luck = 1) : (luck = -1)); 195 ((luck > 0) ? (luck = 1) : (luck = -1));
167 diff -= luck; 196 diff -= luck;
168 if (diff < 1) 197 if (diff < 1)
169 return (num); /*check again */ 198 return (num); /*check again */
170 ((goodbad) ? (min += luck) : (diff)); 199 ((goodbad) ? (min += luck) : (diff));
171 ran = RANDOM ();
172 total += MAX (1, MIN (size, (ran % diff) + min)); 200 total += MAX (1, MIN (size, rndm (diff) + min));
173 } 201 }
174 else 202 else
175 {
176 total += RANDOM () % size + 1; 203 total += rndm (size) + 1;
177 }
178 } 204 }
205
179 return (total); 206 return total;
180}
181
182/*
183 * Another convenience function. Returns a number between min and max.
184 * It is suggested one use these functions rather than RANDOM()%, as it
185 * would appear that a number of off-by-one-errors exist due to improper
186 * use of %. This should also prevent SIGFPE.
187 */
188
189int
190rndm (int min, int max)
191{
192 int diff;
193
194 diff = max - min + 1;
195 if (max < 1 || diff < 1)
196 return (min);
197
198 return (RANDOM () % diff + min);
199} 207}
200 208
201/* decay and destroy perishable items in a map */ 209/* decay and destroy perishable items in a map */
202void 210void
203maptile::decay_objects () 211maptile::decay_objects ()
… …
242 if (op->stats.food < 0) 250 if (op->stats.food < 0)
243 destroy = 1; 251 destroy = 1;
244 } 252 }
245 else 253 else
246 { 254 {
247 int mat = op->material; 255 int mat = op->materials;
248 256
249 if (mat & M_PAPER 257 if (mat & M_PAPER
250 || mat & M_LEATHER 258 || mat & M_LEATHER
251 || mat & M_WOOD 259 || mat & M_WOOD
252 || mat & M_ORGANIC 260 || mat & M_ORGANIC
… …
267} 275}
268 276
269/* convert materialname to materialtype_t */ 277/* convert materialname to materialtype_t */
270 278
271materialtype_t * 279materialtype_t *
272name_to_material (const char *name) 280name_to_material (const shstr &name)
273{ 281{
274 materialtype_t *mt, *nmt; 282 for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)
275 283 if (name == mt->name)
276 mt = NULL;
277 for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt = nmt->next)
278 {
279 if (strcmp (name, nmt->name) == 0)
280 {
281 mt = nmt;
282 break;
283 }
284 }
285 return mt; 284 return mt;
285
286 return materialt;
286} 287}
287 288
288/* when doing transmutation of objects, we have to recheck the resistances, 289/* when doing transmutation of objects, we have to recheck the resistances,
289 * as some that did not apply previously, may apply now. 290 * as some that did not apply previously, may apply now.
290 */ 291 */
… …
339 340
340 if (nmt == NULL) 341 if (nmt == NULL)
341 { 342 {
342 lmt = NULL; 343 lmt = NULL;
343#ifndef NEW_MATERIAL_CODE 344#ifndef NEW_MATERIAL_CODE
344 for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next) 345 for (mt = materialt; mt && mt->next; mt = mt->next)
345 { 346 {
346 if (op->material & mt->material) 347 if (op->materials & mt->material)
347 { 348 {
348 lmt = mt; 349 lmt = mt;
349 break; 350 break;
350 } 351 }
351 } 352 }
352 353
353#else 354#else
354 for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next) 355 for (mt = materialt; mt && mt->next; mt = mt->next)
355 { 356 {
356 if (op->material & mt->material && rndm (1, 100) <= mt->chance && 357 if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
357 difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0)) 358 difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0))
358 { 359 {
359 lmt = mt; 360 lmt = mt;
360 if (!(op->is_weapon () || op->is_armor ())) 361 if (!(op->is_weapon () || op->is_armor ()))
361 break; 362 break;
… …
379 { 380 {
380 op->stats.dam += lmt->damage; 381 op->stats.dam += lmt->damage;
381 if (op->stats.dam < 1) 382 if (op->stats.dam < 1)
382 op->stats.dam = 1; 383 op->stats.dam = 1;
383 } 384 }
385
384 if (op->stats.sp && op->type == BOW) 386 if (op->stats.sp && op->type == BOW)
385 op->stats.sp += lmt->sp; 387 op->stats.sp += lmt->sp;
386 if (op->stats.wc && op->is_weapon ()) 388 if (op->stats.wc && op->is_weapon ())
387 op->stats.wc += lmt->wc; 389 op->stats.wc += lmt->wc;
388 if (op->is_armor ()) 390 if (op->is_armor ())
… …
397 op->resist[j] = 100; 399 op->resist[j] = 100;
398 if (op->resist[j] < -100) 400 if (op->resist[j] < -100)
399 op->resist[j] = -100; 401 op->resist[j] = -100;
400 } 402 }
401 } 403 }
402 op->materialname = add_string (lmt->name); 404 op->materialname = lmt->name;
403 /* dont make it unstackable if it doesn't need to be */ 405 /* dont make it unstackable if it doesn't need to be */
404 if (op->is_weapon () || op->is_armor ()) 406 if (op->is_weapon () || op->is_armor ())
405 { 407 {
406 op->weight = (op->weight * lmt->weight) / 100; 408 op->weight = (op->weight * lmt->weight) / 100;
407 op->value = (op->value * lmt->value) / 100; 409 op->value = (op->value * lmt->value) / 100;
… …
544 return; 546 return;
545} 547}
546 548
547///////////////////////////////////////////////////////////////////////////// 549/////////////////////////////////////////////////////////////////////////////
548 550
551void
552fork_abort (const char *msg)
553{
554 if (!fork ())
555 {
556 signal (SIGABRT, SIG_DFL);
557 // try to put corefiles into a subdirectory, if existing, to allow
558 // an administrator to reduce the I/O load.
559 chdir ("cores");
560 abort ();
561 }
562
563 LOG (llevError, "fork abort: %s\n", msg);
564}
565
549void *salloc_ (int n) throw (std::bad_alloc) 566void *salloc_ (int n) throw (std::bad_alloc)
550{ 567{
568#ifdef PREFER_MALLOC
569 void *ptr = malloc (n);
570#else
551 void *ptr = g_slice_alloc (n); 571 void *ptr = g_slice_alloc (n);
572#endif
552 573
553 if (!ptr) 574 if (!ptr)
554 throw std::bad_alloc (); 575 throw std::bad_alloc ();
555 576
556 return ptr; 577 return ptr;
… …
590 } 611 }
591 else 612 else
592 memcpy (dst, src, len + 1); 613 memcpy (dst, src, len + 1);
593} 614}
594 615
616const std::string
617format (const char *format, ...)
618{
619 int len;
620
621 {
622 char buf[128];
623
624 va_list ap;
625 va_start (ap, format);
626 len = vsnprintf (buf, sizeof (buf), format, ap);
627 va_end (ap);
628
629 assert (len >= 0); // shield againstz broken vsnprintf's
630
631 // was our static buffer short enough?
632 if (len < sizeof (buf))
633 return std::string (buf, len);
634 }
635
636 {
637 // longer, try harder
638 char *buf = salloc<char> (len + 1);
639
640 va_list ap;
641 va_start (ap, format);
642 vsnprintf (buf, len + 1, format, ap);
643 va_end (ap);
644
645 const std::string s (buf, len);
646 sfree<char> (buf, len + 1);
647
648 return buf;
649 }
650}
651
595tstamp now () 652tstamp now ()
596{ 653{
597 struct timeval tv; 654 struct timeval tv;
598 655
599 gettimeofday (&tv, 0); 656 gettimeofday (&tv, 0);
… …
608 665
609 int diff = (b - a) & 7; 666 int diff = (b - a) & 7;
610 return diff <= 1 || diff >= 7; 667 return diff <= 1 || diff >= 7;
611} 668}
612 669
670/* crc32 0xdebb20e3 table and supplementary functions. */
671extern const uint32_t crc_32_tab[256] =
672{
673 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
674 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
675 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
676 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
677 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
678 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
679 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
680 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
681 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
682 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
683 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
684 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
685 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
686 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
687 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
688 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
689 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
690 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
691 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
692 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
693 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
694 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
695 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
696 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
697 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
698 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
699 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
700 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
701 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
702 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
703 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
704 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
705 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
706 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
707 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
708 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
709 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
710 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
711 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
712 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
713 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
714 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
715 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
716 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
717 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
718 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
719 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
720 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
721 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
722 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
723 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
724 0x2d02ef8dL
725};
726
727

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines