server/common/utils.C

/*
 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Crossfire TRT is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <crossfire@schmorp.de>
 */

/*
 * General convenience functions for crossfire.
 */

#include <cstdlib>
#include <sys/types.h>
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
#include <signal.h>

#include <global.h>
#include <funcpoint.h>
#include <material.h>

#include <glib.h>

rand_gen rndm;

void
tausworthe_random_generator::seed (uint32_t seed)
{
  state [0] = seed      * 69069U; if (state [0] <  2U) state [0] +=   2U;
  state [1] = state [0] * 69069U; if (state [0] <  8U) state [0] +=   8U;
  state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] +=  16U;
  state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U;

  for (int i = 11; --i; )
    operator ()();
}

uint32_t
tausworthe_random_generator::next ()
{
  state [0] = ((state [0] & 0xFFFFFFFEU) << 18U) ^ (((state [0] <<  6U) ^ state [0]) >> 13U);
  state [1] = ((state [1] & 0xFFFFFFF8U) <<  2U) ^ (((state [1] <<  2U) ^ state [1]) >> 27U);
  state [2] = ((state [2] & 0xFFFFFFF0U) <<  7U) ^ (((state [2] << 13U) ^ state [2]) >> 21U);
  state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] <<  3U) ^ state [3]) >> 12U);

  return state [0] ^ state [1] ^ state [2] ^ state [3];
}

uint32_t
tausworthe_random_generator::get_range (uint32_t num)
{
  return (next () * (uint64_t)num) >> 32U;
}

// return a number within (min .. max)
int 
tausworthe_random_generator::get_range (int r_min, int r_max)
{
  return r_min + get_range (max (r_max - r_min + 1, 0));
}

/*
 * The random functions here take luck into account when rolling random
 * dice or numbers.  This function has less of an impact the larger the
 * difference becomes in the random numbers.  IE, the effect is lessened
 * on a 1-1000 roll, vs a 1-6 roll.  This can be used by crafty programmers,
 * to specifically disable luck in certain rolls, simply by making the
 * numbers larger (ie, 1d1000 > 500 vs 1d6 > 3)
 */

/*
 * Roll a random number between min and max.  Uses op to determine luck,
 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
 * Generally, op should be the player/caster/hitter requesting the roll,
 * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
 */
int
random_roll (int r_min, int r_max, const object *op, int goodbad)
{
  int base = r_max - r_min > 1 ? 20 : 50;     /* d2 and d3 are corner cases */

  if (r_max < r_min)
    {
      LOG (llevError | logBacktrace, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
      return r_min;
    }

  if (op->type == PLAYER)
    {
      int luck = op->stats.luck;

      if (rndm (base) < min (10, abs (luck)))
        {
          //TODO: take luck into account
        }
    }

  return rndm (r_min, r_max);
}

/*
 * This is a 64 bit version of random_roll above.  This is needed
 * for exp loss calculations for players changing religions.
 */
sint64
random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
{
  sint64 omin = min;
  sint64 diff = max - min + 1;
  int base = diff > 2 ? 20 : 50;     /* d2 and d3 are corner cases */

  if (diff < 0)
    {
      LOG (llevError | logBacktrace, "Calling random_roll64 with min=%" PRId64 " max=%" PRId64 "\n", min, max);
      return (min);             /* avoids a float exception */
    }

  /* 
   * Make a call to get two 32 bit unsigned random numbers, and just to
   * a little bitshifting.
   */
  sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);

  if (op->type != PLAYER)
    return ((ran % diff) + min);

  int luck = op->stats.luck;

  if (rndm (base) < MIN (10, abs (luck)))
    {
      /* we have a winner */
      ((luck > 0) ? (luck = 1) : (luck = -1));
      diff -= luck;
      if (diff < 1)
        return (omin);          /*check again */

      ((goodbad) ? (min += luck) : (diff));

      return (MAX (omin, MIN (max, (ran % diff) + min)));
    }

  return ran % diff + min;
}

/*
 * Roll a number of dice (2d3, 4d6).  Uses op to determine luck,
 * If goodbad is non-zero, luck increases the roll, if zero, it decreases.
 * Generally, op should be the player/caster/hitter requesting the roll,
 * not the recipient (ie, the poor slob getting hit).
 * The args are num D size (ie 4d6)  [garbled 20010916]
 */
