struct {
char username[20];
char password[36];
uint perm;
uint monies;
uint chickens;
uint id;
dword next;
dword prev;
char info[50];
char office[26];
}





/* This file has been generated by the Hex-Rays decompiler.

   Copyright (c) 2009 Hex-Rays <info@hex-rays.com>



   Detected compiler: GNU C++

*/



#include <defs.h>



#include <stdarg.h>





//-------------------------------------------------------------------------

// Data declarations



extern _UNKNOWN start; // weak

extern char format[]; // idb

extern char aUnableToCreate[]; // idb

extern char aUnableToSetReu[]; // idb

extern char aUnableToBindSo[]; // idb

extern char aUnableToListen[]; // idb

extern char aFailedToFindUs[]; // idb

extern char aDrop_privsFail[]; // idb

extern char aSetgidCurrentG[]; // idb

extern char aSetgidCurrentU[]; // idb

extern char a02x[]; // idb

extern char aS[]; // idb

extern char modes[]; // idb

extern char aSCanTBeOpened_[]; // idb

extern char aS_0[]; // idb

extern char aNodeX[]; // idb

extern char aChickensU[]; // idb

extern char aEggsU[]; // idb

extern char aMoniesU[]; // idb

extern char aIdU[]; // idb

extern char aUsernameS[]; // idb

extern char aInfoS[]; // idb

extern char aOfficeS[]; // idb

extern char aPasswordS[]; // idb

extern char aPermU[]; // idb

extern char aNextX[]; // idb

extern char aPrevX[]; // idb

extern char aLcggedIn[]; // idb

extern char s[]; // idb

extern char aEnterNewUserna[]; // idb

extern char aEnterNewInfo[]; // idb

extern char aEnterNewOffice[]; // idb

extern char aEnterNewPass[]; // idb

extern char aInsertFailed_[]; // idb

extern char aYouCurrentlyHa[]; // idb

extern char aMarketPriceFor[]; // idb

extern char aWouldYouLikeTo[]; // idb

extern char aHowMany_[]; // idb

extern char aUSold[]; // idb

extern char aNotEnoughEggs[]; // idb

extern char aYouCurrently_0[]; // idb

extern char aWouldYouLike_0[]; // idb

extern char aHowMuch_[]; // idb

extern char aUBurntToACrisp[]; // idb

extern char aOhSnapItSAllGo[]; // idb

extern char aYouCurrently_1[]; // idb

extern char aMarketPriceF_0[]; // idb

extern char aWouldYouLike_1[]; // idb

extern char aUPurchased[]; // idb

extern char aNotEnoughMoney[]; // idb

extern char aWouldYouLike_2[]; // idb

extern char aWouldYouLike_3[]; // idb

extern char aWouldYouLike_4[]; // idb

extern char aWouldYouLike_5[]; // idb

extern char aWouldYouLike_6[]; // idb

extern char aEnterNewUid[]; // idb

extern char aWouldYouLike_7[]; // idb

extern char aEnterNewEggCou[]; // idb

extern char aYouDonTHaveEno[]; // idb

extern char aWouldYouLike_8[]; // idb

extern char aEnterNewChicke[]; // idb

extern char aYouDonTHaveE_0[]; // idb

extern char aWouldYouLike_9[]; // idb

extern char aEnterNewMonies[]; // idb

extern char aYouDonTHaveE_1[]; // idb

extern char aWouldYouLik_10[]; // idb

extern char aEnterNewPerm[]; // idb

extern char aYouDonTHaveE_2[]; // idb

extern char aFinishedUpdate[]; // idb

extern char aEnterUsername[]; // idb

extern char aEnterPassword[]; // idb

extern char aBadUsernameOrP[]; // idb

extern char aFantasyChicken[]; // idb

extern char aMenuS[]; // idb

extern char aLLogout[]; // idb

extern char aBBuyChickens[]; // idb

extern char aIIncinerateMon[]; // idb

extern char aSSellEggs[]; // idb

extern char aPDisplayMyInfo[]; // idb

extern char aUUpdateMyInfo[]; // idb

extern char aPPrintUserlist[]; // idb

extern char aMenu[]; // idb

extern char aCCreateAccount[]; // idb

extern char aLLogin[]; // idb

extern char aQQuit[]; // idb

extern char s2[]; // idb

extern char aUser[]; // idb

extern char aAttemptedS_[]; // idb

extern char aCya[]; // idb

extern char aCanTAllocateUs[]; // idb

extern char aHomeFcflUser_d[]; // idb

extern char aCanTReadUserDb[]; // idb

extern char aDS[]; // idb

extern char aThatSNotAValid[]; // idb

extern char aC[2]; // weak

extern char asc_804D115[2]; // weak

extern char aS_1[2]; // weak

extern char aI[2]; // weak

extern char aB[2]; // weak

extern char aU[2]; // weak

extern char aP[2]; // weak

extern char asc_804D121[2]; // weak

extern char aP_0[2]; // weak

extern char a6[2]; // weak

extern char filename[]; // idb

extern char aQ[2]; // weak

extern int dword_804E1D8; // weak

extern int dword_804E1E0[]; // weak

extern _UNKNOWN unk_804E1E4; // weak

extern int dword_804E1E8; // weak

extern _UNKNOWN unk_804E3C0; // weak

extern __int16 word_804E404; // weak

extern char name[]; // idb

extern char dword_804E40C[]; // idb

extern char dword_804E410[]; // idb

extern char byte_804E418; // weak

extern int dword_804E41C; // weak

extern int admin; // weak

extern int logged_in; // weak

extern char s1; // idb

// extern _UNKNOWN _gmon_start__; weak



//-------------------------------------------------------------------------

// Function declarations



int __cdecl init_proc();

int sprintf(char *s, const char *format, ...);

void srand(unsigned int seed);

void err(int status, const char *format, ...);

__sighandler_t signal(int sig, __sighandler_t handler);

int __gmon_start__(void); // weak

char *strncpy(char *dest, const char *src, size_t n);

int listen(int fd, int n);

void *memset(void *s, int c, size_t n);

uint16_t htons(uint16_t hostshort);

int setegid(__gid_t gid);

__pid_t wait4(__pid_t pid, void *stat_loc, int options, struct rusage *usage);

ssize_t read(int fd, void *buf, size_t nbytes);

int __cdecl setresuid(_DWORD, _DWORD); // weak

int __cdecl setresgid(_DWORD, _DWORD); // weak

int accept(int fd, struct sockaddr *addr, socklen_t *addr_len);

int socket(int domain, int type, int protocol);

int fclose(FILE *stream);

int setuid(__uid_t uid);

size_t strlen(const char *s);

FILE *fopen(const char *filename, const char *modes);

char *strcpy(char *dest, const char *src);

__gid_t getegid(void);

int printf(const char *format, ...);

int chdir(const char *path);

int bind(int fd, const struct sockaddr *addr, socklen_t len);

__uid_t getuid(void);

int atoi(const char *nptr);

int close(int fd);

int initgroups(const char *, __gid_t group);

time_t time(time_t *timer);

void *malloc(size_t size);

char *strcat(char *dest, const char *src);

ssize_t send(int fd, const void *buf, size_t n, int flags);

int vasprintf(char **, const char *, va_list);

__pid_t fork(void);

int setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen);

int rand(void);

void bzero(void *s, size_t n);

int strncmp(const char *s1, const char *s2, size_t n);

size_t fread(void *ptr, size_t size, size_t n, FILE *stream);

int seteuid(__uid_t uid);

int setgid(__gid_t gid);

struct passwd *getpwnam(const char *name);

int strcmp(const char *s1, const char *s2);

void exit(int status);

__gid_t getgid(void);

__uid_t geteuid(void);

void __cdecl sub_8048CB0();

int __cdecl sub_8048D10();

int __cdecl sub_8048D34();

__pid_t __cdecl handler();

int __cdecl read_x_bytes_or_til_escape_char(int fd, int a2, unsigned int a3, char a4);

signed int __cdecl send_with_or_without_null(int fd, const char *s, int a3);

signed int __cdecl send_data(int fd, int a2, unsigned int a3);

int write_string(int fd, const char *a2, ...);

int __cdecl sub_8048F7A(uint16_t a1);

void __cdecl sub_80490D0(int fd, int (__cdecl *a2)(_DWORD));

int __cdecl sub_804915E(const char *name);

int __cdecl sub_80491BE(int a1);

int __cdecl fill_head_with_madness(int a1);

char __cdecl sub_804939E(int a1, int a2, unsigned int a3);

int __cdecl sub_80494D4(int a1);

int __cdecl sub_8049649(int a1, int a2);

int __cdecl sub_804A296(int a1);

int __cdecl sub_804A3DC(const char *s);

int __cdecl sub_804A443(const char *filename);

char *__cdecl sub_804A60A(int a1, char *dest);

char *__cdecl (const char *s, char *dest);

int __cdecl sub_804A6C0(int fd, int a2);

int __cdecl sub_804A820(int fd, int); // idb

int __cdecl sub_804A855(int fd, int); // idb

int __cdecl check_username_n_pass(int fd, char *a2, const char *s1, const char *s);

void __cdecl sub_804A988();

signed int __cdecl user_exists(int a1, const char *s2);

