/*
 * randw.c
 * This Program won't work on the sparc, where there's no concept of I/O space.
 * Tested with 1.2 and 2.0 on the x86
 *
 * Important: this program won't work without the compiler-option -O or -02 ...
 * and this program can only be run by a superuser.
 *
 * Dieses Programm liest die einfache ISA-Zufallswort-Karte staendig aus und erstellt
 * standarmaessig aus diesen random short die byte_anz grosse Datei
 * /usr/local/ftp/pub/randw.out, die zyklisch mit den neuesten Zufallsworten ueberschrieben wird.
 * Mit der Option d werden die Werte direkt ausgegeben, mit der Option s werden
 * die Daten mit Wartezeiten von einigen Mikrosekunden eingelesen und ausgegeben (high quality by
 * slow speed) und ansonsten werden sie vohrer so transformiert, dass Anzahl der
 * binaeren Nullen der Anzahl der binaeren Einsen angenaehert wird und anschliessend
 * wie im Pseudozufallszahlengenerator durchmischt; dieser Modus ist fehlertolerant,
 * d. h. falls die Karte fehlt oder immer dieselben Werte liefert, werden
 * Pseudozufallszahlen hoher Qualitaet produziert. Sehr lange konstante Teil-Folgen
 * sind dann aber relativ selten; z. B. sind konstante Teil-Folgen der Laenge 1648
 * um rund 50% seltener als bei einer völlig zufaelligen Bit-Folge. Dieser Fall tritt aber
 * bei der typischen Datenrate von 400kB/s im worst case nur alle 9.17*10^209 Jahre auf.
 * Die Nummer des aktuellen Zyklus seit dem Programmstart (und nicht mehr)
 * enthaelt die Datei /usr/local/ftp/pub/randw.log in Form eines unsigned int.
 * Dieses Programm wurde unter Linux erstellt und erfolgreich getestet; es
 * kann leicht nach DOS u. a. portiert werden.
 *

 Copyright (C) 1999 Rolf Freitag

 This Program is freeware; it can be used without payment, the author retains
 all rights.

 This Program is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRENTY; without even the implied warrenty of MERCHANTABILITY of
 FITNESS FOR A PARTICULAR PURPOSE.
*/

#ifdef __sparc__
#   error "This Program can't run on the Sparc platform"
#endif

#include <errno.h>                                /* error codes */
#include <sys/io.h>
#include <sys/stat.h>
//#include <asm/io.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
#include <signal.h>
#include <linux/delay.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <iso646.h>

// simple version number
#define SOFTWARE_VERSION_NUMBER 1.0

#define usec_anz ((int) 1)                        /* Wartezeit in Mikrosekunden f. usleep in  slow. Mit 1 erhaelt man rd. 10kB/s, denn */
/* inw erfordert je rd. 5 Mikrosekunden, das Auslesen von /proc/loadavg ist noch viel langsamer */
/* und usleep(0) benötigt auch einige Mikrosekunden */
/* Die Wartezeit ist umgekehrt proportional dem Bustakt u. betraegt */
/* auf einem 100MHz-Board rd. 5 Mikrosekunden (die Karte wird rd. 800ns */
/* angesprochen). */
#define IA 16807
#define IM 2147483647
#define IQ 127773
#define IR 2836
#define pa ((unsigned) 0x1A0)                     /* ISA-Karten-Adresse, default J1=0, J2=1 : 0x1A0=416 */
/* J1=0, J2=0 : 0x120=288                             */
/* J1=1, J2=0 : 0x160=352                             */
/* J1=1, J2=1 : 0x1E0=480                             */

union Tfast                                       /* Typ z. schnellen zwischenspeichern */
{
  unsigned int i;
  unsigned short s[2];
  unsigned char c[4];
};
static FILE *ofp1 = NULL;                         /* Zufallsbit-Ausgabedatei (Output-File-Pointer) */
static FILE *ofp2 = NULL;                         /* log-Datei ( unsigned int - Nr. der Ausgabe-Datei ) */
static void *v = NULL;                            /* z. Schliessen von /proc/loadavg */
                                                  /* 5 1/4 " - Disc-Grösse : 1457152 */