int
die_roll (int num, int size, const object *op, int goodbad)
{
  int min, luck, total, i, gotlucky;

  int diff = size;
  min = 1;
  luck = total = gotlucky = 0;
  int base = diff > 2 ? 20 : 50;     /* d2 and d3 are corner cases */

  if (size < 2 || diff < 1)
    {
      LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
      return num;             /* avoids a float exception */
    }

  if (op->type == PLAYER)
    luck = op->stats.luck;

  for (i = 0; i < num; i++)
    {
      if (rndm (base) < MIN (10, abs (luck)) && !gotlucky)
        {
          /* we have a winner */
          gotlucky++;
          ((luck > 0) ? (luck = 1) : (luck = -1));
          diff -= luck;
          if (diff < 1)
            return (num);       /*check again */
          ((goodbad) ? (min += luck) : (diff));
          total += MAX (1, MIN (size, rndm (diff) + min));
        }
      else
        total += rndm (size) + 1;
    }

  return total;
}

/* convert materialname to materialtype_t */

materialtype_t *
name_to_material (const shstr &name)
{
  for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)
    if (name == mt->name)
      return mt;

  return 0;
}

/* when doing transmutation of objects, we have to recheck the resistances,
 * as some that did not apply previously, may apply now.
 */

void
transmute_materialname (object *op, const object *change)
{
  materialtype_t *mt;
  int j;

  if (op->materialname == NULL)
    return;

  if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
    return;

  if (!op->is_armor ())
    return;

  mt = name_to_material (op->materialname);
  if (!mt)
    {
      LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->archname, &op->name, &op->materialname);
      return;
    }

  for (j = 0; j < NROFATTACKS; j++)
    if (op->resist[j] == 0 && change->resist[j] != 0)
      {
        op->resist[j] += mt->mod[j];
        if (op->resist[j] > 100)
          op->resist[j] = 100;
        if (op->resist[j] < -100)
          op->resist[j] = -100;
      }
}

/* set the materialname and type for an item */
void
set_materialname (object *op, int difficulty, materialtype_t *nmt)
{
  materialtype_t *mt, *lmt;

  if (op->materialname != NULL)
    return;

  if (nmt == NULL)
    {
      lmt = NULL;

      for (mt = materialt; mt && mt->next; mt = mt->next)
        if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
            difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0))
          {
            lmt = mt;
            if (!(op->is_weapon () || op->is_armor ()))
              break;
          }
    }
  else
    lmt = nmt;

  if (lmt != NULL)
    {
      if (op->stats.dam && op->is_weapon ())
        {
          op->stats.dam += lmt->damage;
          if (op->stats.dam < 1)
            op->stats.dam = 1;
        }

      if (op->stats.sp && op->type == BOW)
        op->stats.sp += lmt->sp;
      if (op->stats.wc && op->is_weapon ())
        op->stats.wc += lmt->wc;
      if (op->is_armor ())
        {
          if (op->stats.ac)
            op->stats.ac += lmt->ac;

          for (int j = 0; j < NROFATTACKS; j++)
            if (op->resist[j] != 0)
              {
                op->resist[j] += lmt->mod[j];
                if (op->resist[j] > 100)
                  op->resist[j] = 100;
                if (op->resist[j] < -100)
                  op->resist[j] = -100;
              }
        }

      op->materialname = lmt->name;
      /* dont make it unstackable if it doesn't need to be */
      if (op->is_weapon () || op->is_armor ())
        {
          op->weight = (op->weight * lmt->weight) / 100;
          op->value = (op->value * lmt->value) / 100;
        }
    }
}

/*
 * Strip out the media tags from a String.
 * Warning the input string will contain the result string
 */
void
strip_media_tag (char *message)
{
  int in_tag = 0;
  char *dest;
  char *src;

  src = dest = message;
  while (*src != '\0')
    {
      if (*src == '[')
        {
          in_tag = 1;
        }
      else if (in_tag && (*src == ']'))
        in_tag = 0;
      else if (!in_tag)
        {
          *dest = *src;
          dest++;
        }
      src++;
    }
  *dest = '\0';
}