int __cdecl read_yes_or_no(int fd, int); // idb

signed int __cdecl create_user(int fd, const char *s, int a3);

int __cdecl buy_eggs(int fd, const char *nptr, int a3);

int __cdecl burn_money(int fd, const char *nptr, int a3);

int __cdecl buy_chickens(int fd, const char *nptr, int a3);

int __cdecl change_info(int fd, const char *nptr, int a3);

int __cdecl try_login(int fd, int s1, char *a3);

int __cdecl print_menu(int fd); // idb

int __cdecl readfromfd(FILE *stream, int a2, unsigned int a3, char a4);

void *__cdecl allocandfillstruct(int a1, int a2, const char *src, const char *a4, const char *a5, const char *a6, int a7, int a8, int a9, int a10, int a11);

signed int __cdecl opendbandinit(const char *filename, int a2, int fd);

void __cdecl sub_804C067(int fd);

int __cdecl sub_804C09F(int a1);

void __cdecl sub_804C18B(int fd);

void __cdecl sub_804C5F0();

int *__cdecl sub_804C600();

void __cdecl sub_804C65A();

void (*__cdecl sub_804C660())(void);

void __cdecl term_proc();





//----- (08048900) --------------------------------------------------------

int __cdecl init_proc()

{

  int v1; // ST04_4@3



  if ( &_gmon_start__ )

    __gmon_start__();

  sub_8048D10();

  sub_804C660();

  return v1;

}

// 8048980: using guessed type int __gmon_start__(void);



//----- (08048C80) --------------------------------------------------------

#error "8048C83: positive sp value has been found (funcsize=2)"



//----- (08048CB0) --------------------------------------------------------

void __cdecl sub_8048CB0()

{

  int v0; // eax@2

  int i; // ebx@2



  if ( !byte_804E418 )

  {

    v0 = dword_804E41C;

    for ( i = ((signed int)(&unk_804E1E4 - (_UNKNOWN *)dword_804E1E0) >> 2) - 1;

          dword_804E41C < (unsigned int)i;

          v0 = dword_804E41C )

    {

      dword_804E41C = v0 + 1;

      ((void (*)(void))dword_804E1E0[dword_804E41C])();

    }

    byte_804E418 = 1;

  }

}

// 804E1E0: using guessed type int dword_804E1E0[];

// 804E418: using guessed type char byte_804E418;

// 804E41C: using guessed type int dword_804E41C;



//----- (08048D10) --------------------------------------------------------

int __cdecl sub_8048D10()

{

  int result; // eax@1



  result = dword_804E1E8;

  if ( dword_804E1E8 )

    result = 0;

  return result;

}

// 804E1E8: using guessed type int dword_804E1E8;



//----- (08048D34) --------------------------------------------------------

int __cdecl sub_8048D34()

{

  int v1; // ST1C_4@1



  v1 = sub_8048F7A(word_804E404);

  sub_804915E("fcfl");

  sub_80490D0(v1, (int (__cdecl *)(_DWORD))sub_804C18B);

  return 0;

}

// 804E404: using guessed type __int16 word_804E404;



//----- (08048D78) --------------------------------------------------------

__pid_t __cdecl handler()

{

  __pid_t result; // eax@1

  char stat_loc; // [sp+1Ch] [bp-Ch]@1



  do

    result = wait4(-1, &stat_loc, 1, 0);

  while ( result > 0 );

  return result;

}



//----- (08048E0A) --------------------------------------------------------

int __cdecl read_x_bytes_or_til_escape_char(int fd, int a2, unsigned int a3, char a4)

{

  char buf; // [sp+2Bh] [bp-Dh]@2

  unsigned int i; // [sp+2Ch] [bp-Ch]@1



  for ( i = 0; ; ++i )

  {

    if ( read(fd, &buf, 1u) <= 0 )

      return -1;

    if ( buf == a4 )

      return i;

    if ( i >= a3 )

      break;

    *(_BYTE *)(i + a2) = buf;

  }

  return -1;

}



//----- (08048E75) --------------------------------------------------------

signed int __cdecl send_with_or_without_null(int fd, const char *string, bool sendnull)

{

  unsigned int len; // eax@2

  size_t strlen; // [sp+1Ch] [bp-Ch]@1



  strlen = strlen(string);

  if (  sendnull )

    len = strlen + 1;

  else

    len = strlen;

  return send_data(fd, string, len);

}



//----- (08048EB2) --------------------------------------------------------

signed int __cdecl send_data(int fd, int a2, unsigned int a3)

{

  unsigned int i; // [sp+18h] [bp-10h]@1

  ssize_t v5; // [sp+1Ch] [bp-Ch]@2



  for ( i = 0; i < a3; i += v5 )

  {

    v5 = send(fd, (const void *)(a2 + i), a3 - i, 0);

    if ( !v5 )

      return -1;

  }

  return i;

}



//----- (08048F10) --------------------------------------------------------

int write_string(int fd, const char *a2, ...)

{

  char *s; // [sp+18h] [bp-10h]@1

  int v4; // [sp+1Ch] [bp-Ch]@1

  va_list va; // [sp+38h] [bp+10h]@1



  va_start(va, a2);

  v4 = 0;

  s = 0;

  if ( vasprintf(&s, a2, va) != -1 && s )

    v4 = send_with_or_without_null(fd, s, 0);

  else

    v4 = -1;

  return v4;

}



//----- (08048F7A) --------------------------------------------------------

int __cdecl sub_8048F7A(uint16_t a1)

{

  int optval; // [sp+2Ch] [bp-ACh]@1

  __int16 s; // [sp+BCh] [bp-1Ch]@1

  uint16_t v4; // [sp+BEh] [bp-1Ah]@1

  int fd; // [sp+CCh] [bp-Ch]@3



  optval = 1;

  memset(&s, 0, 0x10u);

  s = 2;

  v4 = htons(a1);

  if ( signal(17, (__sighandler_t)handler) == (__sighandler_t)-1 )

    err(-1, "Unable to set SIGCHLD handler");

  fd = socket(2, 1, 0);

  if ( fd == -1 )

    err(-1, "Unable to create socket");

  if ( setsockopt(fd, 1, 2, &optval, 4u) == -1 )

    err(-1, "Unable to set reuse");

  if ( bind(fd, (const struct sockaddr *)&s, 0x10u) == -1 )

    err(-1, "Unable to bind socket");

  if ( listen(fd, 20) == -1 )

    err(-1, "Unable to listen on socket");

  return fd;

}



//----- (080490D0) --------------------------------------------------------

void __cdecl sub_80490D0(int fd, int (__cdecl *a2)(_DWORD))

{

  socklen_t addr_len; // [sp+1Ch] [bp-2Ch]@2

  struct sockaddr addr; // [sp+20h] [bp-28h]@2

  int v4; // [sp+30h] [bp-18h]@1

  int v5; // [sp+34h] [bp-14h]@2

  int v6; // [sp+38h] [bp-10h]@3

  int status; // [sp+3Ch] [bp-Ch]@5



  v4 = 1;

  while ( v4 )

  {

    addr_len = 16;

    v5 = accept(fd, &addr, &addr_len);

    if ( v5 != -1 )

    {

      v6 = fork();

      if ( v6 != -1 )

      {

        if ( !v6 )

        {

          close(fd);

          status = a2(v5);

          close(v5);

          exit(status);

        }

        close(v5);

      }

    }

  }

}



//----- (0804915E) --------------------------------------------------------

int __cdecl sub_804915E(const char *name)

{

  int v2; // [sp+1Ch] [bp-Ch]@1



  v2 = (int)getpwnam(name);

  if ( !v2 )

    err(-1, "Failed to find user %s\n", name);

  if ( sub_80491BE(v2) == -1 )

    err(-1, "drop_privs failed!\n");

  return 0;

}



//----- (080491BE) --------------------------------------------------------

int __cdecl sub_80491BE(int a1)

{

  int result; // eax@2

  int v2; // ebx@8

  __gid_t v3; // eax@8

  int v4; // ebx@12

  __uid_t v5; // eax@12

  __uid_t v6; // [sp+14h] [bp-14h]@1

  __gid_t v7; // [sp+18h] [bp-10h]@1



  v6 = getuid();

  v7 = getgid();

  initgroups(*(const char **)a1, *(_DWORD *)(a1 + 12));

  if ( setresgid(*(_DWORD *)(a1 + 12), *(_DWORD *)(a1 + 12)) >= 0 )

  {

    if ( setresuid(*(_DWORD *)(a1 + 8), *(_DWORD *)(a1 + 8)) >= 0 )

    {

      if ( *(_DWORD *)(a1 + 12) == v7 || setgid(v7) == -1 && setegid(v7) == -1 )

      {

        if ( *(_DWORD *)(a1 + 8) == v6 || setuid(v6) == -1 && seteuid(v6) == -1 )

        {

          if ( getgid() == *(_DWORD *)(a1 + 12) && getegid() == *(_DWORD *)(a1 + 12) )

          {

            if ( getuid() == *(_DWORD *)(a1 + 8) && geteuid() == *(_DWORD *)(a1 + 8) )

              result = chdir(*(const char **)(a1 + 20));

            else

              result = -1;

          }

          else

          {

            result = -1;

          }

        }

        else

        {

          v4 = *(_DWORD *)(a1 + 8);

          v5 = getuid();

          printf("setgid current uid: %d target uid: %d\n", v5, v4);

          result = -1;

        }

      }

      else

      {

        v2 = *(_DWORD *)(a1 + 12);

        v3 = getgid();

        printf("setgid current gid: %d target gid: %d\n", v3, v2);

        result = -1;

      }

    }

    else

    {

      result = -1;

    }

  }

  else

  {

    result = -1;

  }

  return result;

}

