text: 
  #ifndef HAVE_STPCPY
  char *
  stpcpy(char *a,const char *b)
  {
      while( *b )
  	*a++ = *b++;
      *a = 0;
  
      return (char*)a;
  }
  #endif
  
  
  #ifndef HAVE_STRSEP
  /* code taken from glibc-2.2.1/sysdeps/generic/strsep.c */
  char *
  strsep (char **stringp, const char *delim)
  {
    char *begin, *end;
  
    begin = *stringp;
    if (begin == NULL)
      return NULL;
  
    /* A frequent case is when the delimiter string contains only one
       character.  Here we don't need to call the expensive `strpbrk'
       function and instead work using `strchr'.  */
    if (delim[0] == '\0' || delim[1] == '\0')
      {
        char ch = delim[0];
  
        if (ch == '\0')
          end = NULL;
        else
          {
            if (*begin == ch)
              end = begin;
            else if (*begin == '\0')
              end = NULL;
            else
              end = strchr (begin + 1, ch);
          }
      }
    else
      /* Find the end of the token.  */
      end = strpbrk (begin, delim);
  
    if (end)
      {
        /* Terminate the token and set *STRINGP past NUL character.  */
        *end++ = '\0';
        *stringp = end;
      }
    else
      /* No more delimiters; this is the last token.  */
      *stringp = NULL;
  
    return begin;
  }
  #endif /*HAVE_STRSEP*/
  
  /*  #ifndef HAVE_STRLWR */
  /*  char * */
  /*  strlwr(char *s) */
  /*  { */
  /*      char *p; */
  /*      for(p=s; *p; p++ ) */
  /*  	*p = tolower(*p); */
  /*      return s; */
  /*  } */
  /*  #endif */
  
  #ifndef HAVE_STRCASECMP
  int
  strcasecmp( const char *a, const char *b )
  {
      for( ; *a && *b; a++, b++ ) {
  	if( *a != *b && toupper(*a) != toupper(*b) )
  	    break;
      }
      return *(const byte*)a - *(const byte*)b;
  }
  #endif
  
  /* My Break ---------------------------------------- */
  
  #if defined(__cplusplus)
  extern "C"
  {
  #endif
  
  #define si(y,x,k,c) (s(y,c) = word_in(x, c) ^ (k)[c])
  #define so(y,x,c)   word_out(y, c, s(x,c))
  
  #if defined(ARRAYS)
  #define locals(y,x)     x[4],y[4]
  #else
  #define locals(y,x)     x##0,x##1,x##2,x##3,y##0,y##1,y##2,y##3
  #endif
  
  #define l_copy(y, x)    s(y,0) = s(x,0); s(y,1) = s(x,1); \
                          s(y,2) = s(x,2); s(y,3) = s(x,3);
  #define state_in(y,x,k) si(y,x,k,0); si(y,x,k,1); si(y,x,k,2); si(y,x,k,3)
  #define state_out(y,x)  so(y,x,0); so(y,x,1); so(y,x,2); so(y,x,3)
  #define round(rm,y,x,k) rm(y,x,k,0); rm(y,x,k,1); rm(y,x,k,2); rm(y,x,k,3)
  
  #if defined(ENCRYPTION) && !defined(AES_ASM)
  
  /* Visual C++ .Net v7.1 provides the fastest encryption code when using
     Pentium optimiation with small code but this is poor for decryption
     so we need to control this with the following VC++ pragmas
  */
  
  #if defined(_MSC_VER)
  #pragma optimize( "s", on )
  #endif
  
  /* Given the column (c) of the output state variable, the following
     macros give the input state variables which are needed in its
     computation for each row (r) of the state. All the alternative
     macros give the same end values but expand into different ways
     of calculating these values.  In particular the complex macro
     used for dynamically variable block sizes is designed to expand
     to a compile time constant whenever possible but will expand to
     conditional clauses on some branches (I am grateful to Frank
     Yellin for this construction)
  */
  
  #define fwd_var(x,r,c)\
   ( r == 0 ? ( c == 0 ? s(x,0) : c == 1 ? s(x,1) : c == 2 ? s(x,2) : s(x,3))\
   : r == 1 ? ( c == 0 ? s(x,1) : c == 1 ? s(x,2) : c == 2 ? s(x,3) : s(x,0))\
   : r == 2 ? ( c == 0 ? s(x,2) : c == 1 ? s(x,3) : c == 2 ? s(x,0) : s(x,1))\
   :          ( c == 0 ? s(x,3) : c == 1 ? s(x,0) : c == 2 ? s(x,1) : s(x,2)))
  
  
  