const char *
strrstr (const char *haystack, const char *needle)
{
  const char *lastneedle;

  lastneedle = NULL;
  while ((haystack = strstr (haystack, needle)) != NULL)
    {
      lastneedle = haystack;
      haystack++;
    }
  return lastneedle;

}

#define EOL_SIZE (sizeof("\n")-1)
void
strip_endline (char *buf)
{
  if (strlen (buf) < sizeof ("\n"))
    {
      return;
    }
  if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
    buf[strlen (buf) - EOL_SIZE] = '\0';
}

/**
 * Replace in string src all occurrences of key by replacement. The resulting
 * string is put into result; at most resultsize characters (including the
 * terminating null character) will be written to result.
 */
void
replace (const char *src, const char *key, const char *replacement, char *result, size_t resultsize)
{
  size_t resultlen;
  size_t keylen;

  /* special case to prevent infinite loop if key==replacement=="" */
  if (strcmp (key, replacement) == 0)
    {
      snprintf (result, resultsize, "%s", src);
      return;
    }

  keylen = strlen (key);

  resultlen = 0;
  while (*src != '\0' && resultlen + 1 < resultsize)
    {
      if (strncmp (src, key, keylen) == 0)
        {
          snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
          resultlen += strlen (result + resultlen);
          src += keylen;
        }
      else
        {
          result[resultlen++] = *src++;
        }
    }
  result[resultlen] = '\0';
}

/**
 * Taking a string as an argument, mutate it into a string that looks like a list.
 * a 'list' for the purposes here, is a string of items, seperated by commas, except
 * for the last entry, which has an 'and' before it, and a full stop (period) after it.
 * This function will also strip all trailing non alphanumeric characters.
 * It does not insert an oxford comma.
 */

void
make_list_like (char *input)
{
  char *p, tmp[MAX_BUF];
  int i;

  if (!input || strlen (input) > MAX_BUF - 5)
    return;
  /* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */

  strncpy (tmp, input, MAX_BUF - 5);
  /*trim all trailing commas, spaces etc. */
  for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
    tmp[i] = '\0';

  strcat (tmp, ".");

  p = strrchr (tmp, ',');
  if (p)
    {
      *p = '\0';
      strcpy (input, tmp);
      p++;
      strcat (input, " and");
      strcat (input, p);
    }
  else
    strcpy (input, tmp);

  return;
}

/////////////////////////////////////////////////////////////////////////////

void
fork_abort (const char *msg)
{
  if (!fork ())
    {
      signal (SIGABRT, SIG_DFL);
      // try to put corefiles into a subdirectory, if existing, to allow
      // an administrator to reduce the I/O load.
      chdir ("cores");
      abort ();
    }

  LOG (llevError, "fork abort: %s\n", msg);
}

void *salloc_ (int n) throw (std::bad_alloc)
{
#ifdef PREFER_MALLOC
  void *ptr = malloc (n);
#else
  void *ptr = g_slice_alloc (n);
#endif

  if (!ptr)
    throw std::bad_alloc ();

  return ptr;
}

void *salloc_ (int n, void *src) throw (std::bad_alloc)
{
  void *ptr = salloc_ (n);

  if (src)
    memcpy (ptr, src, n);
  else
    memset (ptr, 0, n);

  return ptr;
}

void assign (char *dst, const char *src, int maxlen)
{
  if (!src)
    src = "";

  int len = strlen (src);

  if (len >= maxlen - 1)
    {
      if (maxlen <= 4)
        {
          memset (dst, '.', maxlen - 1);
          dst [maxlen - 1] = 0;
        }
      else
        {
          memcpy (dst, src, maxlen - 4);
          memcpy (dst + maxlen - 4, "...", 4);
        }
    }
  else
    memcpy (dst, src, len + 1);
}