// 8048A30: using guessed type int __cdecl setresuid(_DWORD, _DWORD);

// 8048A40: using guessed type int __cdecl setresgid(_DWORD, _DWORD);



//----- (0804935C) --------------------------------------------------------

int __cdecl fill_head_with_madness(int a1)

{

  int result; // eax@1



  *(_DWORD *)(a1 + 4) = 0;

  *(_DWORD *)a1 = *(_DWORD *)(a1 + 4);

  *(_DWORD *)(a1 + 8) = -559038737;

  *(_DWORD *)(a1 + 12) = -782326291;

  *(_DWORD *)(a1 + 16) = -553727763;

  result = a1;

  *(_DWORD *)(a1 + 20) = -1161901314;

  return result;

}



//----- (0804939E) --------------------------------------------------------

char __cdecl sub_804939E(int a1, int a2, unsigned int a3)

{

  char result; // al@9

  int v4[16]; // [sp+14h] [bp-54h]@6

  int v5; // [sp+54h] [bp-14h]@1

  unsigned int v6; // [sp+58h] [bp-10h]@5

  int v7; // [sp+5Ch] [bp-Ch]@5



  v5 = (*(_DWORD *)a1 >> 3) & 0x3F;

  if ( *(_DWORD *)a1 + 8 * a3 < *(_DWORD *)a1 )

    ++*(_DWORD *)(a1 + 4);

  *(_DWORD *)a1 += 8 * a3;

  *(_DWORD *)(a1 + 4) += a3 >> 29;

  while ( 1 )

  {

    result = a3-- != 0;

    if ( !result )

      break;

    *(_BYTE *)(a1 + v5++ + 24) = *(_BYTE *)a2++;

    if ( v5 == 64 )

    {

      v6 = 0;

      v7 = 0;

      while ( v6 <= 0xF )

      {

        v4[v6++] = (*(_BYTE *)(a1 + v7 + 1 + 24) << 8) | (*(_BYTE *)(a1 + v7 + 2 + 24) << 16) | (*(_BYTE *)(a1 + v7 + 3 + 24) << 24) | *(_BYTE *)(a1 + v7 + 24);

        v7 += 4;

      }

      sub_8049649(a1 + 8, (int)v4);

      v5 = 0;

    }

  }

  return result;

}

// 804939E: using guessed type int var_54[16];



//----- (080494D4) --------------------------------------------------------

int __cdecl sub_80494D4(int a1)

{

  unsigned int v1; // eax@2

  int result; // eax@7

  int v3[14]; // [sp+10h] [bp-58h]@5

  int v4; // [sp+48h] [bp-20h]@1

  int v5; // [sp+4Ch] [bp-1Ch]@1

  int v6; // [sp+50h] [bp-18h]@1

  unsigned int v7; // [sp+54h] [bp-14h]@4

  int v8; // [sp+58h] [bp-10h]@4

  unsigned int v9; // [sp+5Ch] [bp-Ch]@4



  v4 = *(_DWORD *)a1;

  v5 = *(_DWORD *)(a1 + 4);

  v6 = (*(_DWORD *)a1 >> 3) & 0x3F;

  if ( v6 > 55 )

    v1 = 120 - v6;

  else

    v1 = 56 - v6;

  v9 = v1;

  sub_804939E(a1, (int)&unk_804E3C0, v1);

  v7 = 0;

  v8 = 0;

  while ( v7 <= 0xD )

  {

    v3[v7++] = (*(_BYTE *)(a1 + v8 + 1 + 24) << 8) | (*(_BYTE *)(a1 + v8 + 2 + 24) << 16) | (*(_BYTE *)(a1 + v8 + 3 + 24) << 24) | *(_BYTE *)(a1 + v8 + 24);

    v8 += 4;

  }

  result = sub_8049649(a1 + 8, (int)v3);

  v7 = 0;

  v8 = 0;

  while ( v7 <= 3 )

  {

    *(_BYTE *)(a1 + v8 + 88) = *(_DWORD *)(a1 + 4 * v7 + 8);

    *(_BYTE *)(a1 + v8 + 1 + 88) = *(_WORD *)(a1 + 4 * v7 + 8) >> 8;

    *(_BYTE *)(a1 + v8 + 2 + 88) = *(_DWORD *)(a1 + 4 * v7 + 8) >> 16;

    result = a1;

    *(_BYTE *)(a1 + v8 + 3 + 88) = *(_DWORD *)(a1 + 4 * v7++ + 8) >> 24;

    v8 += 4;

  }

  return result;

}

// 80494D4: using guessed type int var_58[14];



//----- (08049649) --------------------------------------------------------

int __cdecl sub_8049649(int a1, int a2)