static unsigned int byteanz = ((unsigned int) 1457152);
static unsigned int wortanz = 0;
static unsigned int intanz = 0;
static unsigned int ll = 0;                       /* Zahl von ofp2         */
static int ssm = 0;                               /* single-shot or continous mode */
static unsigned int next = 0;                     /* f. Pseudozufalls-Zahl */
static int idum = 0;
static unsigned int ra = 0;                       /* zwischen-Zufalls-Variable */
const int m1 = 2147483647, m2 = 2145483479,
a12 = 63308, q12 = 33921, r12 = 12979, a13 = -183326, q13 = 11714, r13 = 2883, a21 = 86098, q21 = 24919, r21 = 7417, a23 = -539608, q23 = 3976, r23 = 2071;
static int x10 = 0, x11 = 0, x12 = 0, x20 = 0, x21 = 0, x22 = 0, h = 0, p12 = 0, p13 = 0, p21 = 0, p23 = 0;

void
sig_handler (int sig)
{
  printf ("\aSignal %d - program exiting... \r\n", sig);
  if (v != NULL)
    fclose (v);
  if (ofp1 != NULL)
    fclose (ofp1);
  if (ofp2 != NULL)
    fclose (ofp2);
  ioperm (pa, 2, 0);
  exit (0);
}                                                 /* sig_handler */


void
direct ()                                         /* direkte Ausgabe */
{
  unsigned int li = 0;
  union Tfast fast;
  unsigned short us = 0;

  for (;;)
  {
    rewind (ofp2);
    fprintf (ofp2, "%ud\n", ll);
    fflush (ofp2);
    rewind (ofp1);
    for (li = 1; li <= byteanz;)
    {
      if (byteanz - li >= 1)                      /* Schreiben vor dem lezten Byte (byteanz) */
      {
        us = inw (pa);                            /* direktes Einlesen */
        fast.s[0] = us;
                                                  /* direktes Schreiben ohne die Reihenfolge zu aendern */
        fwrite (&fast.s[0], sizeof (unsigned short), 1, ofp1);
        fflush (ofp1);
        li += 2;
      }
      if (byteanz >= li)
      {
        us = inw (pa);                            /* direktes Einlesen */
        fast.s[0] = us;
                                                  /* direktes Schreiben ohne die Reihenfolge zu aendern */
        fwrite (&fast.c[0], sizeof (unsigned char), 1, ofp1);
        li++;
      }
    }
    ll++;
    if (ssm)
      break;
  }
}                                                 /* direct */