const std::string
format (const char *format, ...)
{
  int len;

  {
    char buf[128];

    va_list ap;
    va_start (ap, format);
    len = vsnprintf (buf, sizeof (buf), format, ap);
    va_end (ap);

    assert (len >= 0); // shield againstz broken vsnprintf's

    // was our static buffer short enough?
    if (len < sizeof (buf))
      return std::string (buf, len);
  }

  {
    // longer, try harder
    char *buf = salloc<char> (len + 1);

    va_list ap;
    va_start (ap, format);
    vsnprintf (buf, len + 1, format, ap);
    va_end (ap);

    const std::string s (buf, len);
    sfree<char> (buf, len + 1);
      
    return buf;
  }
}

tstamp now ()
{
  struct timeval tv;

  gettimeofday (&tv, 0);
  return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
}

int
similar_direction (int a, int b)
{
  if (!a || !b)
    return 0;

  int diff = (b - a) & 7;
  return diff <= 1 || diff >= 7;
}

/* crc32 0xdebb20e3 table and supplementary functions.  */
extern const uint32_t crc_32_tab[256] =
{
    0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
    0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
    0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
    0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
    0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
    0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
    0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
    0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
    0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
    0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
    0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
    0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
    0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
    0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
    0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
    0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
    0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
    0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
    0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
    0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
    0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
    0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
    0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
    0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
    0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
    0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
    0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
    0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
    0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
    0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
    0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
    0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
    0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
    0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
    0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
    0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
    0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
    0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
    0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
    0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
    0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
    0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
    0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
    0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
    0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
    0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
    0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
    0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
    0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
    0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
    0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
    0x2d02ef8dL
};