{

  int result; // eax@1

  int v3; // ST04_4@1

  int v4; // ST08_4@1

  int v5; // ST0C_4@1

  int v6; // et0@1

  int v7; // ST00_4@1

  int v8; // et0@1

  int v9; // ST0C_4@1

  int v10; // et0@1

  int v11; // ST08_4@1

  int v12; // et0@1

  int v13; // ST04_4@1

  int v14; // et0@1

  int v15; // ST00_4@1

  int v16; // et0@1

  int v17; // ST0C_4@1

  int v18; // et0@1

  int v19; // ST08_4@1

  int v20; // et0@1

  int v21; // ST04_4@1

  int v22; // et0@1

  int v23; // ST00_4@1

  int v24; // et0@1

  int v25; // ST0C_4@1

  int v26; // et0@1

  int v27; // ST08_4@1

  int v28; // et0@1

  int v29; // ST04_4@1

  int v30; // et0@1

  int v31; // ST00_4@1

  int v32; // et0@1

  int v33; // ST0C_4@1

  int v34; // et0@1

  int v35; // ST08_4@1

  int v36; // et0@1

  int v37; // ST04_4@1

  int v38; // et0@1

  int v39; // ST00_4@1

  int v40; // et0@1

  int v41; // ST0C_4@1

  int v42; // et0@1

  int v43; // ST08_4@1

  int v44; // et0@1

  int v45; // ST04_4@1

  int v46; // et0@1

  int v47; // ST00_4@1

  int v48; // et0@1

  int v49; // ST0C_4@1

  int v50; // et0@1

  int v51; // ST08_4@1

  int v52; // et0@1

  int v53; // ST04_4@1

  int v54; // et0@1

  int v55; // ST00_4@1

  int v56; // et0@1

  int v57; // ST0C_4@1

  int v58; // et0@1

  int v59; // ST08_4@1

  int v60; // et0@1

  int v61; // ST04_4@1

  int v62; // et0@1

  int v63; // ST00_4@1

  int v64; // et0@1

  int v65; // ST0C_4@1

  int v66; // et0@1

  int v67; // ST08_4@1

  int v68; // et0@1

  int v69; // ST04_4@1

  int v70; // et0@1

  int v71; // ST00_4@1

  int v72; // et0@1

  int v73; // ST0C_4@1

  int v74; // et0@1

  int v75; // ST08_4@1

  int v76; // et0@1

  int v77; // ST04_4@1

  int v78; // et0@1

  int v79; // ST00_4@1

  int v80; // et0@1

  int v81; // ST0C_4@1

  int v82; // et0@1

  int v83; // ST08_4@1

  int v84; // et0@1

  int v85; // ST04_4@1

  int v86; // et0@1

  int v87; // ST00_4@1

  int v88; // et0@1

  int v89; // ST0C_4@1

  int v90; // et0@1

  int v91; // ST08_4@1

  int v92; // et0@1

  int v93; // ST04_4@1

  int v94; // et0@1

  int v95; // ST00_4@1

  int v96; // et0@1

  int v97; // ST0C_4@1

  int v98; // et0@1

  int v99; // ST08_4@1

  int v100; // et0@1

  int v101; // ST04_4@1

  int v102; // et0@1

  int v103; // ST00_4@1

  int v104; // et0@1

  int v105; // ST0C_4@1

  int v106; // et0@1

  int v107; // ST08_4@1

  int v108; // et0@1

  int v109; // ST04_4@1

  int v110; // et0@1

  int v111; // ST00_4@1

  int v112; // et0@1

  int v113; // ST0C_4@1

  int v114; // et0@1

  int v115; // ST08_4@1

  int v116; // et0@1

  int v117; // ST04_4@1

  int v118; // et0@1

  int v119; // ST00_4@1

  int v120; // et0@1

  int v121; // ST0C_4@1

  int v122; // et0@1

  int v123; // ST08_4@1

  int v124; // et0@1

  int v125; // ST04_4@1

  int v126; // et0@1

  int v127; // ST00_4@1

  int v128; // et0@1

  int v129; // ST0C_4@1

  int v130; // et0@1

  int v131; // ST08_4@1

  int v132; // et0@1



  v3 = *(_DWORD *)(a1 + 4);

  v4 = *(_DWORD *)(a1 + 8);

  v5 = *(_DWORD *)(a1 + 12);

  v6 = __ROR__(*(_DWORD *)a1 + (v5 & ~v3 | v4 & v3) + *(_DWORD *)a2 - 680876936, 25);

  v7 = v3 + v6;

  v8 = __ROR__(v5 + (v4 & ~(v3 + v6) | v3 & (v3 + v6)) + *(_DWORD *)(a2 + 4) - 389564586, 20);

  v9 = v7 + v8;

  v10 = __ROR__(v4 + (v3 & ~(v7 + v8) | v7 & (v7 + v8)) + *(_DWORD *)(a2 + 8) + 606105819, 15);

  v11 = v9 + v10;

  v12 = __ROR__(v3 + (v7 & ~(v9 + v10) | v9 & (v9 + v10)) + *(_DWORD *)(a2 + 12) - 1044525330, 10);

  v13 = v11 + v12;

  v14 = __ROR__(v7 + (v9 & ~(v11 + v12) | v11 & (v11 + v12)) + *(_DWORD *)(a2 + 16) - 176418897, 25);

  v15 = v13 + v14;

  v16 = __ROR__(v9 + (v11 & ~(v13 + v14) | v13 & (v13 + v14)) + *(_DWORD *)(a2 + 20) + 1200080426, 20);

  v17 = v15 + v16;

  v18 = __ROR__(v11 + (v13 & ~(v15 + v16) | v15 & (v15 + v16)) + *(_DWORD *)(a2 + 24) - 1473231341, 15);

  v19 = v17 + v18;

  v20 = __ROR__(v13 + (v15 & ~(v17 + v18) | v17 & (v17 + v18)) + *(_DWORD *)(a2 + 28) - 45705983, 10);

  v21 = v19 + v20;

  v22 = __ROR__(v15 + (v17 & ~(v19 + v20) | v19 & (v19 + v20)) + *(_DWORD *)(a2 + 32) + 1770035416, 25);

  v23 = v21 + v22;

  v24 = __ROR__(v17 + (v19 & ~(v21 + v22) | v21 & (v21 + v22)) + *(_DWORD *)(a2 + 36) - 1958414417, 20);

  v25 = v23 + v24;

  v26 = __ROR__(v19 + (v21 & ~(v23 + v24) | v23 & (v23 + v24)) + *(_DWORD *)(a2 + 40) - 42063, 15);

  v27 = v25 + v26;

  v28 = __ROR__(v21 + (v23 & ~(v25 + v26) | v25 & (v25 + v26)) + *(_DWORD *)(a2 + 44) - 1990404162, 10);

  v29 = v27 + v28;

  v30 = __ROR__(v23 + (v25 & ~(v27 + v28) | v27 & (v27 + v28)) + *(_DWORD *)(a2 + 48) + 1804603682, 25);

  v31 = v29 + v30;

  v32 = __ROR__(v25 + (v27 & ~(v29 + v30) | v29 & (v29 + v30)) + *(_DWORD *)(a2 + 52) - 40341101, 20);

  v33 = v31 + v32;

  v34 = __ROR__(v27 + (v29 & ~(v31 + v32) | v31 & (v31 + v32)) + *(_DWORD *)(a2 + 56) - 1502002290, 15);

  v35 = v33 + v34;

  v36 = __ROR__(v29 + (v31 & ~(v33 + v34) | v33 & (v33 + v34)) + *(_DWORD *)(a2 + 60) + 1236535329, 10);

  v37 = v35 + v36;

  v38 = __ROR__(v31 + (v35 & ~v33 | v33 & (v35 + v36)) + *(_DWORD *)(a2 + 4) - 165796510, 27);

  v39 = v37 + v38;

  v40 = __ROR__(v33 + (v37 & ~v35 | v35 & (v37 + v38)) + *(_DWORD *)(a2 + 24) - 1069501632, 23);

  v41 = v39 + v40;

  v42 = __ROR__(v35 + (v39 & ~v37 | v37 & (v39 + v40)) + *(_DWORD *)(a2 + 44) + 643717713, 18);

  v43 = v41 + v42;

  v44 = __ROR__(v37 + (v41 & ~v39 | v39 & (v41 + v42)) + *(_DWORD *)a2 - 373897302, 12);

  v45 = v43 + v44;

  v46 = __ROR__(v39 + (v43 & ~v41 | v41 & (v43 + v44)) + *(_DWORD *)(a2 + 20) - 701558691, 27);

  v47 = v45 + v46;

  v48 = __ROR__(v41 + (v45 & ~v43 | v43 & (v45 + v46)) + *(_DWORD *)(a2 + 40) + 38016083, 23);

  v49 = v47 + v48;

  v50 = __ROR__(v43 + (v47 & ~v45 | v45 & (v47 + v48)) + *(_DWORD *)(a2 + 60) - 660478335, 18);

  v51 = v49 + v50;

  v52 = __ROR__(v45 + (v49 & ~v47 | v47 & (v49 + v50)) + *(_DWORD *)(a2 + 16) - 405537848, 12);

  v53 = v51 + v52;

  v54 = __ROR__(v47 + (v51 & ~v49 | v49 & (v51 + v52)) + *(_DWORD *)(a2 + 36) + 568446438, 27);

  v55 = v53 + v54;

  v56 = __ROR__(v49 + (v53 & ~v51 | v51 & (v53 + v54)) + *(_DWORD *)(a2 + 56) - 1019803690, 23);

  v57 = v55 + v56;

  v58 = __ROR__(v51 + (v55 & ~v53 | v53 & (v55 + v56)) + *(_DWORD *)(a2 + 12) - 187363961, 18);

  v59 = v57 + v58;

  v60 = __ROR__(v53 + (v57 & ~v55 | v55 & (v57 + v58)) + *(_DWORD *)(a2 + 32) + 1163531501, 12);

  v61 = v59 + v60;

  v62 = __ROR__(v55 + (v59 & ~v57 | v57 & (v59 + v60)) + *(_DWORD *)(a2 + 52) - 1444681467, 27);

  v63 = v61 + v62;

  v64 = __ROR__(v57 + (v61 & ~v59 | v59 & (v61 + v62)) + *(_DWORD *)(a2 + 8) - 51403784, 23);

  v65 = v63 + v64;

  v66 = __ROR__(v59 + (v63 & ~v61 | v61 & (v63 + v64)) + *(_DWORD *)(a2 + 28) + 1735328473, 18);

  v67 = v65 + v66;

  v68 = __ROR__(v61 + (v65 & ~v63 | v63 & (v65 + v66)) + *(_DWORD *)(a2 + 48) - 1926607734, 12);

  v69 = v67 + v68;

  v70 = __ROR__(v63 + (v65 ^ (v67 + v68) ^ v67) + *(_DWORD *)(a2 + 20) - 378558, 28);

  v71 = v69 + v70;

  v72 = __ROR__(v65 + (v67 ^ (v69 + v70) ^ v69) + *(_DWORD *)(a2 + 32) - 2022574463, 21);

  v73 = v71 + v72;

  v74 = __ROR__(v67 + (v69 ^ (v71 + v72) ^ v71) + *(_DWORD *)(a2 + 44) + 1839030562, 16);

  v75 = v73 + v74;

  v76 = __ROR__(v69 + (v71 ^ (v73 + v74) ^ v73) + *(_DWORD *)(a2 + 56) - 35309556, 9);

  v77 = v75 + v76;

  v78 = __ROR__(v71 + (v73 ^ (v75 + v76) ^ v75) + *(_DWORD *)(a2 + 4) - 1530992060, 28);

  v79 = v77 + v78;

  v80 = __ROR__(v73 + (v75 ^ (v77 + v78) ^ v77) + *(_DWORD *)(a2 + 16) + 1272893353, 21);

  v81 = v79 + v80;

  v82 = __ROR__(v75 + (v77 ^ (v79 + v80) ^ v79) + *(_DWORD *)(a2 + 28) - 155497632, 16);

  v83 = v81 + v82;

  v84 = __ROR__(v77 + (v79 ^ (v81 + v82) ^ v81) + *(_DWORD *)(a2 + 40) - 1094730640, 9);

  v85 = v83 + v84;

  v86 = __ROR__(v79 + (v81 ^ (v83 + v84) ^ v83) + *(_DWORD *)(a2 + 52) + 681279174, 28);

  v87 = v85 + v86;

  v88 = __ROR__(v81 + (v83 ^ (v85 + v86) ^ v85) + *(_DWORD *)a2 - 358537222, 21);

  v89 = v87 + v88;

  v90 = __ROR__(v83 + (v85 ^ (v87 + v88) ^ v87) + *(_DWORD *)(a2 + 12) - 722521979, 16);

  v91 = v89 + v90;

  v92 = __ROR__(v85 + (v87 ^ (v89 + v90) ^ v89) + *(_DWORD *)(a2 + 24) + 76029189, 9);

  v93 = v91 + v92;

  v94 = __ROR__(v87 + (v89 ^ (v91 + v92) ^ v91) + *(_DWORD *)(a2 + 36) - 640364487, 28);

  v95 = v93 + v94;

  v96 = __ROR__(v89 + (v91 ^ (v93 + v94) ^ v93) + *(_DWORD *)(a2 + 48) - 421815835, 21);

  v97 = v95 + v96;

  v98 = __ROR__(v91 + (v93 ^ (v95 + v96) ^ v95) + *(_DWORD *)(a2 + 60) + 530742520, 16);

  v99 = v97 + v98;

  v100 = __ROR__(v93 + (v95 ^ (v97 + v98) ^ v97) + *(_DWORD *)(a2 + 8) - 995338651, 9);

  v101 = v99 + v100;

  v102 = __ROR__(v95 + (v99 ^ ((v99 + v100) | ~v97)) + *(_DWORD *)a2 - 198630844, 26);

  v103 = v101 + v102;

  v104 = __ROR__(v97 + (v101 ^ ((v101 + v102) | ~v99)) + *(_DWORD *)(a2 + 28) + 1126891415, 22);

  v105 = v103 + v104;

  v106 = __ROR__(v99 + (v103 ^ ((v103 + v104) | ~v101)) + *(_DWORD *)(a2 + 56) - 1416354905, 17);

  v107 = v105 + v106;

  v108 = __ROR__(v101 + (v105 ^ ((v105 + v106) | ~v103)) + *(_DWORD *)(a2 + 20) - 57434055, 11);

  v109 = v107 + v108;

  v110 = __ROR__(v103 + (v107 ^ ((v107 + v108) | ~v105)) + *(_DWORD *)(a2 + 48) + 1700485571, 26);

  v111 = v109 + v110;

  v112 = __ROR__(v105 + (v109 ^ ((v109 + v110) | ~v107)) + *(_DWORD *)(a2 + 12) - 1894986606, 22);

  v113 = v111 + v112;

  v114 = __ROR__(v107 + (v111 ^ ((v111 + v112) | ~v109)) + *(_DWORD *)(a2 + 40) - 1051523, 17);

  v115 = v113 + v114;

  v116 = __ROR__(v109 + (v113 ^ ((v113 + v114) | ~v111)) + *(_DWORD *)(a2 + 4) - 2054922799, 11);

  v117 = v115 + v116;

  v118 = __ROR__(v111 + (v115 ^ ((v115 + v116) | ~v113)) + *(_DWORD *)(a2 + 32) + 1873313359, 26);

  v119 = v117 + v118;

  v120 = __ROR__(v113 + (v117 ^ ((v117 + v118) | ~v115)) + *(_DWORD *)(a2 + 60) - 30611744, 22);

  v121 = v119 + v120;

  v122 = __ROR__(v115 + (v119 ^ ((v119 + v120) | ~v117)) + *(_DWORD *)(a2 + 24) - 1560198380, 17);

  v123 = v121 + v122;

  v124 = __ROR__(v117 + (v121 ^ ((v121 + v122) | ~v119)) + *(_DWORD *)(a2 + 52) + 1309151649, 11);

  v125 = v123 + v124;

  v126 = __ROR__(v119 + (v123 ^ ((v123 + v124) | ~v121)) + *(_DWORD *)(a2 + 16) - 145523070, 26);

  v127 = v125 + v126;

  v128 = __ROR__(v121 + (v125 ^ ((v125 + v126) | ~v123)) + *(_DWORD *)(a2 + 44) - 1120210379, 22);

  v129 = v127 + v128;

  v130 = __ROR__(v123 + (v127 ^ ((v127 + v128) | ~v125)) + *(_DWORD *)(a2 + 8) + 718787259, 17);

  v131 = v129 + v130;

  v132 = __ROR__(v125 + (v129 ^ ((v129 + v130) | ~v127)) + *(_DWORD *)(a2 + 36) - 343485551, 11);

  *(_DWORD *)a1 += v127;

  *(_DWORD *)(a1 + 4) += v131 + v132;

  *(_DWORD *)(a1 + 8) += v131;

  result = v129 + *(_DWORD *)(a1 + 12);

  *(_DWORD *)(a1 + 12) = result;

  return result;

}