void
fastest_medium_quality ()                         /* arbeitet auch ohne funktionierende Karte brauchbar */
{
  FILE *fp = NULL;                                /* fuer /dev/urandom, denn sonst (als lokale Funktion) waere urandom() ca. 1000 mal langsamer */
  int i1 = 0, k = 0;                              /* fuer minimalen Standard Generator nach Lewis, Goodman, Miller, 1969 */
  unsigned char c = 0;                            /* zum Auslesen von /dev/urandom           */
  unsigned int li = 0;
  union Tfast fast;
  unsigned short w0 = 0, w1 = 0;                  /* 16 T-FF-Eingangswerte          */
  unsigned short w2 = 0xffff, v2 = 0x0000;        /* 16 T-FF-Zustaende      */

  fp = fopen ("/dev/urandom", "r");
  if (ferror (fp))
  {
    perror ("\a can't open /dev/urandom ");
    exit (errno);
  }
  fscanf (fp, "%c", &c);
  i1 = ((unsigned int) c);                        /* initialisieren */
  fscanf (fp, "%c", &c);
  i1 |= ((unsigned int) c) << 8;
  fscanf (fp, "%c", &c);
  i1 |= ((unsigned int) c) << 16;
  fscanf (fp, "%c", &c);
  i1 |= ((unsigned int) c) << 24;
  fclose (fp);
  if (i1);
  else
    i1 = time (NULL);
  for (;;)
  {
    w1 = inw (pa);                                /* w1 initialisieren */
    rewind (ofp2);
    fprintf (ofp2, "%ud\n", ll);
    fflush (ofp2);
    rewind (ofp1);
    for (li = 1; li <= intanz; li++)
    {
      ra += 69069;
      ra++;
      switch ((ra >> 15) & 0x00000003)            /* pseudo-random inverting before toggle */
      {
        case 0:
          w0 = inw (pa);                          /* Eingabe auf die 2 T-FFs */
          w2 ^= w0 & ~w1;
          v2 ^= ~w0 & w1;
          w1 = w0;
          w0 = inw (pa);
          w2 ^= w0 & ~w1;
          v2 ^= ~w0 & w1;
          w1 = w0;
          break;
        case 1:
          w0 = inw (pa);                          /* Eingabe auf die 2 T-FFs */
          w0 = ~w0;
          w2 ^= w0 & ~w1;
          v2 ^= ~w0 & w1;
          w1 = w0;
          w0 = inw (pa);
          w2 ^= w0 & ~w1;
          v2 ^= ~w0 & w1;
          w1 = w0;
          break;
        case 2:
          w0 = inw (pa);                          /* Eingabe auf die 2 T-FFs */
          w2 ^= w0 & ~w1;
          v2 ^= ~w0 & w1;
          w1 = w0;
          w0 = inw (pa);
          w0 = ~w0;
          w2 ^= w0 & ~w1;
          v2 ^= ~w0 & w1;
          w1 = w0;
          break;
        case 3:
          w0 = inw (pa);                          /* Eingabe auf die 2 T-FFs */
          w0 = ~w0;
          w2 ^= w0 & ~w1;
          v2 ^= ~w0 & w1;
          w1 = w0;
          w0 = inw (pa);
          w0 = ~w0;
          w2 ^= w0 & ~w1;
          v2 ^= ~w0 & w1;
          w1 = w0;
          break;
        default:
          fprintf (ofp1, "program panic");
          break;                                  /* should never happen */
      }
      /* EXOR fuer worsest case (Karte funktioniert zunaechst und versagt ploetzlich, die T-FFs verbleiben
         in einem unguenstigen Zustand (d. h. mehr oder weniger als 16 binaere Nullen in v2 und w2)) */
      fast.s[0] = v2;
      fast.s[1] = w2;
      k = i1 / IQ;
      i1 = IA * (i1 - k * IQ) - IR * k;
      if (i1 < 0)
        i1 += IM;
      fast.i ^= i1;
                                                  /* direktes Schreiben ohne die Reihenfolge zu aendern */
      fwrite (&fast.i, sizeof (unsigned int), 1, ofp1);
      fflush (ofp1);
    }
    ll++;
    if (ssm)
      break;
  }
}                                                 /* fastest_medium_quality */


void
slow ()
{
  int i = 0, load = 0, usec = 0;
  unsigned short stmp = 0;
  unsigned int li = 0;
  union Tfast fast;
  FILE *f = NULL;

  f = fopen ("/proc/loadavg", "r");
  if (ferror (f))
  {
    perror ("\a can't open /proc/loadavg");
    exit (errno);
  }
  v = f;
  for (;;)
  {
    rewind (ofp2);
    fprintf (ofp2, "%ud\n", ll);
    fflush (ofp2);
    rewind (ofp1);
    usec = 100 * usec_anz;                        /* prepare for a later division */
    if (f)
      fscanf (f, "%d.%d", &load, &i);             /* scan of the loadaverage */
    else
      load = i = 0;
    load = 100 + load * 100 + i;
    for (li = 1; li <= intanz; li++)
    {
      usleep (usec / load);                       /* wartet usec mikrosekunden */
      fast.s[0] = 0;
      for (stmp = 0x0001; stmp <= 0x8000; stmp <<= 1)
      {
        fast.s[0] += inw (pa) & stmp;
        usleep (usec / load);                     /* wartet usec mikrosekunden */
        if (stmp == 0x8000)
          break;
      }
      fast.s[1] = 0;
      for (stmp = 0x0001; stmp <= 0x8000; stmp <<= 1)
      {
        fast.s[1] += inw (pa) & stmp;             /* bitweises Einlesen */
        usleep (usec / load);                     /* wartet usec mikrosekunden */
        if (stmp == 0x8000)
          break;
      }
      fwrite (&fast.i, sizeof (int), 1, ofp1);    /* direktes Schreiben ohne die Reihenfolge zu aendern */
      fflush (ofp1);
    }
    ll++;
    if (ssm)
      break;
  }
}                                                 /* slow */