Revision:	1.62
Committed:	Tue Jul 10 07:31:20 2007 UTC (16 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.61:	+1 -1 lines
Log Message:	return 0 from name_to_material for unknown materials, to avoid unknown material message
#	User	Rev	Content
1	elmex	1.1	/*
2	root	1.60	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	pippijn	1.39	*
4	root	1.57	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5			* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6			* Copyright (©) 1992,2007 Frank Tore Johansen
7	pippijn	1.39	*
8	root	1.60	* Crossfire TRT is free software: you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation, either version 3 of the License, or
11			* (at your option) any later version.
12	pippijn	1.39	*
13	root	1.60	* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17	pippijn	1.39	*
18	root	1.60	* You should have received a copy of the GNU General Public License
19			* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	root	1.57	*
21			* The authors can be reached via e-mail to <crossfire@schmorp.de>
22	pippijn	1.39	*/
23	elmex	1.1
24			/*
25			* General convenience functions for crossfire.
26			*/
27
28	root	1.37	#include <cstdlib>
29			#include <sys/types.h>
30			#include <unistd.h>
31			#include <sys/time.h>
32			#include <time.h>
33			#include <signal.h>
34
35	elmex	1.1	#include <global.h>
36			#include <funcpoint.h>
37			#include <material.h>
38
39	root	1.4	#include <glib.h>
40
41	root	1.42	rand_gen rndm;
42	root	1.40
43	root	1.42	void
44			tausworthe_random_generator::seed (uint32_t seed)
45	root	1.40	{
46	root	1.49	state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
47			state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;
48			state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;
49			state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U;
50	root	1.40
51			for (int i = 11; --i; )
52			operator ()();
53			}
54
55			uint32_t
56			tausworthe_random_generator::next ()
57			{
58			state [0] = ((state [0] & 0xFFFFFFFEU) << 18U) ^ (((state [0] << 6U) ^ state [0]) >> 13U);
59			state [1] = ((state [1] & 0xFFFFFFF8U) << 2U) ^ (((state [1] << 2U) ^ state [1]) >> 27U);
60			state [2] = ((state [2] & 0xFFFFFFF0U) << 7U) ^ (((state [2] << 13U) ^ state [2]) >> 21U);
61			state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] << 3U) ^ state [3]) >> 12U);
62
63			return state [0] ^ state [1] ^ state [2] ^ state [3];
64			}
65
66	root	1.42	uint32_t
67	root	1.50	tausworthe_random_generator::get_range (uint32_t num)
68	root	1.42	{
69	root	1.50	return (next () * (uint64_t)num) >> 32U;
70	root	1.42	}
71
72			// return a number within (min .. max)
73			int
74			tausworthe_random_generator::get_range (int r_min, int r_max)
75			{
76	root	1.50	return r_min + get_range (max (r_max - r_min + 1, 0));
77	root	1.42	}
78
79	elmex	1.1	/*
80			* The random functions here take luck into account when rolling random
81			* dice or numbers. This function has less of an impact the larger the
82			* difference becomes in the random numbers. IE, the effect is lessened
83			* on a 1-1000 roll, vs a 1-6 roll. This can be used by crafty programmers,
84			* to specifically disable luck in certain rolls, simply by making the
85			* numbers larger (ie, 1d1000 > 500 vs 1d6 > 3)
86			*/
87
88			/*
89			* Roll a random number between min and max. Uses op to determine luck,
90			* and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
91			* Generally, op should be the player/caster/hitter requesting the roll,
92			* not the recipient (ie, the poor slob getting hit). [garbled 20010916]
93			*/
94	root	1.9	int
95	root	1.41	random_roll (int r_min, int r_max, const object *op, int goodbad)
96	root	1.9	{
97	root	1.41	int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
98	elmex	1.1
99	root	1.55	if (r_max < r_min)
100	root	1.9	{
101	root	1.54	LOG (llevError \| logBacktrace, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
102	root	1.41	return r_min;
103	elmex	1.1	}
104
105	root	1.41	if (op->type == PLAYER)
106	root	1.9	{
107	root	1.41	int luck = op->stats.luck;
108	elmex	1.1
109	root	1.41	if (rndm (base) < min (10, abs (luck)))
110			{
111			//TODO: take luck into account
112			}
113	elmex	1.1	}
114	root	1.41
115			return rndm (r_min, r_max);
116	elmex	1.1	}
117
118			/*
119			* This is a 64 bit version of random_roll above. This is needed
120			* for exp loss calculations for players changing religions.
121			*/
122	root	1.9	sint64
123			random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
124			{
125	root	1.55	sint64 omin = min;
126			sint64 diff = max - min + 1;
127			int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
128	root	1.9
129	root	1.55	if (diff < 0)
130	root	1.9	{
131	root	1.54	LOG (llevError \| logBacktrace, "Calling random_roll64 with min=%" PRId64 " max=%" PRId64 "\n", min, max);
132	root	1.9	return (min); /* avoids a float exception */
133	elmex	1.1	}
134
135	root	1.45	/*
136			* Make a call to get two 32 bit unsigned random numbers, and just to
137			* a little bitshifting.
138	root	1.9	*/
139	root	1.55	sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
140	root	1.9
141			if (op->type != PLAYER)
142			return ((ran % diff) + min);
143
144	root	1.55	int luck = op->stats.luck;
145
146	root	1.45	if (rndm (base) < MIN (10, abs (luck)))
147	root	1.9	{
148			/* we have a winner */
149			((luck > 0) ? (luck = 1) : (luck = -1));
150			diff -= luck;
151			if (diff < 1)
152			return (omin); /check again /
153	root	1.55
154	root	1.9	((goodbad) ? (min += luck) : (diff));
155	elmex	1.1
156	root	1.9	return (MAX (omin, MIN (max, (ran % diff) + min)));
157	elmex	1.1	}
158	root	1.45
159	root	1.55	return ran % diff + min;
160	elmex	1.1	}
161
162			/*
163			* Roll a number of dice (2d3, 4d6). Uses op to determine luck,
164			* If goodbad is non-zero, luck increases the roll, if zero, it decreases.
165			* Generally, op should be the player/caster/hitter requesting the roll,
166			* not the recipient (ie, the poor slob getting hit).
167			* The args are num D size (ie 4d6) [garbled 20010916]
168			*/
169	root	1.9	int
170			die_roll (int num, int size, const object *op, int goodbad)
171			{
172	root	1.55	int min, luck, total, i, gotlucky;
173	root	1.9
174	root	1.55	int diff = size;
175	root	1.9	min = 1;
176			luck = total = gotlucky = 0;
177	root	1.55	int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
178
179	root	1.9	if (size < 2 \|\| diff < 1)
180			{
181			LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
182	root	1.55	return num; /* avoids a float exception */
183	root	1.9	}
184	elmex	1.1
185	root	1.9	if (op->type == PLAYER)
186			luck = op->stats.luck;
187
188			for (i = 0; i < num; i++)
189			{
190	root	1.45	if (rndm (base) < MIN (10, abs (luck)) && !gotlucky)
191	root	1.9	{
192			/* we have a winner */
193			gotlucky++;
194			((luck > 0) ? (luck = 1) : (luck = -1));
195			diff -= luck;
196			if (diff < 1)
197			return (num); /check again /
198			((goodbad) ? (min += luck) : (diff));
199	root	1.45	total += MAX (1, MIN (size, rndm (diff) + min));
200	root	1.9	}
201			else
202	root	1.45	total += rndm (size) + 1;
203	elmex	1.1	}
204	root	1.45
205			return total;
206	elmex	1.1	}
207
208			/* convert materialname to materialtype_t */
209
210	root	1.9	materialtype_t *
211	root	1.47	name_to_material (const shstr &name)
212	elmex	1.1	{
213	root	1.47	for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)
214			if (name == mt->name)
215			return mt;
216	elmex	1.1
217	root	1.62	return 0;
218	elmex	1.1	}
219
220			/* when doing transmutation of objects, we have to recheck the resistances,
221			* as some that did not apply previously, may apply now.
222			*/
223
224	root	1.9	void
225			transmute_materialname (object op, const object change)
226	elmex	1.1	{
227	root	1.9	materialtype_t *mt;
228			int j;
229	elmex	1.1
230	root	1.9	if (op->materialname == NULL)
231			return;
232	elmex	1.1
233	root	1.9	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
234			return;
235
236	root	1.26	if (!op->is_armor ())
237	root	1.9	return;
238
239			mt = name_to_material (op->materialname);
240			if (!mt)
241			{
242	root	1.58	LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->archname, &op->name, &op->materialname);
243	root	1.9	return;
244			}
245
246			for (j = 0; j < NROFATTACKS; j++)
247			if (op->resist[j] == 0 && change->resist[j] != 0)
248			{
249			op->resist[j] += mt->mod[j];
250			if (op->resist[j] > 100)
251			op->resist[j] = 100;
252			if (op->resist[j] < -100)
253			op->resist[j] = -100;
254			}
255	elmex	1.1	}
256
257			/* set the materialname and type for an item */
258	root	1.9	void
259			set_materialname (object op, int difficulty, materialtype_t nmt)
260	elmex	1.1	{
261	root	1.9	materialtype_t mt, lmt;
262
263			if (op->materialname != NULL)
264			return;
265	elmex	1.1
266	root	1.9	if (nmt == NULL)
267			{
268			lmt = NULL;
269	root	1.61
270	root	1.47	for (mt = materialt; mt && mt->next; mt = mt->next)
271	root	1.61	if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
272			difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
273			{
274			lmt = mt;
275			if (!(op->is_weapon () \|\| op->is_armor ()))
276	root	1.9	break;
277	root	1.61	}
278	root	1.9	}
279			else
280	root	1.61	lmt = nmt;
281	elmex	1.1
282	root	1.9	if (lmt != NULL)
283			{
284	root	1.26	if (op->stats.dam && op->is_weapon ())
285	root	1.9	{
286			op->stats.dam += lmt->damage;
287			if (op->stats.dam < 1)
288			op->stats.dam = 1;
289			}
290	root	1.46
291	root	1.9	if (op->stats.sp && op->type == BOW)
292			op->stats.sp += lmt->sp;
293	root	1.26	if (op->stats.wc && op->is_weapon ())
294	root	1.9	op->stats.wc += lmt->wc;
295	root	1.26	if (op->is_armor ())
296	root	1.9	{
297			if (op->stats.ac)
298			op->stats.ac += lmt->ac;
299	root	1.61
300			for (int j = 0; j < NROFATTACKS; j++)
301	root	1.9	if (op->resist[j] != 0)
302			{
303			op->resist[j] += lmt->mod[j];
304			if (op->resist[j] > 100)
305			op->resist[j] = 100;
306			if (op->resist[j] < -100)
307			op->resist[j] = -100;
308			}
309			}
310	root	1.61
311	root	1.46	op->materialname = lmt->name;
312	root	1.9	/* dont make it unstackable if it doesn't need to be */
313	root	1.26	if (op->is_weapon () \|\| op->is_armor ())
314	root	1.9	{
315			op->weight = (op->weight * lmt->weight) / 100;
316			op->value = (op->value * lmt->value) / 100;
317	root	1.2	}
318	elmex	1.1	}
319			}
320
321			/*
322			* Strip out the media tags from a String.
323			* Warning the input string will contain the result string
324			*/
325	root	1.9	void
326			strip_media_tag (char *message)
327			{
328			int in_tag = 0;
329			char *dest;
330			char *src;
331
332			src = dest = message;
333			while (*src != '\0')
334			{
335			if (*src == '[')
336			{
337			in_tag = 1;
338			}
339			else if (in_tag && (*src == ']'))
340			in_tag = 0;
341			else if (!in_tag)
342			{
343			dest = src;
344			dest++;
345			}
346			src++;
347			}
348			*dest = '\0';
349			}
350
351			const char *
352			strrstr (const char haystack, const char needle)
353			{
354			const char *lastneedle;
355
356			lastneedle = NULL;
357			while ((haystack = strstr (haystack, needle)) != NULL)
358			{
359			lastneedle = haystack;
360			haystack++;
361	elmex	1.1	}
362	root	1.9	return lastneedle;
363
364	elmex	1.1	}
365	root	1.9
366	elmex	1.1	#define EOL_SIZE (sizeof("\n")-1)
367	root	1.9	void
368			strip_endline (char *buf)
369			{
370			if (strlen (buf) < sizeof ("\n"))
371			{
372			return;
373	elmex	1.1	}
374	root	1.9	if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
375			buf[strlen (buf) - EOL_SIZE] = '\0';
376	elmex	1.1	}
377
378			/**
379			* Replace in string src all occurrences of key by replacement. The resulting
380			* string is put into result; at most resultsize characters (including the
381			* terminating null character) will be written to result.
382			*/
383	root	1.9	void
384			replace (const char src, const char key, const char replacement, char result, size_t resultsize)
385	elmex	1.1	{
386	root	1.9	size_t resultlen;
387			size_t keylen;
388	elmex	1.1
389	root	1.9	/* special case to prevent infinite loop if key==replacement=="" */
390			if (strcmp (key, replacement) == 0)
391			{
392			snprintf (result, resultsize, "%s", src);
393			return;
394			}
395
396			keylen = strlen (key);
397
398			resultlen = 0;
399			while (*src != '\0' && resultlen + 1 < resultsize)
400			{
401			if (strncmp (src, key, keylen) == 0)
402	root	1.2	{
403	root	1.9	snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
404			resultlen += strlen (result + resultlen);
405			src += keylen;
406	root	1.2	}
407	root	1.9	else
408	root	1.2	{
409	root	1.9	result[resultlen++] = *src++;
410	root	1.2	}
411	root	1.9	}
412			result[resultlen] = '\0';
413	elmex	1.1	}
414
415			/**
416			* Taking a string as an argument, mutate it into a string that looks like a list.
417			* a 'list' for the purposes here, is a string of items, seperated by commas, except
418			* for the last entry, which has an 'and' before it, and a full stop (period) after it.
419			* This function will also strip all trailing non alphanumeric characters.
420			* It does not insert an oxford comma.
421			*/
422
423	root	1.9	void
424			make_list_like (char *input)
425			{
426			char *p, tmp[MAX_BUF];
427			int i;
428
429			if (!input \|\| strlen (input) > MAX_BUF - 5)
430	elmex	1.1	return;
431	root	1.9	/* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
432
433			strncpy (tmp, input, MAX_BUF - 5);
434			/trim all trailing commas, spaces etc. /
435			for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
436			tmp[i] = '\0';
437	root	1.11
438	root	1.9	strcat (tmp, ".");
439
440			p = strrchr (tmp, ',');
441			if (p)
442			{
443			*p = '\0';
444			strcpy (input, tmp);
445			p++;
446			strcat (input, " and");
447			strcat (input, p);
448			}
449			else
450			strcpy (input, tmp);
451	root	1.11
452	root	1.9	return;
453	elmex	1.1	}
454	root	1.3
455	root	1.14	/////////////////////////////////////////////////////////////////////////////
456
457	root	1.37	void
458			fork_abort (const char *msg)
459			{
460			if (!fork ())
461			{
462			signal (SIGABRT, SIG_DFL);
463	root	1.52	// try to put corefiles into a subdirectory, if existing, to allow
464			// an administrator to reduce the I/O load.
465			chdir ("cores");
466	root	1.37	abort ();
467			}
468
469	root	1.38	LOG (llevError, "fork abort: %s\n", msg);
470	root	1.37	}
471	root	1.38
472	root	1.25	void *salloc_ (int n) throw (std::bad_alloc)
473	root	1.10	{
474	root	1.44	#ifdef PREFER_MALLOC
475			void *ptr = malloc (n);
476			#else
477	root	1.25	void *ptr = g_slice_alloc (n);
478	root	1.44	#endif
479	root	1.13
480	root	1.23	if (!ptr)
481	root	1.13	throw std::bad_alloc ();
482	root	1.4
483	root	1.23	return ptr;
484			}
485
486	root	1.25	void salloc_ (int n, void src) throw (std::bad_alloc)
487	root	1.23	{
488	root	1.25	void *ptr = salloc_ (n);
489	root	1.23
490	root	1.24	if (src)
491	root	1.25	memcpy (ptr, src, n);
492	root	1.24	else
493	root	1.25	memset (ptr, 0, n);
494	root	1.23
495			return ptr;
496	root	1.3	}
497	root	1.11
498			void assign (char dst, const char src, int maxlen)
499			{
500			if (!src)
501			src = "";
502
503			int len = strlen (src);
504
505			if (len >= maxlen - 1)
506			{
507			if (maxlen <= 4)
508			{
509			memset (dst, '.', maxlen - 1);
510			dst [maxlen - 1] = 0;
511			}
512			else
513			{
514			memcpy (dst, src, maxlen - 4);
515			memcpy (dst + maxlen - 4, "...", 4);
516			}
517			}
518			else
519			memcpy (dst, src, len + 1);
520			}
521
522	root	1.51	const std::string
523			format (const char *format, ...)
524			{
525			int len;
526
527			{
528			char buf[128];
529
530			va_list ap;
531			va_start (ap, format);
532			len = vsnprintf (buf, sizeof (buf), format, ap);
533			va_end (ap);
534
535			assert (len >= 0); // shield againstz broken vsnprintf's
536
537			// was our static buffer short enough?
538			if (len < sizeof (buf))
539			return std::string (buf, len);
540			}
541
542			{
543			// longer, try harder
544			char *buf = salloc<char> (len + 1);
545
546			va_list ap;
547			va_start (ap, format);
548			vsnprintf (buf, len + 1, format, ap);
549			va_end (ap);
550
551			const std::string s (buf, len);
552			sfree<char> (buf, len + 1);
553
554			return buf;
555			}
556			}
557
558	root	1.23	tstamp now ()
559			{
560			struct timeval tv;
561
562			gettimeofday (&tv, 0);
563			return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
564			}
565	root	1.17
566	root	1.32	int
567			similar_direction (int a, int b)
568			{
569			if (!a \|\| !b)
570			return 0;
571
572			int diff = (b - a) & 7;
573			return diff <= 1 \|\| diff >= 7;
574			}
575
576	root	1.48	/* crc32 0xdebb20e3 table and supplementary functions. */
577			extern const uint32_t crc_32_tab[256] =
578			{
579			0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
580			0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
581			0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
582			0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
583			0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
584			0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
585			0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
586			0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
587			0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
588			0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
589			0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
590			0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
591			0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
592			0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
593			0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
594			0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
595			0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
596			0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
597			0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
598			0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
599			0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
600			0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
601			0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
602			0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
603			0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
604			0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
605			0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
606			0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
607			0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
608			0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
609			0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
610			0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
611			0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
612			0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
613			0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
614			0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
615			0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
616			0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
617			0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
618			0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
619			0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
620			0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
621			0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
622			0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
623			0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
624			0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
625			0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
626			0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
627			0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
628			0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
629			0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
630			0x2d02ef8dL
631			};
632
633