//----- (0804A296) --------------------------------------------------------

int __cdecl sub_804A296(int a1)

{

  int result; // eax@2

  signed int i; // [sp+1Ch] [bp-Ch]@1



  for ( i = 0; i <= 15; ++i )

    result = printf("%02x", *(_BYTE *)(a1 + i + 88));

  return result;

}



//----- (0804A3DC) --------------------------------------------------------

int __cdecl sub_804A3DC(const char *s)

{

  char v2; // [sp+14h] [bp-74h]@1

  unsigned int v3; // [sp+7Ch] [bp-Ch]@1



  v3 = strlen(s);

  fill_head_with_madness((int)&v2);

  sub_804939E((int)&v2, (int)s, v3);

  sub_80494D4((int)&v2);

  sub_804A296((int)&v2);

  return printf(" \"%s\"\n\n", s);

}



//----- (0804A443) --------------------------------------------------------

int __cdecl sub_804A443(const char *filename)

{

  int result; // eax@2

  char ptr; // [sp+10h] [bp-478h]@4

  char v3; // [sp+410h] [bp-78h]@3

  FILE *stream; // [sp+478h] [bp-10h]@1

  unsigned int v5; // [sp+47Ch] [bp-Ch]@4



  stream = fopen(filename, "rb");

  if ( stream )

  {

    fill_head_with_madness((int)&v3);

    while ( 1 )

    {

      v5 = fread(&ptr, 1u, 0x400u, stream);

      if ( !v5 )

        break;

      sub_804939E((int)&v3, (int)&ptr, v5);

    }

    sub_80494D4((int)&v3);

    sub_804A296((int)&v3);

    printf(" %s\n", filename);

    result = fclose(stream);

  }

  else

  {

    result = printf("%s can't be opened.\n", filename);

  }

  return result;

}



//----- (0804A60A) --------------------------------------------------------

char *__cdecl sub_804A60A(int a1, char *dest)

{

  char *result; // eax@1

  char src; // [sp+16h] [bp-42h]@2

  int i; // [sp+48h] [bp-10h]@1

  int v5; // [sp+4Ch] [bp-Ch]@2



  result = dest;

  *dest = 0;

  for ( i = 0; i <= 15; ++i )

  {

    v5 = sprintf(&src, "%02x", *(_BYTE *)(a1 + i + 88));

    result = strcat(dest, &src);

  }

  return result;

}



//----- (0804A666) --------------------------------------------------------

char *__cdecl md5(const char *s, char *dest)

{

  int v3; // [sp+14h] [bp-74h]@1

  unsigned int v4; // [sp+7Ch] [bp-Ch]@1



  v4 = strlen(s);

  fill_head_with_madness((int)&v3);

  sub_804939E((int)&v3, (int)s, v4);

  sub_80494D4((int)&v3);

  return sub_804A60A((int)&v3, dest);

}



//----- (0804A6C0) --------------------------------------------------------

int __cdecl sub_804A6C0(int fd, int a2)

{

  write_string(fd, "<node> %x\n", a2);

  write_string(fd, "  chickens: %u \n", *(_DWORD *)(a2 + 60));

  write_string(fd, "  eggs:     %u \n", *(_DWORD *)(a2 + 68));

  write_string(fd, "  monies:   %u \n", *(_DWORD *)(a2 + 64));

  write_string(fd, "  id:       %u \n", *(_DWORD *)(a2 + 72));

  write_string(fd, "  username: %s \n", a2);

  write_string(fd, "  info:     %s \n", a2 + 84);

  write_string(fd, "  office:   %s \n", a2 + 134);

  write_string(fd, "  password: %s \n\n", a2 + 20);

  write_string(fd, "  perm:     %u \n", *(_DWORD *)(a2 + 56));

  write_string(fd, "  next:     %x \n", *(_DWORD *)(a2 + 76));

  return write_string(fd, "  prev:     %x \n", *(_DWORD *)(a2 + 80));

}



//----- (0804A820) --------------------------------------------------------

int __cdecl sub_804A820(int fd, int a2)

{

  int result; // eax@3

  int i; // [sp+1Ch] [bp-Ch]@1



  for ( i = a2; ; sub_804A6C0(fd, i) )

  {

    result = *(_DWORD *)(i + 76);

    if ( !result )

      break;

    i = *(_DWORD *)(i + 76);

  }

  return result;

}



//----- (0804A855) --------------------------------------------------------

int __cdecl sub_804A855(int fd, int a2)

{

  int result; // eax@4

  int v3; // [sp+1Ch] [bp-Ch]@1



  v3 = a2;

  while ( 1 )

  {

    result = *(_DWORD *)(v3 + 76);

    if ( !result )

      break;

    v3 = *(_DWORD *)(v3 + 76);

    if ( !strcmp(&s1, (const char *)v3) )

      sub_804A6C0(fd, v3);

  }

  return result;

}



//----- (0804A8A1) --------------------------------------------------------

int __cdecl check_username_n_pass(int fd, char *a2, const char *s1 /* user */, const char *s /* pass */)