unsigned int
ran00 ()
{
  unsigned int itmp;

  h = x10 / q13;
  p13 = a13 * (h * q13 - x10) - h * r13;
  h = x11 / q12;
  p12 = a12 * (x11 - h * q12) - h * r12;
  if (p13 < 0)
    p13 += m1;
  if (p12 < 0)
    p12 += m1;
  x10 = x11;
  x11 = x12;
  x12 = p12 - p13;
  if (x12 < 0)
    x12 += m1;
  h = x20 / q23;
  p23 = a23 * (h * q23 - x20) - h * r23;
  h = x22 / q21;
  p21 = a21 * (x22 - h * q21) - h * r21;
  if (p23 < 0)
    p23 += m2;
  if (p21 < 0)
    p21 += m2;
  x20 = x21;
  x21 = x22;
  x22 = p21 - p23;
  if (x22 < 0)
    x22 += m2;
  if (x12 < x22)
    itmp = x12 - x22 + m1;
  else
    itmp = x12 - x22;
  return itmp;                                    /* pseudorandom 31-Bit-Integer */
}                                                 /* ran00 */


void
high_quality ()                                   /* default, fehlertollerant (falls bei fehlender Karte nur ffff eingelesen wird) */
{                                                 /* benötigt ca. 30 Takte/Byte, d. h. bei Einlesen mit 17MHz waere ein PII 500 vermutl. ganz ausgelastet */
  FILE *fp = NULL;                                /* fuer /dev/urandom, denn sonst (als lokale Funktion) waere urandom() ca. 1000 mal langsamer */
  int i1 = 0, k = 0;
  unsigned char c = 0;                            /* zum Auslesen von /dev/urandom           */
                                                  /* Laufvariablen                           */
  unsigned int m = 0, n = 0, itmp1 = 0, itmp2 = 0, count1 = 0;
  unsigned int zip1 = 0, zi = 0, zim1 = 0;        /* f. erweiterten Kongruenzgenerator       */
  unsigned short w0 = 0, w1 = 0;                  /* 16 T-FF-Eingangswerte                   */
  unsigned short w2 = 0xffff, v2 = 0x0000;        /* 16 T-FF-Zustaende                        */
  unsigned short ush = 1;
  unsigned int ui[32768] =                        /* Bit-Felder z. Bitweisen mixen, zum Entkorrelieren */
  {
    0
  };
  unsigned int uo = 0;                            /* Bit-Feld z. Zwischenspeichern */
  unsigned int uc = 0;                            /* Laufvariable                            */
  unsigned int j = 0;                             /* z. Zwischenspeichern                    */
  union Tfast h1[15];                             /* Union z. schellen Zischenspeichern nach dem Bit-Mixen */

  /* Initialisierungen */

  fp = fopen ("/dev/urandom", "r");
  if (ferror (fp))
  {
    perror ("\a can't open /dev/urandom ");
    exit (errno);
  }
  fscanf (fp, "%c", &c);
  i1 = ((unsigned int) c);                        /* initialisieren */
  fscanf (fp, "%c", &c);
  i1 ^= ((unsigned int) c) << 8;
  fscanf (fp, "%c", &c);
  i1 |= ((unsigned int) c) << 16;
  fscanf (fp, "%c", &c);
  i1 |= ((unsigned int) c) << 24;
  if (i1);
  else
    i1 = 13;
  fscanf (fp, "%c", &c);
  zip1 = ((unsigned int) c);                      /* initialisieren */
  fscanf (fp, "%c", &c);
  zip1 ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  zip1 |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  zip1 |= ((unsigned int) c) << 23;
  if (zip1);
  else
    zip1 = 13;
  zip1 %= 0x7fffffff;
  fscanf (fp, "%c", &c);
  zi = ((unsigned int) c);                        /* initialisieren */
  fscanf (fp, "%c", &c);
  zi ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  zi |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  zi |= ((unsigned int) c) << 23;
  if (zi);
  else
    zi = 17;
  zi %= 0x7fffffff;
  fscanf (fp, "%c", &c);
  zim1 = ((unsigned int) c);                      /* initialisieren */
  fscanf (fp, "%c", &c);
  zim1 ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  zim1 |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  zim1 |= ((unsigned int) c) << 23;
  if (zim1);
  else
    zim1 = 37;
  zim1 %= 0x7fffffff;
  fscanf (fp, "%c", &c);
  x10 = ((unsigned int) c);                       /* initialisieren */
  fscanf (fp, "%c", &c);
  x10 ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  x10 |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  x10 |= ((unsigned int) c) << 23;
  if (x10);
  else
    x10 = 43;
  fscanf (fp, "%c", &c);
  x11 = ((unsigned int) c);                       /* initialisieren */
  fscanf (fp, "%c", &c);
  x11 ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  x11 |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  x11 |= ((unsigned int) c) << 23;
  if (x11);
  else
    x11 = 89;
  fscanf (fp, "%c", &c);
  x12 = ((unsigned int) c);                       /* initialisieren */
  fscanf (fp, "%c", &c);
  x12 ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  x12 |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  x12 |= ((unsigned int) c) << 23;
  if (x12);
  else
    x12 = 83;
  fscanf (fp, "%c", &c);
  x20 = ((unsigned int) c);                       /* initialisieren */
  fscanf (fp, "%c", &c);
  x20 ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  x20 |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  x20 |= ((unsigned int) c) << 23;
  if (x20);
  else
    x20 = 79;
  fscanf (fp, "%c", &c);
  x21 = ((unsigned int) c);                       /* initialisieren */
  fscanf (fp, "%c", &c);
  x21 ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  x21 |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  x21 |= ((unsigned int) c) << 23;
  if (x21);
  else
    x21 = 73;
  fscanf (fp, "%c", &c);
  x22 = ((unsigned int) c);                       /* initialisieren */
  fscanf (fp, "%c", &c);
  x22 ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  x22 |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  x22 |= ((unsigned int) c) << 23;
  if (x22);
  else
    x22 = 71;
  fscanf (fp, "%c", &c);
  h = ((unsigned int) c);                         /* initialisieren */
  fscanf (fp, "%c", &c);
  h ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  h |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  h |= ((unsigned int) c) << 23;
  if (h);
  else
    h = 67;
  fscanf (fp, "%c", &c);
  p12 = ((unsigned int) c);                       /* initialisieren */
  fscanf (fp, "%c", &c);
  p12 ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  p12 |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  p12 |= ((unsigned int) c) << 23;
  if (p12);
  else
    p12 = 61;
  fscanf (fp, "%c", &c);
  p13 = ((unsigned int) c);                       /* initialisieren */
  fscanf (fp, "%c", &c);
  p13 ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  p13 |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  p13 |= ((unsigned int) c) << 23;
  if (p13);
  else
    p13 = 59;
  fscanf (fp, "%c", &c);
  p21 = ((unsigned int) c);                       /* initialisieren */
  fscanf (fp, "%c", &c);
  p21 ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  p21 |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  p21 |= ((unsigned int) c) << 23;
  if (p21);
  else
    p21 = 53;
  fscanf (fp, "%c", &c);
  p23 = ((unsigned int) c);                       /* initialisieren */
  fscanf (fp, "%c", &c);
  p23 ^= ((unsigned int) c) << 7;
  fscanf (fp, "%c", &c);
  p23 |= ((unsigned int) c) << 15;
  fscanf (fp, "%c", &c);
  p23 |= ((unsigned int) c) << 23;
  if (p23);
  else
    p23 = 47;
  w1 = inw (pa);                                  /* w1 initialisieren */
  for (n = 0; n < 32768; n++)
  {
    fscanf (fp, "%c", &c);
    ui[n] = ((unsigned int) c);                   /* ui initialisieren */
    fscanf (fp, "%c", &c);
    ui[n] |= ((unsigned int) c) << 8;
    fscanf (fp, "%c", &c);
    ui[n] |= ((unsigned int) c) << 16;
    fscanf (fp, "%c", &c);
    ui[n] |= ((unsigned int) c) << 24;
    /* printf("ui=%x\n",ui[n]); */
  }
  fclose (fp);
  rewind (ofp2);
  fprintf (ofp2, "%u\n", ll);                     /* ll (=0) ausgeben */
  fflush (ofp2);
  for (count1 = 0; count1 < 3000; count1++)       /* warming up */
  {
    for (n = 0; n < 15; n++)                      /* Einlesen von 30 Wörtern */
    {
      w0 = inw (pa);                              /* Eingabe auf die 2 T-FFs: bei 1-Bit-Mix ergibt sich so binaer 0101... */
      w2 ^= w0 & ~w1;
      v2 ^= ~w0 & w1;
      w1 = w0;
      w0 = inw (pa);
      w2 ^= w0 & ~w1;
      v2 ^= ~w0 & w1;
      w1 = w0;
      k = i1 / IQ;
      i1 = IA * (i1 - k * IQ) - IR * k;
      if (i1 < 0)
        i1 += IM;
      v2 ^= i1;
      k = i1 / IQ;
      i1 = IA * (i1 - k * IQ) - IR * k;
      if (i1 < 0)
        i1 += IM;
      w2 ^= i1;
      zip1 = (1999 * zi + 4444 * zim1) % 0x7fffffff;
      zim1 = zi;
      zi = zip1;
      itmp1 = zip1 & 0x00007fff;
      ra *= 69069;
      ra++;
      itmp2 = ra >> 27;
      if (ui[itmp1] & (j = (0x00000001 << itmp2)))
        uo = 0x00000001;
      else
        uo = 0x00000000;
      if (w2 & 0x0001)                            /* w2 auslesen */
        ui[itmp1] |= j;                           /* aus w2 ausgelesenes Bit setzen */
      else
        ui[itmp1] &= ~j;                          /* ausgelesenes Bit löschen */
      itmp1 = (zip1 >> 15) & 0x00007fff;
      ra *= 69069;
      ra++;
      itmp2 = ra >> 27;
      if (ui[itmp1] & (j = (0x00000001 << itmp2)))
        uo |= 0x00000002;
      if (v2 & 0x0001)                            /* v2 auslesen */
        ui[itmp1] |= j;                           /* aus v2 ausgelesenes Bit setzen */
      else
        ui[itmp1] &= ~j;                          /* ausgelesenes Bit löschen */
      uc = 0x00000002;
      ush = 0x0001;
      do
      {
        next = ran00 ();
        do
        {
          uc <<= 1;
          ush <<= 1;
          zip1 = (1999 * zi + 4444 * zim1) % 0x7fffffff;
          zim1 = zi;
          zi = zip1;
          itmp1 = zip1 & 0x00007fff;
          itmp2 = next & 0x0000001f;
          if (ui[itmp1] & (j = (0x00000001 << itmp2)))
            uo |= uc;
          if (w2 & ush)                           /* w2 auslesen */
            ui[itmp1] |= j;                       /* aus w2 ausgelesenes Bit setzen */
          else
            ui[itmp1] &= ~j;                      /* ausgelesenes Bit löschen */
          itmp1 = (zip1 >> 15) & 0x00007fff;
          next >>= 5;
          itmp2 = next & 0x0000001f;              /* um nächstes Bit an anderer Stelle in ui[itmp1] einzufügen */
          uc <<= 1;
          if (ui[itmp1] & (j = (0x00000001 << itmp2)))
            uo |= uc;
          if (v2 & ush)                           /* v2 auslesen */
            ui[itmp1] |= j;                       /* aus ui ausgelesenes Bit setzen */
          else
            ui[itmp1] &= ~j;                      /* ausgelesenes Bit löschen */
          next >>= 5;
        }
        while (uc & 0x7df7df7f);                  /* nach Auslesen von 30 der 31 Bits von */
      }                                           /* ran00() erneuerte Benutzung von ran00() */
      while (uc < 0x80000000);
      h1[n].i = uo;                               /* Zwischenspeichern in h1 */
    }                                             /* for */
  }                                               /* for count1 */
  for (;;)
  {
    for (n = 0; n < 15; n++)                      /* Einlesen von 30 Wörtern */
    {
      w0 = inw (pa);                              /* Eingabe auf die 2 T-FFs: bei 1-Bit-Mix ergibt sich so binaer 0101... */
      w2 ^= w0 & ~w1;
      v2 ^= ~w0 & w1;
      w1 = w0;
      w0 = inw (pa);
      w2 ^= w0 & ~w1;
      v2 ^= ~w0 & w1;
      w1 = w0;
      k = i1 / IQ;
      i1 = IA * (i1 - k * IQ) - IR * k;
      if (i1 < 0)
        i1 += IM;
      v2 ^= i1;
      k = i1 / IQ;
      i1 = IA * (i1 - k * IQ) - IR * k;
      if (i1 < 0)
        i1 += IM;
      w2 ^= i1;
      ra *= 69069;
      ra++;
      zip1 = (1999 * zi + 4444 * zim1) % 0x7fffffff;
      zim1 = zi;
      zi = zip1;
      itmp1 = zip1 & 0x00007fff;
      ra *= 69069;
      ra++;
      itmp2 = ra >> 27;
      if (ui[itmp1] & (j = (0x00000001 << itmp2)))
        uo = 0x00000001;
      else
        uo = 0x00000000;
      if (v2 & 0x0001)                            /* w2 auslesen */
        ui[itmp1] |= j;                           /* aus w2 ausgelesenes Bit setzen */
      else
        ui[itmp1] &= ~j;                          /* ausgelesenes Bit löschen */
      itmp1 = (zip1 >> 15) & 0x00007fff;
      ra *= 69069;
      ra++;
      itmp2 = ra >> 27;
      if (ui[itmp1] & (j = (0x00000001 << itmp2)))
        uo |= 0x00000002;
      if (w2 & 0x0001)                            /* v2 auslesen */
        ui[itmp1] |= j;                           /* aus v2 ausgelesenes Bit setzen */
      else
        ui[itmp1] &= ~j;                          /* ausgelesenes Bit löschen */
      uc = 0x00000002;
      ush = 0x0001;
      do
      {
        next = ran00 ();
        do
        {
          uc <<= 1;
          ush <<= 1;
          zip1 = (1999 * zi + 4444 * zim1) % 0x7fffffff;
          zim1 = zi;
          zi = zip1;
          itmp1 = zip1 & 0x00007fff;
          itmp2 = next & 0x0000001f;
          if (ui[itmp1] & (j = (0x00000001 << itmp2)))
            uo |= uc;
          if (v2 & ush)                           /* w2 auslesen */
            ui[itmp1] |= j;                       /* aus w2 ausgelesenes Bit setzen */
          else
            ui[itmp1] &= ~j;                      /* ausgelesenes Bit löschen */
          itmp1 = (zip1 >> 15) & 0x00007fff;
          next >>= 5;
          itmp2 = next & 0x0000001f;              /* um nächstes Bit an anderer Stelle in ui[itmp1] einzufügen */
          uc <<= 1;
          if (ui[itmp1] & (j = (0x00000001 << itmp2)))
            uo |= uc;
          if (w2 & ush)                           /* v2 auslesen */
            ui[itmp1] |= j;                       /* aus ui ausgelesenes Bit setzen */
          else
            ui[itmp1] &= ~j;                      /* ausgelesenes Bit löschen */
          next >>= 5;
        }
        while (uc & 0x7df7df7f);                  /* nach Auslesen von 30 der 31 Bits von */
      }                                           /* ran00() erneuerte Benutzung von ran00() */
      while (uc < 0x80000000);
      h1[n].i = uo;                               /* Zwischenspeichern in h1 */
    }                                             /* for */
    /* printf ("itmp=%x\n", itmp); */
    /* printf ("ui[lc]=%x, j=%x\n", ui[lc], j); */
    /* printf ("uo=%x\n",uo); */
    /* printf ("ush=%x\n", ush); */
    /* printf ("w2=%x, ui=%x\n",w2, ui[lc]); */
    /* printf ("\nitmp=%d\n", itmp); */
    /* printf ("itmp=%d, uc=%x\n\n", itmp, uc); */
    /* printf ("itmp=%x, j=%x, uo=%x, ui=%x, next=%x\n", itmp, j, uo, ui[((lc - 1 < 0) ? 0 : lc - 1) % N_ui], next); */
    /* printf ("uo=%x, ui=%x", uo, ui[lc % N_ui]); */
    /* printf ("uo=%x, uc=%x, ush=%x, j=%x\n", uo, uc, ush, j); */
    /* printf ("uc=%x\n", uc); */
    /* printf ("uo=%x\n", uo); */
    for (n = 15; n >= 1; n--)
    {
      if (m >= intanz)
      {
        if (ssm)
          goto hq_end;
        rewind (ofp1);
        m = 0;
        ll++;
        rewind (ofp2);
        fprintf (ofp2, "%u\n", ll);
        fflush (ofp2);
      }
      fwrite (&h1[n - 1], sizeof (unsigned int), 1, ofp1);
      m++;
    }
    fflush (ofp1);
  }                                               /* for(;;) */
  hq_end:;
}                                                 /* high_quality */