{

  char dest; // [sp+17h] [bp-31h]@3

  char v6; // [sp+37h] [bp-11h]@3

  int v7; // [sp+38h] [bp-10h]@1

  char *src; // [sp+3Ch] [bp-Ch]@1



  v7 = 1;

  src = a2;

  while ( *((_DWORD *)src + 19) )

  {

    src = (char *)*((_DWORD *)src + 19);

    if ( !strcmp(s1, src) )

    {

      md5(s, &dest); /* md5 */

      v6 = 0;

      if ( !strncmp(&dest, src + 20, 0x20u) )

      {

        write_string(fd, "lcgged in!\n", src + 20);

        logged_in = 1;

        strncpy(&::s1, src, 0x14u);

        if ( *((_DWORD *)src + 14) > 0x1F3u )

          admin = 1;

        return 0;

      }

    }

  }

  return v7;

}

// 804E420: using guessed type int dword_804E420;

// 804E424: using guessed type int dword_804E424;



//----- (0804A988) --------------------------------------------------------

void __cdecl sub_804A988()

{

  logged_in = 0;

  admin = 0;

  s1 = 0;

}

// 804E420: using guessed type int dword_804E420;

// 804E424: using guessed type int dword_804E424;



//----- (0804A9CB) --------------------------------------------------------

signed int __cdecl user_exists(struct *users, const char *username)

{

  struct *curuser; // [sp+1Ch] [bp-Ch]@1



  curuser = users;

  while ( *(_DWORD *)(curuser.next) )

  {

    curuser = *(_DWORD *)(curuser.next);

    if ( !strcmp((const char *)curuser, username) )

      return 1;

  }

  return 0;

}



//----- (0804AA10) --------------------------------------------------------

int __cdecl read_yes_or_no(int fd, int a2)

{

  int i; // [sp+1Ch] [bp-Ch]@1



  for ( i = read_x_bytes_or_til_escape_char(fd, a2, 0x257u, 10);

        i != 1 || *(_BYTE *)a2 != 121 && *(_BYTE *)a2 != 110;

        i = read_x_bytes_or_til_escape_char(fd, a2, 0x257u, 10) )

    send_with_or_without_null(fd, "[y/n]", 0);

  return *(_BYTE *)a2;

}



//----- (0804AA9F) --------------------------------------------------------

signed int __cdecl create_user(int fd, const char *s, int head)

{

  signed int result; // eax@2

  const char dest[33]; // [sp+39h] [bp-8Fh]@3

  const char office[20]; // [sp+5Ah] [bp-6Eh]@3

  const char info[50]; // [sp+6Eh] [bp-5Ah]@3

  char user[50]; // [sp+A0h] [bp-28h]@1

  int id; // [sp+B4h] [bp-14h]@1

  int v9; // [sp+B8h] [bp-10h]@1

  int v10; // [sp+BCh] [bp-Ch]@1



  id = 0;

  v10 = 0;

  send_with_or_without_null(fd, "enter new username: ", 0);

  readlen = read_x_bytes_or_til_escape_char(fd, (int)s, 0x257u, 10);

  s[readlen] = 0;

  strncpy(&user, s, 20);

  if ( user_exists(head, &src) )

  {

    result = 1;

  }

  else

  {

    send_with_or_without_null(fd, "enter new info: ", 0);

    readlen = read_x_bytes_or_til_escape_char(fd, (int)s, 0x257u, 10);

    s[readlen] = 0;

    strncpy((char *)info, s, 50);

    send_with_or_without_null(fd, "enter new office: ", 0);

    readlen = read_x_bytes_or_til_escape_char(fd, (int)s, 0x257u, 10);

    s[readlen] = 0;

    strncpy((char *)office, s, 20);

    send_with_or_without_null(fd, "enter new pass: ", 0);

    readlen = read_x_bytes_or_til_escape_char(fd, (int)s, 0x257u, 10);

    s[readlen] = 0;

    strncpy((char *)password, s, 33);

    md5(s, (char *)password);

    if ( allocandfillstruct(fd, head, &username, info, office, password, id, 1, 1000, 0, 0) )

    {

      v10 = 1;

      write_string(fd, "insert failed.\n");

    }

    result = v10;

  }

  return result;

}


//----- (0804ACFC) --------------------------------------------------------

int __cdecl buy_eggs(int fd, const char *nptr, int a3)

{

  int result; // eax@4

  int v4; // [sp+2E8h] [bp-10h]@1

  int v5; // [sp+2ECh] [bp-Ch]@5



  v4 = a3;

  do

  {

    if ( !*(_DWORD *)(v4 + 76) )

      break;

    v4 = *(_DWORD *)(v4 + 76);

  }

  while ( strcmp(&s1, (const char *)v4) );

  write_string(fd, "you currently have $%u and %u eggs\n ", *(_DWORD *)(v4 + 64), *(_DWORD *)(v4 + 68));

  write_string(fd, "market price for an egg is %u\n ", *(_DWORD *)dword_804E410);

  write_string(fd, "would you like to sell eggs [y/n]: ");

  result = read_yes_or_no(fd, (int)nptr);

  if ( (_BYTE)result == 121 )

  {

    write_string(fd, "how many?: ");

    nptr[read_x_bytes_or_til_escape_char(fd, (int)nptr, 0x257u, 10)] = 0;

    v5 = atoi(nptr);

    if ( (unsigned int)v5 >= *(_DWORD *)(v4 + 68) )

    {

      result = write_string(fd, "not enough eggs!\n");

    }

    else

    {

      *(_DWORD *)(v4 + 68) -= v5;

      *(_DWORD *)(v4 + 64) += v5 * *(_DWORD *)dword_804E410;

      result = write_string(fd, "%u sold!\n", v5);

    }

  }

  return result;

}



//----- (0804AE76) --------------------------------------------------------

int __cdecl burn_money(int fd, const char *nptr, int a3)

{

  int result; // eax@4

  int v4; // [sp+2E4h] [bp-14h]@1

  int v5; // [sp+2ECh] [bp-Ch]@6



  v4 = a3;

  do

  {

    if ( !*(_DWORD *)(v4 + 76) )

      break;

    v4 = *(_DWORD *)(v4 + 76);

  }

  while ( strcmp(&s1, (const char *)v4) );

  write_string(fd, "you currently have $%u\n ", *(_DWORD *)(v4 + 64));

  write_string(fd, "would you like to incinerate some?[y/n]: ");

  result = read_yes_or_no(fd, (int)nptr);

  if ( (_BYTE)result == 121 || (_BYTE)result == 110 )

  {

    write_string(fd, "how much?: ");

    nptr[read_x_bytes_or_til_escape_char(fd, (int)nptr, 0x257u, 10)] = 0;

    v5 = atoi(nptr);

    if ( (unsigned int)v5 >= *(_DWORD *)(v4 + 64) )

    {

      *(_DWORD *)(v4 + 64) = 0;

      result = write_string(fd, "oh snap!  it's all gone! all that's left is ashes!\n");

    }

    else

    {

      *(_DWORD *)(v4 + 64) -= v5;

      result = write_string(fd, "%u burnt to a crisp!\n", v5);

    }

  }

  return result;

}



//----- (0804AFC6) --------------------------------------------------------

int __cdecl buy_chickens(int fd, const char *nptr, int a3)

{

  int result; // eax@4

  int v4; // [sp+2E8h] [bp-10h]@1

  int v5; // [sp+2ECh] [bp-Ch]@5



  v4 = a3;

  do

  {

    if ( !*(_DWORD *)(v4 + 76) )

      break;

    v4 = *(_DWORD *)(v4 + 76);

  }

  while ( strcmp(&s1, (const char *)v4) );

  write_string(fd, "you currently have $%u and %u chickens\n ", *(_DWORD *)(v4 + 64), *(_DWORD *)(v4 + 60));

  write_string(fd, "market price for a chicken is %u\n ", *(_DWORD *)dword_804E40C);

  write_string(fd, "would you like to buy chickens [y/n]: ");

  result = read_yes_or_no(fd, (int)nptr);

  if ( (_BYTE)result == 121 )

  {

    write_string(fd, "how many?: ");

    nptr[read_x_bytes_or_til_escape_char(fd, (int)nptr, 0x257u, 10)] = 0;

    v5 = atoi(nptr);

    if ( (unsigned int)(*(_DWORD *)dword_804E40C * v5) > *(_DWORD *)(v4 + 64) )

    {

      result = write_string(fd, "not enough money!\n");

    }

    else

    {

      *(_DWORD *)(v4 + 64) -= v5 * *(_DWORD *)dword_804E40C;

      *(_DWORD *)(v4 + 60) += v5;

      result = write_string(fd, "%u purchased!\n", v5);

    }

  }

  return result;

}



//----- (0804B148) --------------------------------------------------------

int __cdecl change_info(int fd, const char *nptr, int a3)