int
main (const int argc, const char * const argv[])  /* __attribute__ ((__noreturn__)); */
{
  char c1 = '0';
  int i = 0;
  int chm = 1;
  char line1[255] = { '\0' };
  char line2[255] = { '\0' };
  char line3[255] = { '\0' };
  char outname1[255] = "/usr/local/ftp/pub/randw.out";
  char outname2[255] = "/usr/local/ftp/pub/randw.log";

  signal (SIGHUP, sig_handler);
  signal (SIGINT, sig_handler);
  signal (SIGQUIT, sig_handler);
  signal (SIGILL, sig_handler);
  signal (SIGTRAP, sig_handler);
  signal (SIGIOT, sig_handler);
  /*  signal(SIGEMT,  sig_handler); */
  signal (SIGFPE, sig_handler);
  signal (SIGKILL, sig_handler);
  signal (SIGBUS, sig_handler);
  signal (SIGSEGV, sig_handler);
  /*  signal(SIGSYS,  sig_handler); */
  signal (SIGPIPE, sig_handler);
  signal (SIGALRM, sig_handler);
  signal (SIGTERM, sig_handler);
  signal (SIGABRT, sig_handler);

  if ( (argc>1) and not strncmp (argv[1], "-V", 123) )
  {
    fprintf (stdout, "%s version %.1f\n", argv[0], SOFTWARE_VERSION_NUMBER);
    exit ( (argc < 5) ? 0 : -1);
  }
  ra = 5 * ((unsigned long) time (NULL)) + 1;     /* f. Pseudozufalls-Zahl */
  idum = ra * 5 + 1;
  ioperm (pa, 2, 1);
  if ((argc > 4) or (argc < 2))
  {
    fprintf (stderr, "\aUsage: %s [d or s or m] [Output-file-name] [Output-file-size in 4*n%%4 Byte]\n", argv[0]);
    fprintf (stderr, "or: %s -V\n", argv[0]);
    fprintf (stderr, "[] = Optional <> = Parameter Requirement. 1..4 parameters required.\n");
    exit (-1);
  }
  if (argc >= 2)
  {
    sscanf (argv[1], "%s", line1);
    if (sscanf (line1, "%d", &i) == 1);
    else if (strlen (line1) == 1)
      sscanf (line1, "%c", &c1);
    else if (sscanf (line1, "%s", outname1) == 1)
      chm = 0;
  }
  if (argc >= 3)
  {
    sscanf (argv[2], "%s", line2);
    if (sscanf (line2, "%d", &i) == 1);
    else if (strlen (line2) == 1)
      sscanf (line2, "%c", &c1);
    else if (sscanf (line2, "%s", outname1) == 1)
      chm = 0;
  }
  if (argc == 4)
  {
    sscanf (argv[3], "%s", line3);
    if (sscanf (line3, "%d", &i) == 1);
    else if (strlen (line3) == 1)
      sscanf (line3, "%c", &c1);
    else if (sscanf (line3, "%s", outname1) == 1)
      chm = 0;
  }
  if (!(chm))
    strcpy (outname2, "/dev/null");
  if (i)
  {
    byteanz = ((unsigned int) i);
    ssm = 1;
  }
  wortanz = byteanz / 2;
  intanz = byteanz / 4;
  /*  printf ("byteanz = %u\n", byteanz); */
  /*  printf ("c1 = %c\n", c1); */
  /*  printf ("outname1 = %s\n", outname1); */
  /*  printf ("outname2 = %s\n", outname2); */
  ofp1 = fopen (outname1, "w");
  if (ferror (ofp1))
  {
    perror ("\a output-random-file-error ");
    fclose (ofp1);
    exit (errno);
  }
  if (chm)
    chmod (outname1, 01644);                      /* lesen f. alle, schreiben nur f. superuser */
  ofp2 = fopen (outname2, "w");
  if (ferror (ofp2))
  {
    perror ("\a output-log-file-error ");
    fclose (ofp1);
    fclose (ofp2);
    exit (errno);
  }
  if (chm)
    chmod (outname2, 01644);
  if (c1 == 'd')
    direct ();
  else if (c1 == 's')
    slow ();
  else if (c1 == 'm')
    fastest_medium_quality ();
  else
    high_quality ();
  if (ofp1 != NULL)
    fclose (ofp1);
  if (ofp2 != NULL)
    fclose (ofp2);
  ioperm (pa, 2, 0);
  exit (0);
}                                                 /* main */