{

  int v4; // [sp+C0h] [bp-18h]@1

  int v5; // [sp+CCh] [bp-Ch]@1



  v4 = 0;

  v5 = a3;

  do

  {

    if ( !*(_DWORD *)(v5 + 76) )

      break;

    v5 = *(_DWORD *)(v5 + 76);

  }

  while ( strcmp(&s1, (const char *)v5) );

  write_string(fd, "would you like to change username (%s) [y/n]: ", &s1);

  if ( (unsigned __int8)read_yes_or_no(fd, (int)nptr) == 121 )

  {

    write_string(fd, "enter new username: ");

    v4 = read_x_bytes_or_til_escape_char(fd, (int)nptr, 0x257u, 10);

    nptr[v4] = 0;

    strncpy((char *)v5, nptr, 20);

    strncpy(&s1, nptr, 20);

  }

  write_string(fd, "would you like to change user info (%s) [y/n]: ", v5 + 84);

  if ( (unsigned __int8)read_yes_or_no(fd, (int)nptr) == 121 )

  {

    write_string(fd, "enter new info: ");

    v4 = read_x_bytes_or_til_escape_char(fd, (int)nptr, 0x257u, 10);

    nptr[v4] = 0;

    strncpy((char *)(v5 + 84), nptr, 50);

  }

  write_string(fd, "would you like to change office #(%s) [y/n]: ", v5 + 134);

  if ( (unsigned __int8)read_yes_or_no(fd, (int)nptr) == 121 )

  {

    write_string(fd, "enter new office: ");

    v4 = read_x_bytes_or_til_escape_char(fd, (int)nptr, 0x257u, 10);

    nptr[v4] = 0;

    strcpy((char *)(v5 + 134), nptr);

  }

  write_string(fd, "would you like to change password [y/n]: ");

  if ( (unsigned __int8)read_yes_or_no(fd, (int)nptr) == 121 )

  {

    write_string(fd, "enter new pass: ");

    v4 = read_x_bytes_or_til_escape_char(fd, (int)nptr, 0x257u, 10);

    nptr[v4] = 0;

    strncpy((char *)(v5 + 20), nptr, 0x21u);

  }

  write_string(fd, "would you like to change uid(%u) [y/n]: ", *(_DWORD *)(v5 + 72));

  if ( (unsigned __int8)read_yes_or_no(fd, (int)nptr) == 121 )

  {

    write_string(fd, "enter new uid: ");

    v4 = read_x_bytes_or_til_escape_char(fd, (int)nptr, 0x257u, 10);

    nptr[v4] = 0;

    *(_DWORD *)(v5 + 72) = atoi(nptr);

  }

  write_string(fd, "would you like to change you egg count(%u) [y/n]: ", *(_DWORD *)(v5 + 68));

  if ( (unsigned __int8)read_yes_or_no(fd, (int)nptr) == 121 )

  {

    write_string(fd, "enter new egg count: ");

    v4 = read_x_bytes_or_til_escape_char(fd, (int)nptr, 0x257u, 10);

    nptr[v4] = 0;

    if ( admin )

      *(_DWORD *)(v5 + 68) = atoi(nptr);

    else

      write_string(fd, "you don't have enough permissions to change egg amount\n");

  }

  write_string(fd, "would you like to change chicken count(%u) [y/n]: ", *(_DWORD *)(v5 + 60));

  if ( (unsigned __int8)read_yes_or_no(fd, (int)nptr) == 121 )

  {

    write_string(fd, "enter new chicken count: ");

    v4 = read_x_bytes_or_til_escape_char(fd, (int)nptr, 0x257u, 10);

    nptr[v4] = 0;

    if ( admin )

      *(_DWORD *)(v5 + 60) = atoi(nptr);

    else

      write_string(fd, "you don't have enough permissions to adjust chickens\n");

  }

  write_string(fd, "would you like to change monies(%u) [y/n]: ", *(_DWORD *)(v5 + 64));

  if ( (unsigned __int8)read_yes_or_no(fd, (int)nptr) == 121 )

  {

    write_string(fd, "enter new monies: ");

    v4 = read_x_bytes_or_til_escape_char(fd, (int)nptr, 0x257u, 10);

    nptr[v4] = 0;

    if ( admin )

      *(_DWORD *)(v5 + 64) = atoi(nptr);

    else

      write_string(fd, "you don't have enough permissions to add monies\n");

  }

  write_string(fd, "would you like to change your perms(%u) [y/n]: ", *(_DWORD *)(v5 + 56));

  if ( (unsigned __int8)read_yes_or_no(fd, (int)nptr) == 121 )

  {

    write_string(fd, "enter new perm: ");

    nptr[v4] = 0;

    if ( admin )

      *(_DWORD *)(v5 + 56) = atoi(nptr);

    else

      write_string(fd, "you don't have enough permissions to change permissions\n");

  }

  write_string(fd, "finished updates \n");

  return 0;

}

// 804E420: using guessed type int dword_804E420;



//----- (0804B6F5) --------------------------------------------------------

int __cdecl try_login(int fd, int s1, char *a3)

{

  int result; // eax@1

  int v4; // eax@1

  int v5; // eax@1

  const char s[600]; // [sp+14h] [bp-264h]@1

  int v7; // [sp+26Ch] [bp-Ch]@1



  send_with_or_without_null(fd, "enter username: ", 0);

  v4 = read_x_bytes_or_til_escape_char(fd, s1, 0x257u, 10);

  v7 = v4;

  *(_BYTE *)(s1 + v4) = 0;

  send_with_or_without_null(fd, "enter password: ", 0);

  v5 = read_x_bytes_or_til_escape_char(fd, (int)s, 0x257u, 10);

  v7 = v5;

  s[v5] = 0;

  result = check_username_n_pass(fd, a3, (const char *)s1, s);

  if ( result )

    result = send_with_or_without_null(fd, "Bad username or pass: ", 0);

  return result;

}



//----- (0804B7E0) --------------------------------------------------------

int __cdecl print_menu(int fd)

{

  send_with_or_without_null(fd, "\n\nfantasy chicken farmin league\n", 0);

  if ( logged_in )

  {

    write_string(fd, "\n\nmenu    (%s)\n", &s1);

    write_string(fd, " L) logout\n");

    write_string(fd, " b) buy chickens\n");

    write_string(fd, " i) incinerate money\n");

    write_string(fd, " s) sell eggs\n");

    write_string(fd, " p) display my info\n");

    write_string(fd, " u) update my info\n");

    if ( admin )

      write_string(fd, " P) print userlist\n");

  }

  else

  {

    write_string(fd, "\n\nmenu\n");

    write_string(fd, " c) create account\n");

    write_string(fd, " l) login\n");

  }

  return write_string(fd, " q) quit \n");

}

// 804E420: using guessed type int dword_804E420;

// 804E424: using guessed type int dword_804E424;



//----- (0804B90A) --------------------------------------------------------

int __cdecl readfromfd(FILE *stream, int a2, unsigned int a3, char a4)

{

  char ptr; // [sp+2Bh] [bp-Dh]@2

  unsigned int i; // [sp+2Ch] [bp-Ch]@1



  for ( i = 0; ; ++i )

  {

    if ( !fread(&ptr, 1u, 1u, stream) )

      return -1;

    if ( ptr == a4 )

      return i;

    if ( i >= a3 )

      break;

    *(_BYTE *)(i + a2) = ptr;

  }

  return -1;

}



//----- (0804B9E6) --------------------------------------------------------

void *__cdecl allocandfillstruct(int fd, sruct *head, const char *username, const char *info, const char *office, const char *password, int id, int perms, int money, int chickens, int eggs)

{

  void *result; // eax@1

  void *v12; // [sp+1Ch] [bp-Ch]@1



  result = malloc(0x9Cu);

  newuser = result;

  if ( result )

  {

    strcpy((char *)newuser.user, username);

    strcpy((char *)newuser.info, info);

    strcpy((char *)newuser.office, office);

    strcpy((char *)newuser.password, password);

    *((_DWORD *)v12 + 18) = id; //id

    *((_DWORD *)v12 + 14) = perms;// perm

    *((_DWORD *)v12 + 16) = money; // monies

    *((_DWORD *)v12 + 15) = chickens; // chickens

    *((_DWORD *)v12 + 17) = eggs; // eggs

    *((_DWORD *)v12 + 19) = *(_DWORD *)(head + 76); // link first ptr to former first

    *((_DWORD *)v12 + 20) = head; // link last pointer to head

    *(_DWORD *)(a2 + 76) = v12; // set head next ptr to this

    result = 0;

  }

  return result;

}


//----- (0804BAB7) --------------------------------------------------------

signed int __cdecl opendbandinit(const char *filename, int head, int fd)

{

  char password[59ish]; // [sp+39h] [bp-2FFh]@1

  char office[33]; // [sp+5Ah] [bp-2DEh]@1

  char info[20]; // [sp+6Eh] [bp-2CAh]@1

  char username[50]; // [sp+A0h] [bp-298h]@1

  char v8[20]; // [sp+B4h] [bp-284h]@3

  signed int v9; // [sp+30Ch] [bp-2Ch]@1

  int v10; // [sp+310h] [bp-28h]@1

  int v11; // [sp+314h] [bp-24h]@1

  int id; // [sp+318h] [bp-20h]@6

  int perms; // [sp+31Ch] [bp-1Ch]@16

  int chickens; // [sp+320h] [bp-18h]@18

  int eggs; // [sp+324h] [bp-14h]@20

  int money; // [sp+328h] [bp-10h]@22

  FILE *v17; // [sp+32Ch] [bp-Ch]@1



  v9 = 0;

  v10 = 0;

  v11 = 0;

  bzero(&username, 0x14u);

  bzero(&info, 0x32u);

  bzero(&office, 0x14u);

  bzero(&password, 0x21u);

  v17 = fopen(filename, "rb");

  if ( v17 )

  {

    while ( 1 )

    {

      v10 = readfromfd(v17, (int)&v8, 0x257u, 10);

      if ( v10 == -1 )

        break;

      *(&v8 + v10) = 0;

      if ( strcmp(&v8, "[user db]") )

      {

        if ( strcmp(&v8, "[user]") )

        {

          v9 = 1;

          break;

        }

        ++v11;

        v10 = readfromfd(v17, (int)&v8, 0x257u, 10);

        if ( v10 != -1 )

        {

          *(&v8 + v10) = 0;

          id = atoi(&v8); // size first thing after user

        }

        v10 = readfromfd(v17, (int)&v8, 0x257u, 10);

        if ( v10 != -1 )

        {

          *(&v8 + v10) = 0;

          strncpy(&username, &v8, 0x14u);

        }

        v10 = readfromfd(v17, (int)&v8, 0x257u, 10);

        if ( v10 != -1 )

        {

          *(&v8 + v10) = 0;

          strncpy(&info, &v8, 0x32u);

        }

        v10 = readfromfd(v17, (int)&v8, 0x257u, 10);

        if ( v10 != -1 )

        {

          *(&v8 + v10) = 0;

          strncpy(&office, &v8, 0x14u);

        }

        v10 = readfromfd(v17, (int)&v8, 0x257u, 10);

        if ( v10 != -1 )

        {

          *(&v8 + v10) = 0;

          strncpy(&password, &v8, 0x21u);

        }

        v10 = readfromfd(v17, (int)&v8, 0x257u, 10);

        if ( v10 != -1 )

        {

          *(&v8 + v10) = 0;

          perms = atoi(&v8);

        }

        v10 = readfromfd(v17, (int)&v8, 0x257u, 10);

        if ( v10 != -1 )

        {

          *(&v8 + v10) = 0;

          chickens = atoi(&v8);

        }

        v10 = readfromfd(v17, (int)&v8, 0x257u, 10);

        if ( v10 != -1 )

        {

          *(&v8 + v10) = 0;

          eggs = atoi(&v8);

        }

        v10 = readfromfd(v17, (int)&v8, 0x257u, 10);

        if ( v10 != -1 )

        {

          *(&v8 + v10) = 0;

          money = atoi(&v8);

        }

        if ( allocandfillstruct(fd, head, &username, &info, &office, &password, id, perms, money, chickens, eggs) )

        {

          v9 = 1;

          write_string(fd, "insert failed.\n");

          break;

        }

      }

    }

    fclose(v17);

  }

  else

  {

    write_string(fd, "attempted %s.\n", filename);

    v9 = 1;

  }

  return v9;

}



//----- (0804C067) --------------------------------------------------------

void __cdecl sub_804C067(int fd)

{

  send_with_or_without_null(fd, "cya\n", 0);

  close(fd);

  exit(0);

}



//----- (0804C09F) --------------------------------------------------------

int __cdecl sub_804C09F(int a1)

{

  int v1; // edx@1

  int result; // eax@11

  signed int v3; // [sp+8h] [bp-10h]@1

  int v4; // [sp+Ch] [bp-Ch]@6



  v1 = rand() % 5;

  v3 = v1 - 2;

  if ( v1 != 2 )

  {

    *(_DWORD *)dword_804E40C += v3;

    *(_DWORD *)dword_804E410 += v3 / 2;

    if ( !*(_DWORD *)dword_804E410 )

      *(_DWORD *)dword_804E410 = 1;

    if ( !*(_DWORD *)dword_804E410 )

      *(_DWORD *)dword_804E410 = 1;

  }

  v4 = a1;

  while ( 1 )

  {

    result = *(_DWORD *)(v4 + 76);

    if ( !result )

      break;

    v4 = *(_DWORD *)(v4 + 76);

    if ( *(_DWORD *)(v4 + 60) )

    {

      if ( v3 == 1 )

        *(_DWORD *)(v4 + 60) += *(_DWORD *)(v4 + 60) >> 2;

      *(_DWORD *)(v4 + 68) = *(_DWORD *)(v4 + 60) + *(_DWORD *)(v4 + 68) - (*(_DWORD *)(v4 + 60) >> 3);

    }

  }

  return result;

}



//----- (0804C18B) --------------------------------------------------------

void __cdecl sub_804C18B(int fd)

{

  unsigned int v1; // eax@1

  int nptr; // [sp+26Ch] [bp-26Ch]@7

  char v3[4]; // [sp+4C4h] [bp-14h]@1

  void *s; // [sp+4C8h] [bp-10h]@1

  FILE *stream; // [sp+4CCh] [bp-Ch]@40



  *(_DWORD *)v3 = 0;

  v1 = time(0);

  srand(v1);

  s = malloc(0x9Cu);

  if ( !s )

  {

    send_with_or_without_null(fd, "can't allocate user_list, quitting\n", 0);

    sub_804C067(fd);

  }

  bzero(s, 0x9Cu);

  *((_DWORD *)s + 19) = 0;

  *((_DWORD *)s + 20) = 0;

  sub_804A988();

  if ( opendbandinit("/home/fcfl/user.db", (int)s, fd) )

  {

    send_with_or_without_null(fd, "can't read user db, quitting\n", 0);

    sub_804C067(fd);

  }

  while ( 1 )

  {

    sub_804C09F((int)s);

    print_menu(fd);

    *(_DWORD *)v3 = read_x_bytes_or_til_escape_char(fd, (int)&nptr, 0x257u, 10);

    nptr[v3] = 0;

    write_string(fd, "%d: %s\n", *(_DWORD *)v3, &nptr);

    if ( *(_DWORD *)v3 == 1 ) // one byte read

    {

      if ( (_BYTE)nptr != aC[0] || logged_in )

      {

        if ( (_BYTE)nptr != asc_804D115[0] || logged_in )

        {

          if ( (_BYTE)nptr == aS_1[0] && logged_in )

          {

            buy_eggs(fd, (const char *)&nptr, (int)s);

          }

          else

          {

            if ( (_BYTE)nptr == aI[0] && logged_in )

            {

              burn_money(fd, (const char *)&nptr, (int)s);

            }

            else

            {

              if ( (_BYTE)nptr == aB[0] && logged_in )

              {

                buy_chickens(fd, (const char *)&nptr, (int)s);

              }

              else

              {

                if ( (_BYTE)nptr == aU[0] && logged_in )

                {

                  change_info(fd, (const char *)&nptr, (int)s);

                }

                else

                {

                  if ( (_BYTE)nptr == aP[0] && logged_in )

                  {

                    sub_804A855(fd, (int)s);

                  }

                  else

                  {

                    if ( (_BYTE)nptr == asc_804D121[0] && logged_in )

                    {

                      sub_804A988();

                    }

                    else

                    {

                      if ( (_BYTE)nptr == aP_0[0] && logged_in && admin )

                      {

                        sub_804A820(fd, (int)s);

                      }

                      else

                      {

                        if ( (_BYTE)nptr == a6[0] && logged_in && admin )

                        {

                          stream = fopen("/home/fcfl/key", "rb");

                          *(_DWORD *)v3 = readfromfd(stream, (int)&nptr, 0x257u, 10);

                          if ( *(_DWORD *)v3 != -1 )

                          {

                            *((_BYTE *)&nptr + *(_DWORD *)v3) = 0;

                            send_with_or_without_null(fd, (const char *)&nptr, 1);

                          }

                        }

                        else

                        {

                          if ( (_BYTE)nptr == aQ[0] )

                            sub_804C067(fd);

                          send_with_or_without_null(fd, "that's not a valid option", 0);

                        }

                      }

                    }

                  }

                }

              }

            }

          }

        }

        else

        {

          try_login(fd, (int)&nptr, (char *)s);

        }

      }

      else

      {

        create_user(fd, (const char *)&nptr, (int)s);

      }

    }

    else

    {

      *(_DWORD *)v3 = 0;

      send_with_or_without_null(fd, "that's not a valid option", 0);

    }

  }

}

// 804E420: using guessed type int dword_804E420;

// 804E424: using guessed type int dword_804E424;



//----- (0804C5F0) --------------------------------------------------------

void __cdecl sub_804C5F0()

{

  ;

}



//----- (0804C600) --------------------------------------------------------

int *__cdecl sub_804C600()

{

  init_proc();

  return &dword_804E1D8;

}

// 804E1D8: using guessed type int dword_804E1D8;



//----- (0804C65A) --------------------------------------------------------

void __cdecl sub_804C65A()

{

  ;

}



//----- (0804C660) --------------------------------------------------------

void (*__cdecl sub_804C660())(void)

{

  void (*result)(void); // eax@1

  int *v1; // ebx@2



  result = (void (*)(void))dword_804E1D8;

  if ( dword_804E1D8 != -1 )

  {

    v1 = &dword_804E1D8;

    do

    {

      --v1;

      result();

      result = (void (*)(void))*v1;

    }

    while ( *v1 != -1 );

  }

  return result;

}

// 804E1D8: using guessed type int dword_804E1D8;



//----- (0804C68C) --------------------------------------------------------

void __cdecl term_proc()

{

  sub_8048CB0();

}



#error "There were 1 decompilation failure(s) on 48 function(s)"