isnum

decompiled_code:
__int64 __fastcall isnum(char *a1)
{
__int64 v1; // rbx
char *v2; // rbp
int v3; // er12

v1 = *a1;
if ( !(_BYTE)v1 )
return 1LL;
v2 = a1 + 1;
v3 = 0;
while ( (((_BYTE)v1 - 43) & 0xFD) == 0 )
{
if ( v3 )
return 0LL;
v3 = 1;
LABEL_6:
v1 = *v2++;
if ( !(_BYTE)v1 )
return 1LL;
}
if ( ((*_ctype_b_loc())[v1] & 0x800) != 0 )
goto LABEL_6;
return 0LL;
}

canonical_decompiled_code:
__int64 __fastcall func0(char *a1)
{
__int64 v1; // rbx
char *v2; // rbp
int v3; // er12

v1 = *a1;
if ( !(_BYTE)v1 )
return 1LL;
v2 = a1 + 1;
v3 = 0;
while ( (((_BYTE)v1 - 43) & 0xFD) == 0 )
{
if ( v3 )
return 0LL;
v3 = 1;
LABEL_6:
v1 = *v2++;
if ( !(_BYTE)v1 )
return 1LL;
}
if ( ((*_ctype_b_loc())[v1] & 0x800) != 0 )
goto LABEL_6;
return 0LL;
}

original_code:
static int isnum(const char *s)
{
 int si = 0;
 while(*s)
 {
  if((*s == '-') || (*s == '+'))
  {
   if(!si)
   {
    si = 1;
    s++;
    continue;
   }
   else return 0;
  }
  if(!((*__ctype_b_loc ())[(int) ((*s++))] & (unsigned short int) _ISdigit))
   return 0;
 }
 return 1;
}

canonical_original_code:
static int isnum(char *s)
{
 int si = 0;
 while(*s)
 {
  if((*s == '-') || (*s == '+'))
  {
   if(!si)
   {
    si = 1;
    s++;
    continue;
   }
   else return 0;
  }
  if(!((*__ctype_b_loc ())[(int) ((*s++))] & (unsigned short) _ISdigit))
   return 0;
 }
 return 1;
}

variable_types:
s
char *

variable_types: si int

return_type: int


isidsym

decompiled_code:
__int64 __fastcall isidsym(char a1)
{
return ((a1 == 95) | (unsigned __int8)((*_ctype_b_loc())[a1] >> 3)) & 1;
}

canonical_decompiled_code:
__int64 __fastcall func1(char a1)
{
return ((a1 == 95) | (unsigned __int8)((*_ctype_b_loc())[a1] >> 3)) & 1;
}

original_code:
static int isidsym(char c)
{
 return (((*__ctype_b_loc ())[(int) ((c))] & (unsigned short int) _ISalnum)||(c == '_'));
}

canonical_original_code:
static int isidsym(char c)
{
 return (((*__ctype_b_loc ())[(int) ((c))] & (unsigned short) _ISalnum)||(c == '_'));
}

variable_types: c char


isident

decompiled_code:
__int64 __fastcall isident(char *a1)
{
const unsigned __int16 **v2; // rax
__int64 v3; // rcx
__int64 result; // rax
char v5; // di
char *v6; // rbx

v2 = _ctype_b_loc();
v3 = *a1;
if ( ((*v2)[v3] & 0x400) != 0 || (result = 0LL, (_BYTE)v3 == 95) )
{
v5 = a1[1];
v6 = a1 + 1;
if ( a1[1] )
{
while ( 1 )
{
result = isidsym(v5);
if ( !(_DWORD)result )
break;
v5 = *++v6;
if ( !v5 )
goto LABEL_8;
}
}
else
{
LABEL_8:
result = 1LL;
}
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func2(char *a1)
{
const unsigned __int16 **v2; // rax
__int64 v3; // rcx
__int64 result; // rax
char v5; // di
char *v6; // rbx

v2 = _ctype_b_loc();
v3 = *a1;
if ( ((*v2)[v3] & 0x400) != 0 || (result = 0LL, (_BYTE)v3 == 95) )
{
v5 = a1[1];
v6 = a1 + 1;
if ( a1[1] )
{
while ( 1 )
{
result = func1(v5);
if ( !(_DWORD)result )
break;
v5 = *++v6;
if ( !v5 )
goto LABEL_8;
}
}
else
{
LABEL_8:
result = 1LL;
}
}
return result;
}

original_code:
static int isident(const char *s)
{
 if ((!((*__ctype_b_loc ())[(int) ((*s))] & (unsigned short int) _ISalpha)) && (*s != '_'))
  return 0;
 s++;
 while(*s)
 {
  if(!isidsym(*s))
   return 0;
  s++;
 }
 return 1;
}

canonical_original_code:
static int isident(char *s)
{
 if ((!((*__ctype_b_loc ())[(int) ((*s))] & (unsigned short) _ISalpha)) && (*s != '_'))
  return 0;
 s++;
 while(*s)
 {
  if(!isidsym(*s))
   return 0;
  s++;
 }
 return 1;
}


isfloat

original_code:
static int isfloat(const char *s)
{
 int p = 0;
 int e = 0;
 int si = 0;
 int n = 0;
 while(*s)
 {
  if(*s == get_dec_point())
  {
   if((p == 0)&&(n == 1))
    p = 1;
   else
    return 0;
  } else if((tolower(*s) == 'e')&&(n == 1)) {
   if(e == 0)
    e = 1;
   else
    return 0;
  } else if((*s == '-')||(*s == '+')) {
   if((si == 0) && (e != 0) && (tolower(*(s - 1)) == 'e'))
    si = 1;
   else
    return 0;
  } else if(!((*__ctype_b_loc ())[(int) ((*s))] & (unsigned short int) _ISdigit)) {
   return 0;
  } else n = 1;
  s++;
 }
 return 1;
}

canonical_original_code:
static int isfloat(char *s)
{
 int p = 0;
 int e = 0;
 int si = 0;
 int n = 0;
 while(*s)
 {
  if(*s == get_dec_point())
  {
   if((p == 0)&&(n == 1))
    p = 1;
   else
    return 0;
  } else if((tolower(*s) == 'e')&&(n == 1)) {
   if(e == 0)
    e = 1;
   else
    return 0;
  } else if((*s == '-')||(*s == '+')) {
   if((si == 0) && (e != 0) && (tolower(*(s - 1)) == 'e'))
    si = 1;
   else
    return 0;
  } else if(!((*__ctype_b_loc ())[(int) ((*s))] & (unsigned short) _ISdigit)) {
   return 0;
  } else n = 1;
  s++;
 }
 return 1;
}

variable_types: p int

variable_types: e int

variable_types: n int


decompiled_code:
__int64 __fastcall sym_get_code(char *s1)
{
const char *v1; // rsi
__int64 i; // rbx
int v3; // er8
__int64 result; // rax
int v5; // er8

v1 = (const char *)&unk_35E;
for ( i = 0LL; ; v1 = (const char *)*(&off_4C8 + 2 * i) )
{
if ( !strncasecmp(s1, v1, 0x64uLL) )
return (unsigned int)sym_bols[4 * (int)i];
if ( ++i == 71 )
break;
}
v3 = isnum(s1);
result = 1001LL;
if ( !v3 )
{
v5 = isfloat(s1);
result = 1002LL;
if ( !v5 )
{
if ( (unsigned int)isident(s1) )
{
result = 1000LL;
}
else
{
err_include(3LL, "SYM : unknown symbol", 0LL, lex_line, lex_c);
result = 0LL;
}
}
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func4(char *s1)
{
const char *v1; // rsi
__int64 i; // rbx
int v3; // er8
__int64 result; // rax
int v5; // er8

v1 = (const char *)&unk_35E;
for ( i = 0LL; ; v1 = (const char *)*(&off_4C8 + 2 * i) )
{
if ( !strncasecmp(s1, v1, 0x64uLL) )
return (unsigned int)sym_bols[4 * (int)i];
if ( ++i == 71 )
break;
}
v3 = func0(s1);
result = 1001LL;
if ( !v3 )
{
v5 = func3(s1);
result = 1002LL;
if ( !v5 )
{
if ( (unsigned int)func2(s1) )
{
result = 1000LL;
}
else
{
err_include(3LL, "SYM : unknown symbol", 0LL, lex_line, lex_c);
result = 0LL;
}
}
}
return result;
}

original_code:
int sym_get_code(const char *sym)
{
 int i;
 for(i = 0; i < sym_count; i++)
 {
  if(!strncasecmp(sym, sym_bols[i].sym, 100))
  {
   return sym_bols[i].code;
  }
 }
 if(isnum(sym))
  return L_NUMERIC;
 if(isfloat(sym))
  return L_FLOAT;
 if(isident(sym))
  return L_IDENT;
 err_include(ERROR, "SYM : unknown symbol", 0, lex_line, lex_c);
 return 0;
}

canonical_original_code:
int sym_get_code(char *sym)
{
 int i;
 for(i = 0; i < sym_count; i++)
 {
  if(!strncasecmp(sym, sym_bols[i].sym, 100))
  {
   return sym_bols[i].code;
  }
 }
 if(isnum(sym))
  return L_NUMERIC;
 if(isfloat(sym))
  return L_FLOAT;
 if(isident(sym))
  return L_IDENT;
 err_include(ERROR, "SYM : unknown symbol", 0, lex_line, lex_c);
 return 0;
}

variable_types:
sym
char *

variable_types: i int


decompiled_code:
__int64 __fastcall sym_get_sym(int a1)
{
__int64 v1; // rax
int i; // edx

v1 = 0LL;
for ( i = 46; i != a1; i = sym_bols[4 * v1] )
{
if ( ++v1 == 71 )
{
err_include(3LL, "SYM : unknown code", 0LL, lex_line, lex_c);
return 0LL;
}
}
return (__int64)*(&off_4C8 + 2 * (int)v1);
}

canonical_decompiled_code:
__int64 __fastcall func5(int a1)
{
__int64 v1; // rax
int i; // edx

v1 = 0LL;
for ( i = 46; i != a1; i = sym_bols[4 * v1] )
{
if ( ++v1 == 71 )
{
err_include(3LL, "SYM : unknown code", 0LL, lex_line, lex_c);
return 0LL;
}
}
return (__int64)*(&off_4C8 + 2 * (int)v1);
}

original_code:
char *sym_get_sym(int code)
{
 int i;
 for(i = 0; i < sym_count; i++)
 {
  if(code == sym_bols[i].code)
  {
   return sym_bols[i].sym;
  }
 }
 err_include(ERROR, "SYM : unknown code", 0, lex_line, lex_c);
 return 0;
}

variable_types: code int

return_type: char *


decompiled_code:
__int64 search_type_table()
{
return 0LL;
}

canonical_decompiled_code:
__int64 func0()
{
return 0LL;
}

canonical_original_code:
struct _type_table_elem *search_type_table()
{
    return 0;
}

return_type: struct _type_table_elem { enum USE_TYPE { UT_SCALAR=5000, UT_LIMITED=5001, UT_ENUM=5002, UT_ARRAY=5003, UT_RECORD=5004, UT_REFERENCE=5005, UT_SET=5006, UT_FILE=5007 } utype; struct _type_table_elem *base; union { struct _list { void *value; struct _list *next; } *constants; struct _list *indexes; struct { unsigned long min; }; }; } *

user_defined_types: struct _type_table_elem { enum USE_TYPE utype; struct _type_table_elem *base; union { struct _list *constants; struct _list *indexes; struct { unsigned long min; }; }; }


decompiled_code:
_QWORD *type_init()
{
_QWORD *v0; // rax
_QWORD *v1; // rax
__int64 v2; // r12
__int64 v3; // rbp
_QWORD *result; // rax

v0 = add_to_type_table(0LL, 5001);
v0[2] = 0LL;
v0[3] = 255LL;
chartype = (__int64)v0;
v1 = add_to_type_table(0LL, 5001);
v1[2] = 0LL;
v1[3] = 0x10000LL;
inttype = (__int64)v1;
v2 = add_to_id_table(0LL, "true", 4002LL);
v3 = add_to_id_table(0LL, "false", 4002LL);
booltype = (__int64)add_to_type_table(0LL, 5002);
add_to_list(booltype + 16, v2);
add_to_list(booltype + 16, v3);
realtype = (__int64)add_to_type_table(0LL, 5001);
texttype = (__int64)add_to_type_table(chartype, 5007);
stringtype = (__int64)add_to_type_table(0LL, 5000);
result = add_to_type_table(0LL, 5005);
ptrtype = (__int64)result;
return result;
}

canonical_decompiled_code:
_QWORD *func1()
{
_QWORD *v0; // rax
_QWORD *v1; // rax
__int64 v2; // r12
__int64 v3; // rbp
_QWORD *result; // rax

v0 = add_to_type_table(0LL, 5001);
v0[2] = 0LL;
v0[3] = 255LL;
chartype = (__int64)v0;
v1 = add_to_type_table(0LL, 5001);
v1[2] = 0LL;
v1[3] = 0x10000LL;
inttype = (__int64)v1;
v2 = add_to_id_table(0LL, "true", 4002LL);
v3 = add_to_id_table(0LL, "false", 4002LL);
booltype = (__int64)add_to_type_table(0LL, 5002);
add_to_list(booltype + 16, v2);
add_to_list(booltype + 16, v3);
realtype = (__int64)add_to_type_table(0LL, 5001);
texttype = (__int64)add_to_type_table(chartype, 5007);
stringtype = (__int64)add_to_type_table(0LL, 5000);
result = add_to_type_table(0LL, 5005);
ptrtype = (__int64)result;
return result;
}

original_code:
void type_init(void)
{
    chartype = add_to_type_table(0, UT_LIMITED);
    chartype->min = 0;
    chartype->max = 255;
    inttype = add_to_type_table(0, UT_LIMITED);
    inttype->min = 0;
    inttype->max = 65536;
    id_table_elem *t, *f;
    t = add_to_id_table(0, "true", UC_CONST);
    f = add_to_id_table(0, "false", UC_CONST);
    booltype = add_to_type_table(0, UT_ENUM);
    add_to_list(&(booltype->constants), t);
    add_to_list(&(booltype->constants), f);
    realtype = add_to_type_table(0, UT_LIMITED);
    texttype = add_to_type_table(chartype, UT_FILE);
    stringtype = add_to_type_table(0, UT_SCALAR);
    ptrtype = add_to_type_table(0, UT_REFERENCE);
}

canonical_original_code:
void type_init()
{
    chartype = add_to_type_table(0, UT_LIMITED);
    chartype->min = 0;
    chartype->max = 255;
    inttype = add_to_type_table(0, UT_LIMITED);
    inttype->min = 0;
    inttype->max = 65536;
    struct _id_table_elem *t; struct _id_table_elem *f;
    t = add_to_id_table(0, "true", UC_CONST);
    f = add_to_id_table(0, "false", UC_CONST);
    booltype = add_to_type_table(0, UT_ENUM);
    add_to_list(&(booltype->constants), t);
    add_to_list(&(booltype->constants), f);
    realtype = add_to_type_table(0, UT_LIMITED);
    texttype = add_to_type_table(chartype, UT_FILE);
    stringtype = add_to_type_table(0, UT_SCALAR);
    ptrtype = add_to_type_table(0, UT_REFERENCE);
}

variable_types: struct _id_table_elem { unsigned long hash; char *name; enum USE_CLASS { UC_PROG=4000, UC_TYPE=4001, UC_CONST=4002, UC_VAR=4003, UC_PROC=4004, UC_FUNC=4005, UC_UNK=4006 } uclass; struct _type_table_elem { enum USE_TYPE { UT_SCALAR=5000, UT_LIMITED=5001, UT_ENUM=5002, UT_ARRAY=5003, UT_RECORD=5004, UT_REFERENCE=5005, UT_SET=5006, UT_FILE=5007 } utype; struct _type_table_elem *base; union { struct _list { void *value; struct _list *next; } *constants; struct _list *indexes; struct { unsigned long min; }; }; } *type; int value; } *

return_type: void

user_defined_types: struct _id_table_elem { unsigned long hash; char *name; enum USE_CLASS uclass; struct _type_table_elem *type; int value; }


decompiled_code:
_BOOL8 __fastcall can_assign(__int64 a1, __int64 a2)
{
_BOOL8 result; // rax
__int64 v3; // rcx

result = 1LL;
if ( a1 != a2 )
{
if ( !a1 || !a2 )
return 1LL;
if ( realtype != a1 || inttype != a2 )
{
if ( stringtype != a1 || (result = 1LL, chartype != a2) )
{
if ( *(_DWORD *)a1 != 5001 || (result = 1LL, *(_QWORD *)(a1 + 8) != a2) )
{
if ( *(_DWORD *)a2 != 5001 )
goto LABEL_8;
v3 = *(_QWORD *)(a2 + 8);
result = 1LL;
if ( v3 == a1 )
return result;
if ( *(_DWORD *)a1 == 5001 )
result = *(_QWORD *)(a1 + 8) == v3;
else
LABEL_8:
result = 0LL;
}
}
}
}
return result;
}

canonical_decompiled_code:
_BOOL8 __fastcall func2(__int64 a1, __int64 a2)
{
_BOOL8 result; // rax
__int64 v3; // rcx

result = 1LL;
if ( a1 != a2 )
{
if ( !a1 || !a2 )
return 1LL;
if ( realtype != a1 || inttype != a2 )
{
if ( stringtype != a1 || (result = 1LL, chartype != a2) )
{
if ( *(_DWORD *)a1 != 5001 || (result = 1LL, *(_QWORD *)(a1 + 8) != a2) )
{
if ( *(_DWORD *)a2 != 5001 )
goto LABEL_8;
v3 = *(_QWORD *)(a2 + 8);
result = 1LL;
if ( v3 == a1 )
return result;
if ( *(_DWORD *)a1 == 5001 )
result = *(_QWORD *)(a1 + 8) == v3;
else
LABEL_8:
result = 0LL;
}
}
}
}
return result;
}

original_code:
int can_assign(type_table_elem *tp1, type_table_elem *tp2)
{
    return
        (tp1 == tp2) ||
        ((tp1 == 0) || (tp2 == 0)) ||
        ((tp1 == realtype) && (tp2 == inttype)) ||
        ((tp1 == stringtype) && (tp2 == chartype)) ||
        ((tp1->utype == UT_LIMITED) && (tp1->base == tp2)) ||
        ((tp2->utype == UT_LIMITED) && (tp2->base == tp1)) ||
        ((tp1->utype == UT_LIMITED) && (tp2->utype == UT_LIMITED) && (tp2->base == tp1->base)) ||
        (0);
}

canonical_original_code:
int can_assign(struct _type_table_elem *tp1, struct _type_table_elem *tp2)
{
    return
        (tp1 == tp2) ||
        ((tp1 == 0) || (tp2 == 0)) ||
        ((tp1 == realtype) && (tp2 == inttype)) ||
        ((tp1 == stringtype) && (tp2 == chartype)) ||
        ((tp1->utype == UT_LIMITED) && (tp1->base == tp2)) ||
        ((tp2->utype == UT_LIMITED) && (tp2->base == tp1)) ||
        ((tp1->utype == UT_LIMITED) && (tp2->utype == UT_LIMITED) && (tp2->base == tp1->base)) ||
        (0);
}

variable_types: struct _type_table_elem { enum USE_TYPE { UT_SCALAR=5000, UT_LIMITED=5001, UT_ENUM=5002, UT_ARRAY=5003, UT_RECORD=5004, UT_REFERENCE=5005, UT_SET=5006, UT_FILE=5007 } utype; struct _type_table_elem *base; union { struct _list { void *value; struct _list *next; } *constants; struct _list *indexes; struct { unsigned long min; }; }; } *


decompiled_code:
_BOOL8 __fastcall can_iterate(_DWORD *a1)
{
_BOOL8 result; // rax

if ( !a1 || (unsigned int)(*a1 - 5001) <= 1 || (_DWORD *)inttype == a1 )
result = 1LL;
else
result = chartype == (_QWORD)a1;
return result;
}

canonical_decompiled_code:
_BOOL8 __fastcall func3(_DWORD *a1)
{
_BOOL8 result; // rax

if ( !a1 || (unsigned int)(*a1 - 5001) <= 1 || (_DWORD *)inttype == a1 )
result = 1LL;
else
result = chartype == (_QWORD)a1;
return result;
}

original_code:
int can_iterate(type_table_elem *tp1)
{
    return
        (tp1 == 0) ||
        (tp1->utype == UT_ENUM) ||
        (tp1->utype == UT_LIMITED) ||
        (tp1 == inttype) ||
        (tp1 == chartype) ||
        (0);
}

canonical_original_code:
int can_iterate(struct _type_table_elem *tp1)
{
    return
        (tp1 == 0) ||
        (tp1->utype == UT_ENUM) ||
        (tp1->utype == UT_LIMITED) ||
        (tp1 == inttype) ||
        (tp1 == chartype) ||
        (0);
}

user_defined_types: enum USE_TYPE { UT_SCALAR=5000, UT_LIMITED=5001, UT_ENUM=5002, UT_ARRAY=5003, UT_RECORD=5004, UT_REFERENCE=5005, UT_SET=5006, UT_FILE=5007 }

user_defined_types: struct _list { void *value; struct _list *next; }


decompiled_code:
char *__fastcall get_type_name(int *a1)
{
const char *v1; // rsi
int v2; // eax
char *v4; // r12
const char *v5; // rsi
__int64 v6; // r13
char *v7; // rax

if ( !a1 )
return dcgettext(0LL, "unknown type", 5);
v1 = "integer";
if ( (int *)inttype == a1 )
return dcgettext(0LL, v1, 5);
v1 = "string";
if ( (int *)stringtype == a1 )
return dcgettext(0LL, v1, 5);
v1 = "real";
if ( (int *)realtype == a1 )
return dcgettext(0LL, v1, 5);
v1 = "boolean";
if ( (int *)booltype == a1 )
return dcgettext(0LL, v1, 5);
v1 = "pointer";
if ( (int *)ptrtype == a1 )
return dcgettext(0LL, v1, 5);
v1 = "char";
if ( (int *)chartype == a1 )
return dcgettext(0LL, v1, 5);
v1 = "text";
if ( (int *)texttype == a1 )
return dcgettext(0LL, v1, 5);
v2 = *a1;
if ( *a1 == 5003 )
{
v4 = (char *)malloc(0x400uLL);
v5 = "array of %s";
v6 = get_type_name(*((_QWORD *)a1 + 1), "text");
}
else if ( v2 == 5005 )
{
v4 = (char *)malloc(0x400uLL);
v5 = "pointer of %s";
v6 = get_type_name(*((_QWORD *)a1 + 1), "text");
}
else
{
v1 = "enumeration";
if ( v2 == 5002 )
return dcgettext(0LL, v1, 5);
v1 = "dummy";
if ( v2 != 5001 )
return dcgettext(0LL, v1, 5);
v4 = (char *)malloc(0x400uLL);
v5 = "limited of %s";
v6 = get_type_name(*((_QWORD *)a1 + 1), "dummy");
}
v7 = dcgettext(0LL, v5, 5);
sprintf(v4, v7, v6);
return v4;
}

canonical_decompiled_code:
char *__fastcall func4(int *a1)
{
const char *v1; // rsi
int v2; // eax
char *v4; // r12
const char *v5; // rsi
__int64 v6; // r13
char *v7; // rax

if ( !a1 )
return dcgettext(0LL, "unknown type", 5);
v1 = "integer";
if ( (int *)inttype == a1 )
return dcgettext(0LL, v1, 5);
v1 = "string";
if ( (int *)stringtype == a1 )
return dcgettext(0LL, v1, 5);
v1 = "real";
if ( (int *)realtype == a1 )
return dcgettext(0LL, v1, 5);
v1 = "boolean";
if ( (int *)booltype == a1 )
return dcgettext(0LL, v1, 5);
v1 = "pointer";
if ( (int *)ptrtype == a1 )
return dcgettext(0LL, v1, 5);
v1 = "char";
if ( (int *)chartype == a1 )
return dcgettext(0LL, v1, 5);
v1 = "text";
if ( (int *)texttype == a1 )
return dcgettext(0LL, v1, 5);
v2 = *a1;
if ( *a1 == 5003 )
{
v4 = (char *)malloc(0x400uLL);
v5 = "array of %s";
v6 = func4(*((_QWORD *)a1 + 1), "text");
}
else if ( v2 == 5005 )
{
v4 = (char *)malloc(0x400uLL);
v5 = "pointer of %s";
v6 = func4(*((_QWORD *)a1 + 1), "text");
}
else
{
v1 = "enumeration";
if ( v2 == 5002 )
return dcgettext(0LL, v1, 5);
v1 = "dummy";
if ( v2 != 5001 )
return dcgettext(0LL, v1, 5);
v4 = (char *)malloc(0x400uLL);
v5 = "limited of %s";
v6 = func4(*((_QWORD *)a1 + 1), "dummy");
}
v7 = dcgettext(0LL, v5, 5);
sprintf(v4, v7, v6);
return v4;
}

original_code:
char *get_type_name(type_table_elem *tp)
{
    if (tp == 0)
        return gettext("unknown type");
    if (tp == inttype)
        return gettext("integer");
    if (tp == stringtype)
        return gettext("string");
    if (tp == realtype)
        return gettext("real");
    if (tp == booltype)
        return gettext("boolean");
    if (tp == ptrtype)
        return gettext("pointer");
    if (tp == chartype)
        return gettext("char");
    if (tp == texttype)
        return gettext("text");
    if (tp->utype == UT_ARRAY)
    {
        char *tmp = malloc(1024);
        sprintf(tmp, gettext("array of %s"), get_type_name(tp->base));
        return tmp;
    }
    if (tp->utype == UT_REFERENCE)
    {
        char *tmp = malloc(1024);
        sprintf(tmp, gettext("pointer of %s"), get_type_name(tp->base));
        return tmp;
    }
    if (tp->utype == UT_ENUM)
    {
        return gettext("enumeration");
    }
    if (tp->utype == UT_LIMITED)
    {
        char *tmp = malloc(1024);
        sprintf(tmp, gettext("limited of %s"), get_type_name(tp->base));
        return tmp;
    }
    return gettext("dummy");
}

canonical_original_code:
char *get_type_name(struct _type_table_elem *tp)
{
    if (tp == 0)
        return gettext("unknown type");
    if (tp == inttype)
        return gettext("integer");
    if (tp == stringtype)
        return gettext("string");
    if (tp == realtype)
        return gettext("real");
    if (tp == booltype)
        return gettext("boolean");
    if (tp == ptrtype)
        return gettext("pointer");
    if (tp == chartype)
        return gettext("char");
    if (tp == texttype)
        return gettext("text");
    if (tp->utype == UT_ARRAY)
    {
        char *tmp = malloc(1024);
        sprintf(tmp, gettext("array of %s"), get_type_name(tp->base));
        return tmp;
    }
    if (tp->utype == UT_REFERENCE)
    {
        char *tmp = malloc(1024);
        sprintf(tmp, gettext("pointer of %s"), get_type_name(tp->base));
        return tmp;
    }
    if (tp->utype == UT_ENUM)
    {
        return gettext("enumeration");
    }
    if (tp->utype == UT_LIMITED)
    {
        char *tmp = malloc(1024);
        sprintf(tmp, gettext("limited of %s"), get_type_name(tp->base));
        return tmp;
    }
    return gettext("dummy");
}

variable_types:
tmp
char *


decompiled_code:
__int64 __fastcall mix_types(__int64 a1, __int64 a2, int a3)
{
char *v4; // r13
char *v5; // r14
char *v6; // r12
char *v7; // rax
unsigned int v8; // ebp
char *v9; // rax
__int64 result; // rax
int v11; // edx
int v12; // eax
__int64 v13; // rcx
__int64 v14; // rsi

if ( !a1 )
return 0LL;
if ( !a2 )
return 0LL;
if ( a3 <= 62 )
{
if ( a3 > 41 )
{
switch ( a3 )
{
case '*':
case '-':
goto LABEL_26;
case '+':
result = stringtype;
if ( (stringtype == a1 || chartype == a1) && (stringtype == a2 || chartype == a2) )
return result;
LABEL_26:
if ( a1 == a2 && (inttype == a1 || realtype == a1) )
return a1;
v11 = *(_DWORD *)a1;
v12 = *(_DWORD *)a2;
if ( *(_DWORD *)a1 != 5001 )
{
if ( v12 != 5001 )
{
LABEL_29:
result = realtype;
if ( realtype == a1 )
goto LABEL_34;
v13 = inttype;
if ( inttype == a1 )
goto LABEL_34;
v11 = *(_DWORD *)a1;
goto LABEL_32;
}
v14 = inttype;
goto LABEL_62;
}
v14 = inttype;
v13 = inttype;
if ( v12 != 5001 )
{
if ( a2 == inttype )
{
result = *(_QWORD *)(a1 + 8);
if ( a2 == result )
return result;
}
goto LABEL_29;
}
result = *(_QWORD *)(a1 + 8);
if ( result == inttype && *(_QWORD *)(a2 + 8) == result )
return result;
if ( a2 == inttype )
{
if ( result == a2 )
return result;
LABEL_62:
v13 = v14;
}
if ( a1 == v14 )
{
result = realtype;
if ( *(_QWORD *)(a2 + 8) == a1 )
return a1;
goto LABEL_34;
}
result = realtype;
if ( a1 == realtype )
goto LABEL_34;
LABEL_32:
if ( v11 != 5001 || *(_QWORD *)(a1 + 8) != v13 )
goto LABEL_10;
LABEL_34:
if ( a2 != result && inttype != a2 && (*(_DWORD *)a2 != 5001 || inttype != *(_QWORD *)(a2 + 8)) )
goto LABEL_10;
break;
case '/':
goto LABEL_29;
case '<':
case '=':
case '>':
goto LABEL_39;
default:
goto LABEL_10;
}
return result;
}
goto LABEL_10;
}
if ( a3 <= 503 )
{
if ( a3 > 501 )
goto LABEL_77;
if ( a3 <= 304 )
{
if ( a3 > 301 )
{
LABEL_39:
if ( (realtype == a1 || inttype == a1 || *(_DWORD *)a1 == 5001 && inttype == *(_QWORD *)(a1 + 8))
&& (realtype == a2 || inttype == a2 || *(_DWORD *)a2 == 5001 && inttype == *(_QWORD *)(a2 + 8))
|| a1 == a2 )
{
return booltype;
}
}
goto LABEL_10;
}
if ( a3 == 400 )
{
LABEL_77:
if ( a1 == a2 )
{
result = a1;
if ( booltype == a1 )
return result;
}
}
LABEL_10:
v4 = (char *)malloc(0x400uLL);
v5 = get_type_name((int *)a2);
v6 = get_type_name((int *)a1);
v7 = dcgettext(0LL, "'%s' and '%s'", 5);
sprintf(v4, v7, v6, v5);
v8 = sem_c;
LODWORD(v6) = sem_l;
v9 = dcgettext(0LL, "wrong types:", 5);
err_include(3LL, v9, v4, (unsigned int)v6, v8);
return 0LL;
}
if ( (unsigned int)(a3 - 506) > 1 || inttype != a1 && (*(_DWORD *)a1 != 5001 || inttype != *(_QWORD *)(a1 + 8)) )
goto LABEL_10;
if ( inttype == a2 )
return inttype;
if ( *(_DWORD *)a2 != 5001 )
goto LABEL_10;
result = *(_QWORD *)(a2 + 8);
if ( inttype != result )
goto LABEL_10;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func5(__int64 a1, __int64 a2, int a3)
{
char *v4; // r13
char *v5; // r14
char *v6; // r12
char *v7; // rax
unsigned int v8; // ebp
char *v9; // rax
__int64 result; // rax
int v11; // edx
int v12; // eax
__int64 v13; // rcx
__int64 v14; // rsi

if ( !a1 )
return 0LL;
if ( !a2 )
return 0LL;
if ( a3 <= 62 )
{
if ( a3 > 41 )
{
switch ( a3 )
{
case '*':
case '-':
goto LABEL_26;
case '+':
result = stringtype;
if ( (stringtype == a1 || chartype == a1) && (stringtype == a2 || chartype == a2) )
return result;
LABEL_26:
if ( a1 == a2 && (inttype == a1 || realtype == a1) )
return a1;
v11 = *(_DWORD *)a1;
v12 = *(_DWORD *)a2;
if ( *(_DWORD *)a1 != 5001 )
{
if ( v12 != 5001 )
{
LABEL_29:
result = realtype;
if ( realtype == a1 )
goto LABEL_34;
v13 = inttype;
if ( inttype == a1 )
goto LABEL_34;
v11 = *(_DWORD *)a1;
goto LABEL_32;
}
v14 = inttype;
goto LABEL_62;
}
v14 = inttype;
v13 = inttype;
if ( v12 != 5001 )
{
if ( a2 == inttype )
{
result = *(_QWORD *)(a1 + 8);
if ( a2 == result )
return result;
}
goto LABEL_29;
}
result = *(_QWORD *)(a1 + 8);
if ( result == inttype && *(_QWORD *)(a2 + 8) == result )
return result;
if ( a2 == inttype )
{
if ( result == a2 )
return result;
LABEL_62:
v13 = v14;
}
if ( a1 == v14 )
{
result = realtype;
if ( *(_QWORD *)(a2 + 8) == a1 )
return a1;
goto LABEL_34;
}
result = realtype;
if ( a1 == realtype )
goto LABEL_34;
LABEL_32:
if ( v11 != 5001 || *(_QWORD *)(a1 + 8) != v13 )
goto LABEL_10;
LABEL_34:
if ( a2 != result && inttype != a2 && (*(_DWORD *)a2 != 5001 || inttype != *(_QWORD *)(a2 + 8)) )
goto LABEL_10;
break;
case '/':
goto LABEL_29;
case '<':
case '=':
case '>':
goto LABEL_39;
default:
goto LABEL_10;
}
return result;
}
goto LABEL_10;
}
if ( a3 <= 503 )
{
if ( a3 > 501 )
goto LABEL_77;
if ( a3 <= 304 )
{
if ( a3 > 301 )
{
LABEL_39:
if ( (realtype == a1 || inttype == a1 || *(_DWORD *)a1 == 5001 && inttype == *(_QWORD *)(a1 + 8))
&& (realtype == a2 || inttype == a2 || *(_DWORD *)a2 == 5001 && inttype == *(_QWORD *)(a2 + 8))
|| a1 == a2 )
{
return booltype;
}
}
goto LABEL_10;
}
if ( a3 == 400 )
{
LABEL_77:
if ( a1 == a2 )
{
result = a1;
if ( booltype == a1 )
return result;
}
}
LABEL_10:
v4 = (char *)malloc(0x400uLL);
v5 = func4((int *)a2);
v6 = func4((int *)a1);
v7 = dcgettext(0LL, "'%s' and '%s'", 5);
sprintf(v4, v7, v6, v5);
v8 = sem_c;
LODWORD(v6) = sem_l;
v9 = dcgettext(0LL, "wrong types:", 5);
err_include(3LL, v9, v4, (unsigned int)v6, v8);
return 0LL;
}
if ( (unsigned int)(a3 - 506) > 1 || inttype != a1 && (*(_DWORD *)a1 != 5001 || inttype != *(_QWORD *)(a1 + 8)) )
goto LABEL_10;
if ( inttype == a2 )
return inttype;
if ( *(_DWORD *)a2 != 5001 )
goto LABEL_10;
result = *(_QWORD *)(a2 + 8);
if ( inttype != result )
goto LABEL_10;
return result;
}

original_code:
type_table_elem *mix_types(type_table_elem *tp1, type_table_elem *tp2, int code)
{
    if ((tp1 == 0) || (tp2 == 0))
        return 0;
    switch (code)
    {
        case L_PLUS:
            if (((tp1 == stringtype) || (tp1 == chartype)) &&
                ((tp2 == stringtype) || (tp2 == chartype)))
                return stringtype;
        case L_STAR:
        case L_MINUS:
            if ((tp1 == tp2) && ((tp1 == inttype)||(tp1 == realtype)))
                return tp1;
            else if ((tp1->utype == UT_LIMITED) && (tp2->utype == UT_LIMITED)
                    && (tp1->base == inttype) && (tp2->base == inttype))
                    return inttype;
            else if ((tp1->utype == UT_LIMITED) && (tp2 == inttype)
                    && (tp1->base == inttype))
                    return inttype;
            else if ((tp2->utype == UT_LIMITED) && (tp1 == inttype)
                    && (tp2->base == inttype))
                    return inttype;
        case L_SLASH:
            if (((tp1 == realtype) || (tp1 == inttype) || ((tp1->utype == UT_LIMITED) && (tp1->base == inttype))) &&
                ((tp2 == realtype) || (tp2 == inttype) || ((tp2->utype == UT_LIMITED) && (tp2->base == inttype))))
                return realtype;
            break;
        case L_DIV:
        case L_MOD:
            if (((tp1 == inttype) || ((tp1->utype == UT_LIMITED) && (tp1->base == inttype))) &&
                ((tp2 == inttype) || ((tp2->utype == UT_LIMITED) && (tp2->base == inttype))))
                return inttype;
            break;
        case L_XOR:
        case L_OR:
        case L_AND:
            if ((tp1 == tp2) && (tp1 == booltype))
                return booltype;
            break;
        case L_GREAT:
        case L_LESS:
        case L_EQUAL:
        case L_NEQUAL:
        case L_GEQUAL:
        case L_LEQUAL:
            if ((((tp1 == realtype) || (tp1 == inttype) || ((tp1->utype == UT_LIMITED) && (tp1->base == inttype))) &&
                ((tp2 == realtype) || (tp2 == inttype) || ((tp2->utype == UT_LIMITED) && (tp2->base == inttype)))) || (tp1 == tp2))
                return booltype;
        default:
            break;
    }
    char *err = malloc(1024);
    sprintf(err, gettext("'%s' and '%s'"), get_type_name(tp1), get_type_name(tp2));
    err_include(ERROR, gettext("wrong types:"), err, sem_l, sem_c);
    return 0;
}

canonical_original_code:
struct _type_table_elem *mix_types(struct _type_table_elem *tp1, struct _type_table_elem *tp2, int code)
{
    if ((tp1 == 0) || (tp2 == 0))
        return 0;
    switch (code)
    {
        case L_PLUS:
            if (((tp1 == stringtype) || (tp1 == chartype)) &&
                ((tp2 == stringtype) || (tp2 == chartype)))
                return stringtype;
        case L_STAR:
        case L_MINUS:
            if ((tp1 == tp2) && ((tp1 == inttype)||(tp1 == realtype)))
                return tp1;
            else if ((tp1->utype == UT_LIMITED) && (tp2->utype == UT_LIMITED)
                    && (tp1->base == inttype) && (tp2->base == inttype))
                    return inttype;
            else if ((tp1->utype == UT_LIMITED) && (tp2 == inttype)
                    && (tp1->base == inttype))
                    return inttype;
            else if ((tp2->utype == UT_LIMITED) && (tp1 == inttype)
                    && (tp2->base == inttype))
                    return inttype;
        case L_SLASH:
            if (((tp1 == realtype) || (tp1 == inttype) || ((tp1->utype == UT_LIMITED) && (tp1->base == inttype))) &&
                ((tp2 == realtype) || (tp2 == inttype) || ((tp2->utype == UT_LIMITED) && (tp2->base == inttype))))
                return realtype;
            break;
        case L_DIV:
        case L_MOD:
            if (((tp1 == inttype) || ((tp1->utype == UT_LIMITED) && (tp1->base == inttype))) &&
                ((tp2 == inttype) || ((tp2->utype == UT_LIMITED) && (tp2->base == inttype))))
                return inttype;
            break;
        case L_XOR:
        case L_OR:
        case L_AND:
            if ((tp1 == tp2) && (tp1 == booltype))
                return booltype;
            break;
        case L_GREAT:
        case L_LESS:
        case L_EQUAL:
        case L_NEQUAL:
        case L_GEQUAL:
        case L_LEQUAL:
            if ((((tp1 == realtype) || (tp1 == inttype) || ((tp1->utype == UT_LIMITED) && (tp1->base == inttype))) &&
                ((tp2 == realtype) || (tp2 == inttype) || ((tp2->utype == UT_LIMITED) && (tp2->base == inttype)))) || (tp1 == tp2))
                return booltype;
        default:
            break;
    }
    char *err = malloc(1024);
    sprintf(err, gettext("'%s' and '%s'"), get_type_name(tp1), get_type_name(tp2));
    err_include(ERROR, gettext("wrong types:"), err, sem_l, sem_c);
    return 0;
}

variable_types:
err
char *


balloc

decompiled_code:
void *balloc()
{
return calloc(0x88uLL, 1uLL);
}

canonical_decompiled_code:
void *func0()
{
return calloc(0x88uLL, 1uLL);
}

return_type: unsigned long *


decompiled_code:
__int64 __fastcall bits_belong(__int64 a1, __int64 a2)
{
__int64 result; // rax

if ( a2 && a1 >= 0 )
result = (*(_QWORD *)(a2 + 8 * ((unsigned __int64)a1 >> 6)) >> a1) & 1LL;
else
result = 0LL;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func1(__int64 a1, __int64 a2)
{
__int64 result; // rax

if ( a2 && a1 >= 0 )
result = (*(_QWORD *)(a2 + 8 * ((unsigned __int64)a1 >> 6)) >> a1) & 1LL;
else
result = 0LL;
return result;
}

original_code:
int bits_belong(long element, unsigned long *set)
{
    if (set == 0)
        return 0;
    if (element < 0)
        return 0;
 if (set[(((unsigned long)element)>>6)]&(1UL<<((((unsigned long)element)&0x003F))))
        return 1;
 else
        return 0;
}

variable_types: element long

variable_types:
set
unsigned long *


decompiled_code:
__int64 __fastcall bits_from_array(unsigned __int64 *a1)
{
void *v2; // rax
unsigned __int64 v3; // rdi
__int64 v4; // r9
unsigned __int64 *v5; // rbx

v2 = balloc();
v3 = *a1;
v4 = (__int64)v2;
if ( *a1 != 1024 )
{
v5 = a1 + 1;
do
{
++v5;
bits_append(v3, v4);
v3 = *(v5 - 1);
}
while ( v3 != 1024 );
}
return v4;
}

original_code:
unsigned long *bits_from_array(unsigned long *a)
{
 int i;
 unsigned long *result = balloc();
 for(i = 0; a[i] != L_INVALID; i++)
 {
  bits_append(a[i], result);
 }
 return result;
}

variable_types:
a
unsigned long *

variable_types:
result
unsigned long *


decompiled_code:
int __fastcall set_print(__int64 a1)
{
__int64 v1; // rbx
__int64 v2; // rsi

v1 = 0LL;
printf("[ ");
do
{
while ( !(unsigned int)bits_belong(v1, a1) )
{
if ( ++v1 == 17 )
return puts(" ]");
}
v2 = (unsigned int)v1++;
printf("%d,", v2);
}
while ( v1 != 17 );
return puts(" ]");
}

canonical_decompiled_code:
int __fastcall func7(__int64 a1)
{
__int64 v1; // rbx
__int64 v2; // rsi

v1 = 0LL;
printf("[ ");
do
{
while ( !(unsigned int)func1(v1, a1) )
{
if ( ++v1 == 17 )
return puts(" ]");
}
v2 = (unsigned int)v1++;
printf("%d,", v2);
}
while ( v1 != 17 );
return puts(" ]");
}

original_code:
void set_print(unsigned long *res)
{
 int i;
 printf("[ ");
 for(i = 0; i < (((1024)>>6)+1); i++)
  if(bits_belong(i, res)) printf("%d,", i);
 printf(" ]\n");
}

variable_types:
res
unsigned long *


decompiled_code:
__int64 __fastcall bits_first(__int64 a1)
{
__int64 i; // r8

if ( !a1 )
return 1024LL;
for ( i = 0LL; i != 1024; ++i )
{
if ( (unsigned int)bits_belong(i, a1) )
break;
}
return i;
}

canonical_decompiled_code:
__int64 __fastcall func8(__int64 a1)
{
__int64 i; // r8

if ( !a1 )
return 1024LL;
for ( i = 0LL; i != 1024; ++i )
{
if ( (unsigned int)func1(i, a1) )
break;
}
return i;
}

original_code:
unsigned long bits_first(unsigned long *res)
{
    unsigned long i;
    if (res == 0)
        return L_INVALID;
    for (i = 0; i < L_INVALID; i++)
        if (bits_belong(i, res))
            return i;
    return L_INVALID;
}

variable_types:
i
unsigned long

return_type: unsigned long


decompiled_code:
__int64 parser_ff()
{
unsigned int v0; // eax
const char *v1; // r12
unsigned int v2; // eax
__int64 result; // rax

syn_line = lex_line;
syn_c = lex_c;
v0 = lex_get_s();
v1 = (const char *)sym_get_sym(v0);
v2 = lex_get_s();
io_printf("Fast forward: %d (%s)\n", v2, v1);
result = lex_next_s();
if ( syn_line != 1 || syn_c != 1 )
{
syn_line = lex_line;
result = lex_c;
syn_c = lex_c;
}
return result;
}

canonical_decompiled_code:
__int64 func0()
{
unsigned int v0; // eax
const char *v1; // r12
unsigned int v2; // eax
__int64 result; // rax

syn_line = lex_line;
syn_c = lex_c;
v0 = lex_get_s();
v1 = (const char *)sym_get_sym(v0);
v2 = lex_get_s();
io_printf("Fast forward: %d (%s)\n", v2, v1);
result = lex_next_s();
if ( syn_line != 1 || syn_c != 1 )
{
syn_line = lex_line;
result = lex_c;
syn_c = lex_c;
}
return result;
}

original_code:
static void parser_ff(void)
{
    syn_line = lex_line;
    syn_c = lex_c;
    io_printf("Fast forward: %d (%s)\n", lex_get_s(), sym_get_sym(lex_get_s()));
    lex_next_s();
    if (syn_line != 1 || syn_c != 1)
    {
        syn_line = lex_line;
        syn_c = lex_c;
    }
}

canonical_original_code:
static void parser_ff()
{
    syn_line = lex_line;
    syn_c = lex_c;
    io_printf("Fast forward: %d (%s)\n", lex_get_s(), sym_get_sym(lex_get_s()));
    lex_next_s();
    if (syn_line != 1 || syn_c != 1)
    {
        syn_line = lex_line;
        syn_c = lex_c;
    }
}


decompiled_code:
__int64 __fastcall skip1(__int64 a1)
{
int v1; // eax
__int64 result; // rax

while ( 1 )
{
result = lex_get_s();
if ( (_DWORD)result == -1 )
break;
v1 = lex_get_s();
result = bits_belong(v1, a1);
if ( (_DWORD)result )
break;
parser_ff();
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func1(__int64 a1)
{
int v1; // eax
__int64 result; // rax

while ( 1 )
{
result = lex_get_s();
if ( (_DWORD)result == -1 )
break;
v1 = lex_get_s();
result = bits_belong(v1, a1);
if ( (_DWORD)result )
break;
func0();
}
return result;
}

original_code:
void skip1(unsigned long *folls)
{
    while ((lex_get_s() != (-1)) && (!bits_belong(lex_get_s(), folls)))
        parser_ff();
}

variable_types:
folls
unsigned long *


decompiled_code:
__int64 __fastcall skip2(__int64 a1, __int64 a2)
{
__int64 v3; // rdi
__int64 result; // rax
__int64 v5; // rdi

while ( 1 )
{
result = lex_get_s();
if ( (_DWORD)result == -1 )
break;
v3 = (int)lex_get_s();
result = bits_belong(v3, a1);
if ( (_DWORD)result )
break;
v5 = (int)lex_get_s();
result = bits_belong(v5, a2);
if ( (_DWORD)result )
break;
parser_ff();
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func2(__int64 a1, __int64 a2)
{
__int64 v3; // rdi
__int64 result; // rax
__int64 v5; // rdi

while ( 1 )
{
result = lex_get_s();
if ( (_DWORD)result == -1 )
break;
v3 = (int)lex_get_s();
result = bits_belong(v3, a1);
if ( (_DWORD)result )
break;
v5 = (int)lex_get_s();
result = bits_belong(v5, a2);
if ( (_DWORD)result )
break;
func0();
}
return result;
}

original_code:
void skip2(unsigned long *start, unsigned long *folls)
{
    while ((lex_get_s() != (-1)) && (!bits_belong(lex_get_s(), start)) && (!bits_belong(lex_get_s(), folls)))
        parser_ff();
}

variable_types:
start
unsigned long *


decompiled_code:
__int64 init_parser()
{
init_parser_program();
init_parser_typedecl();
init_parser_typedefn();
init_parser_vardecl();
init_parser_varpack();
init_parser_varuse();
init_parser_expr();
init_parser_block();
init_parser_constant();
return init_parser_g_operator();
}

canonical_decompiled_code:
__int64 func3()
{
init_parser_program();
init_parser_typedecl();
init_parser_typedefn();
init_parser_vardecl();
init_parser_varpack();
init_parser_varuse();
init_parser_expr();
init_parser_block();
init_parser_constant();
return init_parser_g_operator();
}

original_code:
void init_parser(void)
{
    init_parser_program();
    init_parser_typedecl();
    init_parser_typedefn();
    init_parser_vardecl();
    init_parser_varpack();
    init_parser_varuse();
    init_parser_expr();
    init_parser_block();
    init_parser_constant();
    init_parser_g_operator();
}

canonical_original_code:
void init_parser()
{
    init_parser_program();
    init_parser_typedecl();
    init_parser_typedefn();
    init_parser_vardecl();
    init_parser_varpack();
    init_parser_varuse();
    init_parser_expr();
    init_parser_block();
    init_parser_constant();
    init_parser_g_operator();
}


decompiled_code:
__int64 fini_parser()
{
fini_parser_program();
fini_parser_typedecl();
fini_parser_typedefn();
fini_parser_vardecl();
fini_parser_varpack();
fini_parser_varuse();
fini_parser_expr();
fini_parser_block();
fini_parser_constant();
return fini_parser_g_operator();
}

canonical_decompiled_code:
__int64 func4()
{
fini_parser_program();
fini_parser_typedecl();
fini_parser_typedefn();
fini_parser_vardecl();
fini_parser_varpack();
fini_parser_varuse();
fini_parser_expr();
fini_parser_block();
fini_parser_constant();
return fini_parser_g_operator();
}

original_code:
void fini_parser(void)
{
    fini_parser_program();
    fini_parser_typedecl();
    fini_parser_typedefn();
    fini_parser_vardecl();
    fini_parser_varpack();
    fini_parser_varuse();
    fini_parser_expr();
    fini_parser_block();
    fini_parser_constant();
    fini_parser_g_operator();
}

canonical_original_code:
void fini_parser()
{
    fini_parser_program();
    fini_parser_typedecl();
    fini_parser_typedefn();
    fini_parser_vardecl();
    fini_parser_varpack();
    fini_parser_varuse();
    fini_parser_expr();
    fini_parser_block();
    fini_parser_constant();
    fini_parser_g_operator();
}


decompiled_code:
__int64 __fastcall parser_unexpected(__int64 a1)
{
unsigned int v1; // er13
unsigned int v2; // ebx
char *v3; // rax

v1 = syn_line;
v2 = syn_c;
v3 = dcgettext(0LL, syn_err, 5);
return err_include(3LL, v3, a1, v1, v2);
}

canonical_decompiled_code:
__int64 __fastcall func5(__int64 a1)
{
unsigned int v1; // er13
unsigned int v2; // ebx
char *v3; // rax

v1 = syn_line;
v2 = syn_c;
v3 = dcgettext(0LL, syn_err, 5);
return err_include(3LL, v3, a1, v1, v2);
}

original_code:
void parser_unexpected(const char *extmsg)
{
    err_include(ERROR, gettext(syn_err), extmsg, syn_line, syn_c);
}

canonical_original_code:
void parser_unexpected(char *extmsg)
{
    err_include(ERROR, gettext(syn_err), extmsg, syn_line, syn_c);
}

variable_types:
extmsg
char *


decompiled_code:
__int64 __fastcall parser_exec(__int64 a1, __int64 a2, __int64 a3, __int64 (__fastcall *a4)(__int64, __int64), __int64 a5)
{
__int64 v5; // rbp
__int64 v11; // rdi
int v12; // eax
__int64 v13; // r13
int v14; // eax
char *v16; // r15
unsigned int v17; // eax
char *v18; // rax
char *v19; // rbp
unsigned int v20; // eax
__int64 v21; // rdi
__int64 v22; // r15
unsigned int v23; // eax
__int64 v24; // r14
char *v25; // rax
__int64 v26; // rdi
unsigned int v27; // eax
__int64 v28; // r13
char *v29; // rax
unsigned int v30; // er13
unsigned int v31; // ebx
char *v32; // r12
char *v33; // rax
__int64 v34; // rcx
__int64 v35; // [rsp+8h] [rbp-40h]
__int64 v36; // [rsp+8h] [rbp-40h]

if ( a1 )
{
v5 = a1;
v11 = (int)lex_get_s();
if ( !(unsigned int)bits_belong(v11, a1) )
{
v16 = (char *)malloc(0x400uLL);
if ( a5 )
{
v17 = lex_get_s();
v35 = sym_get_sym(v17);
v18 = dcgettext(0LL, ": got '%s' but %s expected", 5);
sprintf(v16, v18, v35, a5);
}
else
{
v26 = bits_first(v5);
v36 = sym_get_sym(v26);
v27 = lex_get_s();
v28 = sym_get_sym(v27);
v29 = dcgettext(0LL, ": got '%s' but should be '%s' or so", 5);
sprintf(v16, v29, v28, v36);
}
parser_unexpected((__int64)v16);
skip2(v5, a2);
}
v12 = lex_get_s();
v13 = 0LL;
if ( (unsigned int)bits_belong(v12, v5) )
{
v13 = a4(a2, a3);
if ( a2 )
{
v14 = lex_get_s();
if ( !(unsigned int)bits_belong(v14, a2) )
{
v19 = (char *)malloc(0x400uLL);
v20 = bits_first(a3);
v21 = v20;
if ( v20 == 1024 )
v21 = (unsigned int)bits_first(a2);
v22 = sym_get_sym(v21);
v23 = lex_get_s();
v24 = sym_get_sym(v23);
v25 = dcgettext(0LL, ": got '%s' but should be '%s' or so", 5);
sprintf(v19, v25, v24, v22);
parser_unexpected((__int64)v19);
skip1(a2);
}
}
}
}
else
{
v30 = syn_line;
v31 = syn_c;
v32 = dcgettext(0LL, "Empty list of starting tokens", 5);
v33 = dcgettext(0LL, parser_int_error, 5);
v34 = v30;
v13 = 0LL;
err_include(4LL, v33, v32, v34, v31);
}
return v13;
}

canonical_decompiled_code:
__int64 __fastcall func6(__int64 a1, __int64 a2, __int64 a3, __int64 (__fastcall *a4)(__int64, __int64), __int64 a5)
{
__int64 v5; // rbp
__int64 v11; // rdi
int v12; // eax
__int64 v13; // r13
int v14; // eax
char *v16; // r15
unsigned int v17; // eax
char *v18; // rax
char *v19; // rbp
unsigned int v20; // eax
__int64 v21; // rdi
__int64 v22; // r15
unsigned int v23; // eax
__int64 v24; // r14
char *v25; // rax
__int64 v26; // rdi
unsigned int v27; // eax
__int64 v28; // r13
char *v29; // rax
unsigned int v30; // er13
unsigned int v31; // ebx
char *v32; // r12
char *v33; // rax
__int64 v34; // rcx
__int64 v35; // [rsp+8h] [rbp-40h]
__int64 v36; // [rsp+8h] [rbp-40h]

if ( a1 )
{
v5 = a1;
v11 = (int)lex_get_s();
if ( !(unsigned int)bits_belong(v11, a1) )
{
v16 = (char *)malloc(0x400uLL);
if ( a5 )
{
v17 = lex_get_s();
v35 = sym_get_sym(v17);
v18 = dcgettext(0LL, ": got '%s' but %s expected", 5);
sprintf(v16, v18, v35, a5);
}
else
{
v26 = bits_first(v5);
v36 = sym_get_sym(v26);
v27 = lex_get_s();
v28 = sym_get_sym(v27);
v29 = dcgettext(0LL, ": got '%s' but should be '%s' or so", 5);
sprintf(v16, v29, v28, v36);
}
func5((__int64)v16);
func2(v5, a2);
}
v12 = lex_get_s();
v13 = 0LL;
if ( (unsigned int)bits_belong(v12, v5) )
{
v13 = a4(a2, a3);
if ( a2 )
{
v14 = lex_get_s();
if ( !(unsigned int)bits_belong(v14, a2) )
{
v19 = (char *)malloc(0x400uLL);
v20 = bits_first(a3);
v21 = v20;
if ( v20 == 1024 )
v21 = (unsigned int)bits_first(a2);
v22 = sym_get_sym(v21);
v23 = lex_get_s();
v24 = sym_get_sym(v23);
v25 = dcgettext(0LL, ": got '%s' but should be '%s' or so", 5);
sprintf(v19, v25, v24, v22);
func5((__int64)v19);
func1(a2);
}
}
}
}
else
{
v30 = syn_line;
v31 = syn_c;
v32 = dcgettext(0LL, "Empty list of starting tokens", 5);
v33 = dcgettext(0LL, parser_int_error, 5);
v34 = v30;
v13 = 0LL;
err_include(4LL, v33, v32, v34, v31);
}
return v13;
}

original_code:
void *parser_exec(unsigned long *start, unsigned long *folls, unsigned long *ex, parser_func pf, const char *name)
{
    char *tmp;
    int t;
    void *ret = 0;
    if (start == 0)
    {
        err_include(EFATAL, gettext(parser_int_error), gettext("Empty list of starting tokens"), syn_line, syn_c);
        return 0;
    } else if(!bits_belong(lex_get_s(), start)) {
        tmp = malloc(1024);
        if (name != ((void *)0))
        {
            sprintf(tmp, gettext(": got '%s' but %s expected"), sym_get_sym(lex_get_s()), name);
        } else {
            t = bits_first(start);
            sprintf(tmp, gettext(": got '%s' but should be '%s' or so"), sym_get_sym(lex_get_s()), sym_get_sym(t));
        }
        parser_unexpected(tmp);
        skip2(start, folls);
    }
    if(bits_belong(lex_get_s(), start))
    {
        ret = pf(folls, ex);
        if((folls != 0) && !bits_belong(lex_get_s(), folls))
        {
            tmp = malloc(1024);
            t = bits_first(ex);
            if (t == L_INVALID)
                t = bits_first(folls);
            sprintf(tmp, gettext(": got '%s' but should be '%s' or so"), sym_get_sym(lex_get_s()), sym_get_sym(t));
            parser_unexpected(tmp);
            skip1(folls);
        }
    }
    return ret;
}

canonical_original_code:
void *parser_exec(unsigned long *start, unsigned long *folls, unsigned long *ex, void *(*pf)(unsigned long *, unsigned long *), char *name)
{
    char *tmp;
    int t;
    void *ret = 0;
    if (start == 0)
    {
        err_include(EFATAL, gettext(parser_int_error), gettext("Empty list of starting tokens"), syn_line, syn_c);
        return 0;
    } else if(!bits_belong(lex_get_s(), start)) {
        tmp = malloc(1024);
        if (name != ((void *)0))
        {
            sprintf(tmp, gettext(": got '%s' but %s expected"), sym_get_sym(lex_get_s()), name);
        } else {
            t = bits_first(start);
            sprintf(tmp, gettext(": got '%s' but should be '%s' or so"), sym_get_sym(lex_get_s()), sym_get_sym(t));
        }
        parser_unexpected(tmp);
        skip2(start, folls);
    }
    if(bits_belong(lex_get_s(), start))
    {
        ret = pf(folls, ex);
        if((folls != 0) && !bits_belong(lex_get_s(), folls))
        {
            tmp = malloc(1024);
            t = bits_first(ex);
            if (t == L_INVALID)
                t = bits_first(folls);
            sprintf(tmp, gettext(": got '%s' but should be '%s' or so"), sym_get_sym(lex_get_s()), sym_get_sym(t));
            parser_unexpected(tmp);
            skip1(folls);
        }
    }
    return ret;
}

variable_types:
ex
unsigned long *

variable_types: void *(*)(unsigned long *, unsigned long *)

variable_types:
name
char *

variable_types: t int

variable_types:
ret
void *

return_type: void *


accept

decompiled_code:
__int64 __fastcall accept(unsigned int a1)
{
const char *v1; // r13
__int64 v3; // rdi
const char *v4; // rbx
unsigned int v5; // er12
const char *v6; // rax
char *v7; // r12
__int64 v8; // r14
unsigned int v9; // eax
__int64 v10; // r13
char *v11; // rax

v1 = "MATCH";
if ( (unsigned int)lex_get_s() != a1 )
v1 = "MISS";
v3 = (unsigned int)lex_get_s();
v4 = (const char *)sym_get_sym(v3);
v5 = lex_get_s();
v6 = (const char *)sym_get_sym(a1);
io_printf("Req %d (%s), got %d (%s) - %s\n", a1, v6, v5, v4, v1);
if ( (unsigned int)lex_get_s() == a1 )
return parser_ff();
v7 = (char *)malloc(0x400uLL);
v8 = sym_get_sym(a1);
v9 = lex_get_s();
v10 = sym_get_sym(v9);
v11 = dcgettext(0LL, ": got '%s' but expected '%s'", 5);
sprintf(v7, v11, v10, v8);
return parser_unexpected((__int64)v7);
}

canonical_decompiled_code:
__int64 __fastcall func7(unsigned int a1)
{
const char *v1; // r13
__int64 v3; // rdi
const char *v4; // rbx
unsigned int v5; // er12
const char *v6; // rax
char *v7; // r12
__int64 v8; // r14
unsigned int v9; // eax
__int64 v10; // r13
char *v11; // rax

v1 = "MATCH";
if ( (unsigned int)lex_get_s() != a1 )
v1 = "MISS";
v3 = (unsigned int)lex_get_s();
v4 = (const char *)sym_get_sym(v3);
v5 = lex_get_s();
v6 = (const char *)sym_get_sym(a1);
io_printf("Req %d (%s), got %d (%s) - %s\n", a1, v6, v5, v4, v1);
if ( (unsigned int)lex_get_s() == a1 )
return func0();
v7 = (char *)malloc(0x400uLL);
v8 = sym_get_sym(a1);
v9 = lex_get_s();
v10 = sym_get_sym(v9);
v11 = dcgettext(0LL, ": got '%s' but expected '%s'", 5);
sprintf(v7, v11, v10, v8);
return func5((__int64)v7);
}

original_code:
void accept(TOKEN_TYPE t)
{
    io_printf("Req %d (%s), got %d (%s) - %s\n",
        t, sym_get_sym(t),
        lex_get_s(), sym_get_sym(lex_get_s()),
        (t == lex_get_s())?"MATCH":"MISS" );
    if(lex_get_s() == t)
    {
        parser_ff();
    } else {
        char *tmp = malloc(1024);
        sprintf(tmp, gettext(": got '%s' but expected '%s'"), sym_get_sym(lex_get_s()), sym_get_sym(t));
        parser_unexpected(tmp);
    }
}

canonical_original_code:
void accept(enum TOKEN_TYPE t)
{
    io_printf("Req %d (%s), got %d (%s) - %s\n",
        t, sym_get_sym(t),
        lex_get_s(), sym_get_sym(lex_get_s()),
        (t == lex_get_s())?"MATCH":"MISS" );
    if(lex_get_s() == t)
    {
        parser_ff();
    } else {
        char *tmp = malloc(1024);
        sprintf(tmp, gettext(": got '%s' but expected '%s'"), sym_get_sym(lex_get_s()), sym_get_sym(t));
        parser_unexpected(tmp);
    }
}

variable_types: enum TOKEN_TYPE { L_EOF=-1, L_PLUS=expr, L_MINUS=expr, L_STAR=expr, L_SLASH=expr, L_POINT=expr, L_COMMA=expr, L_SEMICOLON=expr, L_COLON=expr, L_ARROW=expr, L_LBRACKET=expr, L_RBRACKET=expr, L_LBRACE=expr, L_RBRACE=expr, L_LPANTH=expr, L_RPANTH=expr, L_EQUAL=expr, L_QUOTE=expr, L_LESS=expr, L_GREAT=expr, L_NEWLINE=expr, L_LCOMMENT=300, L_RCOMMENT=301, L_LEQUAL=302, L_GEQUAL=303, L_NEQUAL=304, L_ASSIGN=305, L_TWOPOINTS=306, L_OR=400, L_TO=401, L_OF=402, L_IN=403, L_DO=404, L_IF=405, L_END=500, L_VAR=501, L_AND=502, L_XOR=503, L_NOT=504, L_FOR=505, L_DIV=506, L_MOD=507, L_NIL=508, L_SSET=509, L_TYPE=600, L_GOTO=601, L_WITH=602, L_CASE=603, L_TRUE=604, L_THEN=605, L_ELSE=606, L_REAL=607, L_WORD=608, L_BYTE=609, L_FILE=610, L_TEXT=611, L_BEGIN=700, L_WHILE=701, L_BREAK=702, L_UNTIL=703, L_ARRAY=704, L_CONST=705, L_FALSE=706, L_SHORT=707, L_LABEL=708, L_REPEAT=800, L_DOWNTO=801, L_RECORD=802, L_STRING=803, L_INTEGER=900, L_PROGRAM=901, L_FUNCTION=902, L_PROCEDURE=903, L_IDENT=1000, L_NUMERIC=1001, L_FLOAT=1002, L_SCONST=1003, L_CHARCONST=1004, L_LINECOMMENT=1005, L_INVALID=1024 }


decompiled_code:
__int64 __fastcall int_parse_typedecl(__int64 a1)
{
__int64 v1; // rax
struct sockaddr *v2; // rsi
void *v3; // rbp
socklen_t *v4; // rdx
socklen_t *v5; // rdx
socklen_t *v6; // rdx
socklen_t *v7; // rdx
const char *v8; // rax
char *v9; // rsi
__int64 v10; // rbx
socklen_t *v11; // rdx
socklen_t *v12; // rdx
__int64 v13; // rax

v1 = balloc();
v2 = (struct sockaddr *)parser_typedecl_aux;
v3 = (void *)v1;
bits_disjunct(a1, parser_typedecl_aux, v1);
accept(600, v2, v4);
do
{
if ( (unsigned int)lex_get_s() == 1000 )
{
v8 = (const char *)lex_get_v();
v9 = strdup(v8);
v10 = add_to_id_table(0LL, v9, 4001LL);
accept(1000, (struct sockaddr *)v9, v11);
accept(61, (struct sockaddr *)v9, v12);
v2 = 0LL;
v13 = parse_typedefn(v3, 0LL);
if ( v10 )
*(_QWORD *)(v10 + 24) = v13;
}
else
{
accept(1000, v2, v7);
accept(61, v2, v5);
v2 = 0LL;
parse_typedefn(v3, 0LL);
}
accept(59, 0LL, v6);
}
while ( (unsigned int)lex_get_s() == 1000 );
free(v3);
return 0LL;
}

canonical_decompiled_code:
__int64 __fastcall func0(__int64 a1)
{
__int64 v1; // rax
struct sockaddr *v2; // rsi
void *v3; // rbp
socklen_t *v4; // rdx
socklen_t *v5; // rdx
socklen_t *v6; // rdx
socklen_t *v7; // rdx
const char *v8; // rax
char *v9; // rsi
__int64 v10; // rbx
socklen_t *v11; // rdx
socklen_t *v12; // rdx
__int64 v13; // rax

v1 = balloc();
v2 = (struct sockaddr *)parser_typedecl_aux;
v3 = (void *)v1;
bits_disjunct(a1, parser_typedecl_aux, v1);
accept(600, v2, v4);
do
{
if ( (unsigned int)lex_get_s() == 1000 )
{
v8 = (const char *)lex_get_v();
v9 = strdup(v8);
v10 = add_to_id_table(0LL, v9, 4001LL);
accept(1000, (struct sockaddr *)v9, v11);
accept(61, (struct sockaddr *)v9, v12);
v2 = 0LL;
v13 = parse_typedefn(v3, 0LL);
if ( v10 )
*(_QWORD *)(v10 + 24) = v13;
}
else
{
accept(1000, v2, v7);
accept(61, v2, v5);
v2 = 0LL;
parse_typedefn(v3, 0LL);
}
accept(59, 0LL, v6);
}
while ( (unsigned int)lex_get_s() == 1000 );
free(v3);
return 0LL;
}

original_code:
void *int_parse_typedecl (unsigned long *folls, unsigned long *ex)
{
    type_table_elem *ret = 0;
    id_table_elem *id = 0;
    lex_val lv;
    char *name;
    unsigned long *tmp = balloc();
    bits_disjunct(folls, parser_typedecl_aux, tmp);
    accept(L_TYPE);
    do
    {
        id = 0;
        ret = 0;
        if (lex_get_s() == L_IDENT)
        {
            lv = lex_get_v();
            name = strdup(lv.string);
            id = add_to_id_table(0, name, UC_TYPE);
        }
        accept(L_IDENT);
        accept(L_EQUAL);
        ret = parse_typedefn(tmp, 0);
        if (id != 0)
            id->type = ret;
        accept(L_SEMICOLON);
    } while (lex_get_s() == L_IDENT);
    free(tmp);
}

canonical_original_code:
void *int_parse_typedecl(unsigned long *folls, unsigned long *ex)
{
    struct _type_table_elem *ret = 0;
    struct _id_table_elem *id = 0;
    union lex_val lv;
    char *name;
    unsigned long *tmp = balloc();
    bits_disjunct(folls, parser_typedecl_aux, tmp);
    accept(L_TYPE);
    do
    {
        id = 0;
        ret = 0;
        if (lex_get_s() == L_IDENT)
        {
            lv = lex_get_v();
            name = strdup(lv.string);
            id = add_to_id_table(0, name, UC_TYPE);
        }
        accept(L_IDENT);
        accept(L_EQUAL);
        ret = parse_typedefn(tmp, 0);
        if (id != 0)
            id->type = ret;
        accept(L_SEMICOLON);
    } while (lex_get_s() == L_IDENT);
    free(tmp);
}

variable_types: struct _id_table_elem { unsigned long hash; char *name; enum USE_CLASS { UC_PROG=4000, UC_TYPE=4001, UC_CONST=4002, UC_VAR=4003, UC_PROC=4004, UC_FUNC=4005, UC_UNK=4006 } uclass; struct _type_table_elem { enum USE_TYPE { UT_SCALAR=5000, UT_LIMITED=5001, UT_ENUM=5002, UT_ARRAY=5003, UT_RECORD=5004, UT_REFERENCE=5005, UT_SET=5006, UT_FILE=5007 } utype; struct _type_table_elem *base; union { struct _list { void *value; struct _list *next; } *constants; struct _list *indexes; struct { unsigned long min; }; }; } *type; int value; } *

variable_types: union lex_val { long inumber; double fnumber; char *string; char character; }

variable_types:
tmp
unsigned long *


decompiled_code:
__int64 __fastcall parse_typedecl(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_typedecl, a1, a2, int_parse_typedecl, "typedecl");
}

canonical_decompiled_code:
__int64 __fastcall func1(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_typedecl, a1, a2, int_parse_typedecl, "typedecl");
}

original_code: void *parse_typedecl (unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_typedecl, folls, ex, int_parse_typedecl, parser_name_typedecl); }

canonical_original_code: void *parse_typedecl(unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_typedecl, folls, ex, int_parse_typedecl, parser_name_typedecl); }


decompiled_code:
void init_parser_typedecl()
{
if ( parser_start_typedecl )
{
if ( parser_folls_typedecl )
goto LABEL_3;
}
else
{
parser_start_typedecl = (void *)bits_from_array(&int_start_typedecl);
if ( parser_folls_typedecl )
{
LABEL_3:
if ( parser_typedecl_aux )
return;
LABEL_7:
parser_typedecl_aux = (void *)bits_from_array(&int_typedecl_aux);
return;
}
}
parser_folls_typedecl = (void *)bits_from_array(&int_folls_typedecl);
if ( !parser_typedecl_aux )
goto LABEL_7;
}

canonical_decompiled_code:
void func2()
{
if ( parser_start_typedecl )
{
if ( parser_folls_typedecl )
goto LABEL_3;
}
else
{
parser_start_typedecl = (void *)bits_from_array(&int_start_typedecl);
if ( parser_folls_typedecl )
{
LABEL_3:
if ( parser_typedecl_aux )
return;
LABEL_7:
parser_typedecl_aux = (void *)bits_from_array(&int_typedecl_aux);
return;
}
}
parser_folls_typedecl = (void *)bits_from_array(&int_folls_typedecl);
if ( !parser_typedecl_aux )
goto LABEL_7;
}

original_code:
void init_parser_typedecl(void)
{
    { { if (parser_start_typedecl == 0) parser_start_typedecl = bits_from_array(int_start_typedecl); }; { if (parser_folls_typedecl == 0) parser_folls_typedecl = bits_from_array(int_folls_typedecl); }; };
    { if (parser_typedecl_aux == 0) parser_typedecl_aux = bits_from_array(int_typedecl_aux); };
}

canonical_original_code:
void init_parser_typedecl()
{
    { { if (parser_start_typedecl == 0) parser_start_typedecl = bits_from_array(int_start_typedecl); }; { if (parser_folls_typedecl == 0) parser_folls_typedecl = bits_from_array(int_folls_typedecl); }; };
    { if (parser_typedecl_aux == 0) parser_typedecl_aux = bits_from_array(int_typedecl_aux); };
}


decompiled_code:
void fini_parser_typedecl()
{
if ( parser_start_typedecl )
free(parser_start_typedecl);
if ( parser_folls_typedecl )
free(parser_folls_typedecl);
if ( parser_typedecl_aux )
free(parser_typedecl_aux);
}

canonical_decompiled_code:
void func3()
{
if ( parser_start_typedecl )
free(parser_start_typedecl);
if ( parser_folls_typedecl )
free(parser_folls_typedecl);
if ( parser_typedecl_aux )
free(parser_typedecl_aux);
}

original_code:
void fini_parser_typedecl(void)
{
    { { if (parser_start_typedecl != 0) free(parser_start_typedecl); }; { if (parser_folls_typedecl != 0) free(parser_folls_typedecl); }; };
    { if (parser_typedecl_aux != 0) free(parser_typedecl_aux); };
}

canonical_original_code:
void fini_parser_typedecl()
{
    { { if (parser_start_typedecl != 0) free(parser_start_typedecl); }; { if (parser_folls_typedecl != 0) free(parser_folls_typedecl); }; };
    { if (parser_typedecl_aux != 0) free(parser_typedecl_aux); };
}


decompiled_code:
__int64 __fastcall int_parse_constant(__int64 a1, char *a2)
{
int v2; // eax
socklen_t *v3; // rdx
int v4; // eax
__int64 v5; // r12
int v6; // eax
socklen_t *v7; // rdx
int v9; // eax
unsigned int v10; // er14
unsigned int v11; // ebx
const char *v12; // rax
char *v13; // r13
__int64 v14; // rax
const char *v15; // rax
__int64 v16; // rax
int v17; // eax
socklen_t *v18; // rdx
__int64 v19[6]; // [rsp+8h] [rbp-30h] BYREF

if ( (unsigned int)lex_get_s() != 43 && (unsigned int)lex_get_s() != 45 )
{
if ( (unsigned int)lex_get_s() != 1001
&& (unsigned int)lex_get_s() != 1002
&& (unsigned int)lex_get_s() != 1000
&& (unsigned int)lex_get_s() != 1003
&& (unsigned int)lex_get_s() != 1004 )
{
goto LABEL_29;
}
v9 = lex_get_s();
v5 = inttype;
if ( v9 == 1003 )
{
if ( (unsigned int)lex_get_s() == 1001 )
{
LABEL_13:
v5 = inttype;
goto LABEL_7;
}
}
else
{
v5 = 0LL;
if ( (unsigned int)lex_get_s() == 1004 )
v5 = realtype;
if ( (unsigned int)lex_get_s() == 1001 )
goto LABEL_13;
}
if ( (unsigned int)lex_get_s() == 1002 )
goto LABEL_15;
if ( (unsigned int)lex_get_s() != 1000 )
goto LABEL_7;
v10 = syn_line;
v11 = syn_c;
v12 = (const char *)lex_get_v();
v19[0] = 4002LL;
a2 = strdup(v12);
v13 = a2;
v14 = search_id_table(0LL, a2, v19);
if ( v14 )
{
v5 = *(_QWORD *)(v14 + 24);
goto LABEL_7;
}
goto LABEL_30;
}
v2 = lex_get_s();
accept(v2, (struct sockaddr *)a2, v3);
if ( (unsigned int)lex_get_s() != 1001 && (unsigned int)lex_get_s() != 1002 && (unsigned int)lex_get_s() != 1000 )
{
LABEL_29:
v5 = 0LL;
parser_unexpected(0LL);
v17 = lex_get_s();
accept(v17, (struct sockaddr *)a2, v18);
return v5;
}
v4 = lex_get_s();
v5 = inttype;
if ( v4 != 1001 )
{
if ( (unsigned int)lex_get_s() == 1002 )
{
LABEL_15:
v5 = realtype;
goto LABEL_7;
}
v5 = 0LL;
if ( (unsigned int)lex_get_s() != 1000 )
goto LABEL_7;
v10 = syn_line;
v11 = syn_c;
v15 = (const char *)lex_get_v();
v19[0] = 4002LL;
a2 = strdup(v15);
v13 = a2;
v16 = search_id_table(0LL, a2, v19);
v5 = v16;
if ( v16 )
{
v5 = *(_QWORD *)(v16 + 24);
goto LABEL_7;
}
LABEL_30:
a2 = dcgettext(0LL, "wrong identifier:", 5);
err_include(3LL, a2, v13, v10, v11);
}
LABEL_7:
v6 = lex_get_s();
accept(v6, (struct sockaddr *)a2, v7);
return v5;
}

canonical_decompiled_code:
__int64 __fastcall func0(__int64 a1, char *a2)
{
int v2; // eax
socklen_t *v3; // rdx
int v4; // eax
__int64 v5; // r12
int v6; // eax
socklen_t *v7; // rdx
int v9; // eax
unsigned int v10; // er14
unsigned int v11; // ebx
const char *v12; // rax
char *v13; // r13
__int64 v14; // rax
const char *v15; // rax
__int64 v16; // rax
int v17; // eax
socklen_t *v18; // rdx
__int64 v19[6]; // [rsp+8h] [rbp-30h] BYREF

if ( (unsigned int)lex_get_s() != 43 && (unsigned int)lex_get_s() != 45 )
{
if ( (unsigned int)lex_get_s() != 1001
&& (unsigned int)lex_get_s() != 1002
&& (unsigned int)lex_get_s() != 1000
&& (unsigned int)lex_get_s() != 1003
&& (unsigned int)lex_get_s() != 1004 )
{
goto LABEL_29;
}
v9 = lex_get_s();
v5 = inttype;
if ( v9 == 1003 )
{
if ( (unsigned int)lex_get_s() == 1001 )
{
LABEL_13:
v5 = inttype;
goto LABEL_7;
}
}
else
{
v5 = 0LL;
if ( (unsigned int)lex_get_s() == 1004 )
v5 = realtype;
if ( (unsigned int)lex_get_s() == 1001 )
goto LABEL_13;
}
if ( (unsigned int)lex_get_s() == 1002 )
goto LABEL_15;
if ( (unsigned int)lex_get_s() != 1000 )
goto LABEL_7;
v10 = syn_line;
v11 = syn_c;
v12 = (const char *)lex_get_v();
v19[0] = 4002LL;
a2 = strdup(v12);
v13 = a2;
v14 = search_id_table(0LL, a2, v19);
if ( v14 )
{
v5 = *(_QWORD *)(v14 + 24);
goto LABEL_7;
}
goto LABEL_30;
}
v2 = lex_get_s();
accept(v2, (struct sockaddr *)a2, v3);
if ( (unsigned int)lex_get_s() != 1001 && (unsigned int)lex_get_s() != 1002 && (unsigned int)lex_get_s() != 1000 )
{
LABEL_29:
v5 = 0LL;
parser_unexpected(0LL);
v17 = lex_get_s();
accept(v17, (struct sockaddr *)a2, v18);
return v5;
}
v4 = lex_get_s();
v5 = inttype;
if ( v4 != 1001 )
{
if ( (unsigned int)lex_get_s() == 1002 )
{
LABEL_15:
v5 = realtype;
goto LABEL_7;
}
v5 = 0LL;
if ( (unsigned int)lex_get_s() != 1000 )
goto LABEL_7;
v10 = syn_line;
v11 = syn_c;
v15 = (const char *)lex_get_v();
v19[0] = 4002LL;
a2 = strdup(v15);
v13 = a2;
v16 = search_id_table(0LL, a2, v19);
v5 = v16;
if ( v16 )
{
v5 = *(_QWORD *)(v16 + 24);
goto LABEL_7;
}
LABEL_30:
a2 = dcgettext(0LL, "wrong identifier:", 5);
err_include(3LL, a2, v13, v10, v11);
}
LABEL_7:
v6 = lex_get_s();
accept(v6, (struct sockaddr *)a2, v7);
return v5;
}

original_code:
void *int_parse_constant (unsigned long *folls, unsigned long *ex)
{
    type_table_elem *ret = 0;
    if ((lex_get_s() == L_PLUS) || (lex_get_s() == L_MINUS))
    {
        accept(lex_get_s());
        if ((lex_get_s() == L_NUMERIC) || (lex_get_s() == L_FLOAT) || (lex_get_s() == L_IDENT))
        {
            if (lex_get_s() == L_NUMERIC)
                ret = inttype;
            else if (lex_get_s() == L_FLOAT)
                ret = realtype;
            else if (lex_get_s() == L_IDENT)
            {
                int sl = syn_line, sc = syn_c;
                lex_val lv = lex_get_v();
                char *name = strdup(lv.string);
                unsigned long *uclass = UC_CONST;
                id_table_elem *id = search_id_table(0, name, &uclass);
                if (id == 0)
                    err_include (ERROR, gettext("wrong identifier:"), name, sl, sc);
                else
                    ret = id->type;
            }
            accept(lex_get_s());
        } else {
            parser_unexpected(0);
            accept(lex_get_s());
        }
    } else {
        if ((lex_get_s() == L_NUMERIC) || (lex_get_s() == L_FLOAT)
            || (lex_get_s() == L_IDENT) || (lex_get_s() == L_SCONST) || (lex_get_s() == L_CHARCONST))
        {
            if (lex_get_s() == L_SCONST)
                ret = inttype;
            else if (lex_get_s() == L_CHARCONST)
                ret = realtype;
            if (lex_get_s() == L_NUMERIC)
                ret = inttype;
            else if (lex_get_s() == L_FLOAT)
                ret = realtype;
            else if (lex_get_s() == L_IDENT)
            {
                int sl = syn_line, sc = syn_c;
                lex_val lv = lex_get_v();
                char *name = strdup(lv.string);
                unsigned long *uclass = UC_CONST;
                id_table_elem *id = search_id_table(0, name, &uclass);
                if (id == 0)
                    err_include (ERROR, gettext("wrong identifier:"), name, sl, sc);
                else
                    ret = id->type;
            }
            accept(lex_get_s());
        } else {
            parser_unexpected(0);
            accept(lex_get_s());
        }
    }
    return ret;
}

canonical_original_code:
void *int_parse_constant(unsigned long *folls, unsigned long *ex)
{
    struct _type_table_elem *ret = 0;
    if ((lex_get_s() == L_PLUS) || (lex_get_s() == L_MINUS))
    {
        accept(lex_get_s());
        if ((lex_get_s() == L_NUMERIC) || (lex_get_s() == L_FLOAT) || (lex_get_s() == L_IDENT))
        {
            if (lex_get_s() == L_NUMERIC)
                ret = inttype;
            else if (lex_get_s() == L_FLOAT)
                ret = realtype;
            else if (lex_get_s() == L_IDENT)
            {
                int sl = syn_line; int sc = syn_c;
                union lex_val lv = lex_get_v();
                char *name = strdup(lv.string);
                unsigned long *uclass = UC_CONST;
                struct _id_table_elem *id = search_id_table(0, name, &uclass);
                if (id == 0)
                    err_include (ERROR, gettext("wrong identifier:"), name, sl, sc);
                else
                    ret = id->type;
            }
            accept(lex_get_s());
        } else {
            parser_unexpected(0);
            accept(lex_get_s());
        }
    } else {
        if ((lex_get_s() == L_NUMERIC) || (lex_get_s() == L_FLOAT)
            || (lex_get_s() == L_IDENT) || (lex_get_s() == L_SCONST) || (lex_get_s() == L_CHARCONST))
        {
            if (lex_get_s() == L_SCONST)
                ret = inttype;
            else if (lex_get_s() == L_CHARCONST)
                ret = realtype;
            if (lex_get_s() == L_NUMERIC)
                ret = inttype;
            else if (lex_get_s() == L_FLOAT)
                ret = realtype;
            else if (lex_get_s() == L_IDENT)
            {
                int sl = syn_line; int sc = syn_c;
                union lex_val lv = lex_get_v();
                char *name = strdup(lv.string);
                unsigned long *uclass = UC_CONST;
                struct _id_table_elem *id = search_id_table(0, name, &uclass);
                if (id == 0)
                    err_include (ERROR, gettext("wrong identifier:"), name, sl, sc);
                else
                    ret = id->type;
            }
            accept(lex_get_s());
        } else {
            parser_unexpected(0);
            accept(lex_get_s());
        }
    }
    return ret;
}

variable_types: struct _type_table_elem { enum USE_TYPE { UT_SCALAR=5000, UT_LIMITED=5001, UT_ENUM=5002, UT_ARRAY=5003, UT_RECORD=5004, UT_REFERENCE=5005, UT_SET=5006, UT_FILE=5007 } utype; struct _type_table_elem *base; union { struct _list { void *value; struct _list *next; } *constants; struct _list *indexes; struct { unsigned long min; }; }; } *

variable_types: sl int

variable_types: sc int

variable_types:
uclass
unsigned long *

user_defined_types: union lex_val { long inumber; double fnumber; char *string; char character; }

user_defined_types: enum USE_CLASS { UC_PROG=4000, UC_TYPE=4001, UC_CONST=4002, UC_VAR=4003, UC_PROC=4004, UC_FUNC=4005, UC_UNK=4006 }


decompiled_code:
__int64 __fastcall parse_constdefn(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_constdefn, a1, a2, int_parse_constdefn, "constdefn");
}

canonical_decompiled_code:
__int64 __fastcall func1(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_constdefn, a1, a2, int_parse_constdefn, "constdefn");
}

original_code: void *parse_constdefn (unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_constdefn, folls, ex, int_parse_constdefn, parser_name_constdefn); }

canonical_original_code: void *parse_constdefn(unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_constdefn, folls, ex, int_parse_constdefn, parser_name_constdefn); }


decompiled_code:
void __fastcall int_parse_constdecl(__int64 a1)
{
__int64 v1; // rax
struct sockaddr *v2; // rsi
void *v3; // rbp
socklen_t *v4; // rdx
socklen_t *v5; // rdx

v1 = balloc();
v2 = (struct sockaddr *)parser_constdecl_aux;
v3 = (void *)v1;
bits_disjunct(a1, parser_constdecl_aux, v1);
accept(705, v2, v4);
do
{
parse_constdefn((__int64)v3, 0LL);
accept(59, 0LL, v5);
}
while ( (unsigned int)lex_get_s() == 1000 );
free(v3);
}

canonical_decompiled_code:
void __fastcall func2(__int64 a1)
{
__int64 v1; // rax
struct sockaddr *v2; // rsi
void *v3; // rbp
socklen_t *v4; // rdx
socklen_t *v5; // rdx

v1 = balloc();
v2 = (struct sockaddr *)parser_constdecl_aux;
v3 = (void *)v1;
bits_disjunct(a1, parser_constdecl_aux, v1);
accept(705, v2, v4);
do
{
func1((__int64)v3, 0LL);
accept(59, 0LL, v5);
}
while ( (unsigned int)lex_get_s() == 1000 );
free(v3);
}

original_code:
void *int_parse_constdecl (unsigned long *folls, unsigned long *ex)
{
    unsigned long *tmp = balloc();
    bits_disjunct(folls, parser_constdecl_aux, tmp);
    accept(L_CONST);
    do
    {
        parse_constdefn(tmp, 0);
        accept(L_SEMICOLON);
    } while (lex_get_s() == L_IDENT);
    free(tmp);
}

canonical_original_code:
void *int_parse_constdecl(unsigned long *folls, unsigned long *ex)
{
    unsigned long *tmp = balloc();
    bits_disjunct(folls, parser_constdecl_aux, tmp);
    accept(L_CONST);
    do
    {
        parse_constdefn(tmp, 0);
        accept(L_SEMICOLON);
    } while (lex_get_s() == L_IDENT);
    free(tmp);
}


decompiled_code:
__int64 __fastcall parse_constdecl(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_constdecl, a1, a2, int_parse_constdecl, "constdecl");
}

canonical_decompiled_code:
__int64 __fastcall func3(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_constdecl, a1, a2, int_parse_constdecl, "constdecl");
}

original_code: void *parse_constdecl (unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_constdecl, folls, ex, int_parse_constdecl, parser_name_constdecl); }

canonical_original_code: void *parse_constdecl(unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_constdecl, folls, ex, int_parse_constdecl, parser_name_constdecl); }


decompiled_code:
__int64 __fastcall parse_constant(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_constant, a1, a2, int_parse_constant, "constant");
}

canonical_decompiled_code:
__int64 __fastcall func4(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_constant, a1, a2, int_parse_constant, "constant");
}

original_code: void *parse_constant (unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_constant, folls, ex, int_parse_constant, parser_name_constant); }

canonical_original_code: void *parse_constant(unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_constant, folls, ex, int_parse_constant, parser_name_constant); }


decompiled_code:
__int64 __fastcall int_parse_constdefn(__int64 a1, struct sockaddr *a2)
{
socklen_t *v2; // rdx
socklen_t *v3; // rdx
__int64 result; // rax
const char *v5; // rax
char *v6; // rsi
__int64 v7; // rbx
socklen_t *v8; // rdx
socklen_t *v9; // rdx
__int64 v10; // rax

if ( (unsigned int)lex_get_s() == 1000 )
{
v5 = (const char *)lex_get_v();
v6 = strdup(v5);
v7 = add_to_id_table(0LL, v6, 4002LL);
accept(1000, (struct sockaddr *)v6, v8);
accept(61, (struct sockaddr *)v6, v9);
v10 = parse_constant(a1, 0LL);
if ( v7 )
*(_QWORD *)(v7 + 24) = v10;
result = 0LL;
}
else
{
accept(1000, a2, v2);
accept(61, a2, v3);
result = parse_constant(a1, 0LL);
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func5(__int64 a1, struct sockaddr *a2)
{
socklen_t *v2; // rdx
socklen_t *v3; // rdx
__int64 result; // rax
const char *v5; // rax
char *v6; // rsi
__int64 v7; // rbx
socklen_t *v8; // rdx
socklen_t *v9; // rdx
__int64 v10; // rax

if ( (unsigned int)lex_get_s() == 1000 )
{
v5 = (const char *)lex_get_v();
v6 = strdup(v5);
v7 = add_to_id_table(0LL, v6, 4002LL);
accept(1000, (struct sockaddr *)v6, v8);
accept(61, (struct sockaddr *)v6, v9);
v10 = func4(a1, 0LL);
if ( v7 )
*(_QWORD *)(v7 + 24) = v10;
result = 0LL;
}
else
{
accept(1000, a2, v2);
accept(61, a2, v3);
result = func4(a1, 0LL);
}
return result;
}

original_code:
void *int_parse_constdefn (unsigned long *folls, unsigned long *ex)
{
    id_table_elem *id = 0;
    type_table_elem *tp = 0;
    if (lex_get_s() == L_IDENT)
    {
        lex_val lv = lex_get_v();
        char *name = strdup(lv.string);
        id = add_to_id_table(0, name, UC_CONST);
    }
    accept(L_IDENT);
    accept(L_EQUAL);
    tp = parse_constant(folls, 0);
    if (id != 0)
        id->type = tp;
}

canonical_original_code:
void *int_parse_constdefn(unsigned long *folls, unsigned long *ex)
{
    struct _id_table_elem *id = 0;
    struct _type_table_elem *tp = 0;
    if (lex_get_s() == L_IDENT)
    {
        union lex_val lv = lex_get_v();
        char *name = strdup(lv.string);
        id = add_to_id_table(0, name, UC_CONST);
    }
    accept(L_IDENT);
    accept(L_EQUAL);
    tp = parse_constant(folls, 0);
    if (id != 0)
        id->type = tp;
}


decompiled_code:
void init_parser_constant()
{
if ( parser_start_constant )
{
if ( parser_folls_constant )
goto LABEL_3;
}
else
{
parser_start_constant = (void *)bits_from_array(&int_start_constant);
if ( parser_folls_constant )
{
LABEL_3:
if ( parser_start_constdecl )
goto LABEL_4;
goto LABEL_11;
}
}
parser_folls_constant = (void *)bits_from_array(&int_folls_constant);
if ( parser_start_constdecl )
{
LABEL_4:
if ( parser_folls_constdecl )
goto LABEL_5;
goto LABEL_12;
}
LABEL_11:
parser_start_constdecl = (void *)bits_from_array(&int_start_constdecl);
if ( parser_folls_constdecl )
{
LABEL_5:
if ( parser_start_constdefn )
goto LABEL_6;
goto LABEL_13;
}
LABEL_12:
parser_folls_constdecl = (void *)bits_from_array(&int_folls_constdecl);
if ( parser_start_constdefn )
{
LABEL_6:
if ( parser_folls_constdefn )
goto LABEL_7;
goto LABEL_14;
}
LABEL_13:
parser_start_constdefn = (void *)bits_from_array(&int_start_constdefn);
if ( parser_folls_constdefn )
{
LABEL_7:
if ( parser_constdecl_aux )
return;
LABEL_15:
parser_constdecl_aux = (void *)bits_from_array(&int_constdecl_aux);
return;
}
LABEL_14:
parser_folls_constdefn = (void *)bits_from_array(&int_folls_constdefn);
if ( !parser_constdecl_aux )
goto LABEL_15;
}

canonical_decompiled_code:
void func6()
{
if ( parser_start_constant )
{
if ( parser_folls_constant )
goto LABEL_3;
}
else
{
parser_start_constant = (void *)bits_from_array(&int_start_constant);
if ( parser_folls_constant )
{
LABEL_3:
if ( parser_start_constdecl )
goto LABEL_4;
goto LABEL_11;
}
}
parser_folls_constant = (void *)bits_from_array(&int_folls_constant);
if ( parser_start_constdecl )
{
LABEL_4:
if ( parser_folls_constdecl )
goto LABEL_5;
goto LABEL_12;
}
LABEL_11:
parser_start_constdecl = (void *)bits_from_array(&int_start_constdecl);
if ( parser_folls_constdecl )
{
LABEL_5:
if ( parser_start_constdefn )
goto LABEL_6;
goto LABEL_13;
}
LABEL_12:
parser_folls_constdecl = (void *)bits_from_array(&int_folls_constdecl);
if ( parser_start_constdefn )
{
LABEL_6:
if ( parser_folls_constdefn )
goto LABEL_7;
goto LABEL_14;
}
LABEL_13:
parser_start_constdefn = (void *)bits_from_array(&int_start_constdefn);
if ( parser_folls_constdefn )
{
LABEL_7:
if ( parser_constdecl_aux )
return;
LABEL_15:
parser_constdecl_aux = (void *)bits_from_array(&int_constdecl_aux);
return;
}
LABEL_14:
parser_folls_constdefn = (void *)bits_from_array(&int_folls_constdefn);
if ( !parser_constdecl_aux )
goto LABEL_15;
}

original_code:
void init_parser_constant(void)
{
    { { if (parser_start_constant == 0) parser_start_constant = bits_from_array(int_start_constant); }; { if (parser_folls_constant == 0) parser_folls_constant = bits_from_array(int_folls_constant); }; };
    { { if (parser_start_constdecl == 0) parser_start_constdecl = bits_from_array(int_start_constdecl); }; { if (parser_folls_constdecl == 0) parser_folls_constdecl = bits_from_array(int_folls_constdecl); }; };
    { { if (parser_start_constdefn == 0) parser_start_constdefn = bits_from_array(int_start_constdefn); }; { if (parser_folls_constdefn == 0) parser_folls_constdefn = bits_from_array(int_folls_constdefn); }; };
    { if (parser_constdecl_aux == 0) parser_constdecl_aux = bits_from_array(int_constdecl_aux); };
}

canonical_original_code:
void init_parser_constant()
{
    { { if (parser_start_constant == 0) parser_start_constant = bits_from_array(int_start_constant); }; { if (parser_folls_constant == 0) parser_folls_constant = bits_from_array(int_folls_constant); }; };
    { { if (parser_start_constdecl == 0) parser_start_constdecl = bits_from_array(int_start_constdecl); }; { if (parser_folls_constdecl == 0) parser_folls_constdecl = bits_from_array(int_folls_constdecl); }; };
    { { if (parser_start_constdefn == 0) parser_start_constdefn = bits_from_array(int_start_constdefn); }; { if (parser_folls_constdefn == 0) parser_folls_constdefn = bits_from_array(int_folls_constdefn); }; };
    { if (parser_constdecl_aux == 0) parser_constdecl_aux = bits_from_array(int_constdecl_aux); };
}


decompiled_code:
void fini_parser_constant()
{
if ( parser_start_constant )
free(parser_start_constant);
if ( parser_folls_constant )
free(parser_folls_constant);
if ( parser_start_constdecl )
free(parser_start_constdecl);
if ( parser_folls_constdecl )
free(parser_folls_constdecl);
if ( parser_start_constdefn )
free(parser_start_constdefn);
if ( parser_folls_constdefn )
free(parser_folls_constdefn);
if ( parser_constdecl_aux )
free(parser_constdecl_aux);
}

canonical_decompiled_code:
void func7()
{
if ( parser_start_constant )
free(parser_start_constant);
if ( parser_folls_constant )
free(parser_folls_constant);
if ( parser_start_constdecl )
free(parser_start_constdecl);
if ( parser_folls_constdecl )
free(parser_folls_constdecl);
if ( parser_start_constdefn )
free(parser_start_constdefn);
if ( parser_folls_constdefn )
free(parser_folls_constdefn);
if ( parser_constdecl_aux )
free(parser_constdecl_aux);
}

original_code:
void fini_parser_constant(void)
{
    { { if (parser_start_constant != 0) free(parser_start_constant); }; { if (parser_folls_constant != 0) free(parser_folls_constant); }; };
    { { if (parser_start_constdecl != 0) free(parser_start_constdecl); }; { if (parser_folls_constdecl != 0) free(parser_folls_constdecl); }; };
    { { if (parser_start_constdefn != 0) free(parser_start_constdefn); }; { if (parser_folls_constdefn != 0) free(parser_folls_constdefn); }; };
    { if (parser_constdecl_aux != 0) free(parser_constdecl_aux); };
}

canonical_original_code:
void fini_parser_constant()
{
    { { if (parser_start_constant != 0) free(parser_start_constant); }; { if (parser_folls_constant != 0) free(parser_folls_constant); }; };
    { { if (parser_start_constdecl != 0) free(parser_start_constdecl); }; { if (parser_folls_constdecl != 0) free(parser_folls_constdecl); }; };
    { { if (parser_start_constdefn != 0) free(parser_start_constdefn); }; { if (parser_folls_constdefn != 0) free(parser_folls_constdefn); }; };
    { if (parser_constdecl_aux != 0) free(parser_constdecl_aux); };
}


decompiled_code:
__int64 __fastcall int_parse_assign_operator(__int64 a1, __int64 a2)
{
void *v3; // rbp
struct sockaddr *v4; // rsi
__int64 v5; // r12
unsigned int v6; // er14
unsigned int v7; // ebx
socklen_t *v8; // rdx
__int64 v9; // rbp
char *v11; // r13
__int64 v12; // rdi
const char *v13; // r15
const char *v14; // rax
char *v15; // rax

v3 = (void *)balloc();
bits_disjunct(a1, parser_assign_operator_aux, v3);
bits_disjunct(v3, parser_start_expr, v3);
v4 = (struct sockaddr *)parser_assign_operator_aux;
v5 = parse_varuse(v3, parser_assign_operator_aux);
free(v3);
v6 = syn_line;
v7 = syn_c;
accept(305, v4, v8);
v9 = parse_expr(a1, a2);
if ( !(unsigned int)can_assign(v5, v9) )
{
v11 = (char *)malloc(0x400uLL);
v12 = v5;
v5 = 0LL;
v13 = (const char *)get_type_name(v9);
v14 = (const char *)get_type_name(v12);
sprintf(v11, "expected '%s' but got '%s'", v14, v13);
v15 = dcgettext(0LL, "type mismatch:", 5);
err_include(3LL, v15, v11, v6, v7);
}
return v5;
}

canonical_decompiled_code:
__int64 __fastcall func0(__int64 a1, __int64 a2)
{
void *v3; // rbp
struct sockaddr *v4; // rsi
__int64 v5; // r12
unsigned int v6; // er14
unsigned int v7; // ebx
socklen_t *v8; // rdx
__int64 v9; // rbp
char *v11; // r13
__int64 v12; // rdi
const char *v13; // r15
const char *v14; // rax
char *v15; // rax

v3 = (void *)balloc();
bits_disjunct(a1, parser_assign_operator_aux, v3);
bits_disjunct(v3, parser_start_expr, v3);
v4 = (struct sockaddr *)parser_assign_operator_aux;
v5 = parse_varuse(v3, parser_assign_operator_aux);
free(v3);
v6 = syn_line;
v7 = syn_c;
accept(305, v4, v8);
v9 = parse_expr(a1, a2);
if ( !(unsigned int)can_assign(v5, v9) )
{
v11 = (char *)malloc(0x400uLL);
v12 = v5;
v5 = 0LL;
v13 = (const char *)get_type_name(v9);
v14 = (const char *)get_type_name(v12);
sprintf(v11, "expected '%s' but got '%s'", v14, v13);
v15 = dcgettext(0LL, "type mismatch:", 5);
err_include(3LL, v15, v11, v6, v7);
}
return v5;
}

original_code:
void *int_parse_assign_operator (unsigned long *folls, unsigned long *ex)
{
    unsigned long *tmp = balloc();
    bits_disjunct(folls, parser_assign_operator_aux, tmp);
    bits_disjunct(tmp, parser_start_expr, tmp);
    type_table_elem *tp1, *tp2, *ret;
    tp1 = parse_varuse(tmp, parser_assign_operator_aux);
    free(tmp);
    int sl, sc;
    ret = 0;
    sl = syn_line;
    sc = syn_c;
    accept(L_ASSIGN);
    tp2 = parse_expr(folls, ex);
    if (!can_assign(tp1, tp2))
    {
        char *st = malloc(1024);
        sprintf(st, "expected '%s' but got '%s'", get_type_name(tp1), get_type_name(tp2));
        err_include(ERROR, gettext("type mismatch:"), st, sl, sc);
    } else {
        ret = tp1;
    }
    return ret;
}

canonical_original_code:
void *int_parse_assign_operator(unsigned long *folls, unsigned long *ex)
{
    unsigned long *tmp = balloc();
    bits_disjunct(folls, parser_assign_operator_aux, tmp);
    bits_disjunct(tmp, parser_start_expr, tmp);
    struct _type_table_elem *tp1; struct _type_table_elem *tp2; struct _type_table_elem *ret;
    tp1 = parse_varuse(tmp, parser_assign_operator_aux);
    free(tmp);
    int sl; int sc;
    ret = 0;
    sl = syn_line;
    sc = syn_c;
    accept(L_ASSIGN);
    tp2 = parse_expr(folls, ex);
    if (!can_assign(tp1, tp2))
    {
        char *st = malloc(1024);
        sprintf(st, "expected '%s' but got '%s'", get_type_name(tp1), get_type_name(tp2));
        err_include(ERROR, gettext("type mismatch:"), st, sl, sc);
    } else {
        ret = tp1;
    }
    return ret;
}

variable_types:
st
char *


decompiled_code:
__int64 __fastcall parse_assign_operator(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_assign_operator, a1, a2, int_parse_assign_operator, "assign_operator");
}

canonical_decompiled_code:
__int64 __fastcall func1(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_assign_operator, a1, a2, int_parse_assign_operator, "assign_operator");
}

original_code: void *parse_assign_operator (unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_assign_operator, folls, ex, int_parse_assign_operator, parser_name_assign_operator); }

canonical_original_code: void *parse_assign_operator(unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_assign_operator, folls, ex, int_parse_assign_operator, parser_name_assign_operator); }

variable_types:
folls
unsigned long *


decompiled_code:
__int64 __fastcall parse_for_operator(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_for_operator, a1, a2, int_parse_for_operator, "for_operator");
}

canonical_decompiled_code:
__int64 __fastcall func2(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_for_operator, a1, a2, int_parse_for_operator, "for_operator");
}

original_code: void *parse_for_operator (unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_for_operator, folls, ex, int_parse_for_operator, parser_name_for_operator); }

canonical_original_code: void *parse_for_operator(unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_for_operator, folls, ex, int_parse_for_operator, parser_name_for_operator); }


decompiled_code:
__int64 __fastcall parse_g_operator(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_g_operator, a1, a2, int_parse_g_operator, "g_operator");
}

canonical_decompiled_code:
__int64 __fastcall func3(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_g_operator, a1, a2, int_parse_g_operator, "g_operator");
}

original_code: void *parse_g_operator (unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_g_operator, folls, ex, int_parse_g_operator, parser_name_g_operator); }

canonical_original_code: void *parse_g_operator(unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_g_operator, folls, ex, int_parse_g_operator, parser_name_g_operator); }


decompiled_code:
__int64 __fastcall int_parse_for_operator(__int64 a1)
{
void *v1; // rbp
struct sockaddr *v2; // rsi
socklen_t *v3; // rdx
char *v4; // rsi
unsigned int v5; // er14
unsigned int v6; // ebx
__int64 v7; // r13
socklen_t *v8; // rdx
unsigned int v9; // ebx
__int64 v10; // r15
__int64 v11; // r14
int v12; // eax
unsigned int v13; // er14
char *v14; // rsi
socklen_t *v15; // rdx
__int64 v17; // r15
__int64 v18; // r13
char *v19; // rax
char *v20; // rax
char *s; // [rsp+8h] [rbp-40h]

v1 = (void *)balloc();
bits_disjunct(a1, parser_for_operator_aux1, v1);
v2 = (struct sockaddr *)parser_for_operator_aux2;
bits_disjunct(v1, parser_for_operator_aux2, v1);
accept(505, v2, v3);
v4 = (char *)parser_for_operator_aux1;
v5 = syn_line;
v6 = syn_c;
v7 = parse_assign_operator((__int64)v1, (__int64)parser_for_operator_aux1);
if ( !(unsigned int)can_iterate(v7) )
{
v7 = 0LL;
v4 = dcgettext(0LL, "invalid loop initialization", 5);
err_include(3LL, v4, 0LL, v5, v6);
}
if ( (unsigned int)lex_get_s() == 401 )
accept(401, (struct sockaddr *)v4, v8);
else
accept(801, (struct sockaddr *)v4, v8);
v9 = 0;
v10 = 0LL;
bits_disjunct(a1, parser_for_operator_aux2, v1);
v11 = parser_start_expr;
v12 = lex_get_s();
v13 = bits_belong(v12, v11);
if ( v13 )
{
v13 = syn_line;
v9 = syn_c;
v10 = parse_expr(v1, 0LL);
if ( !(unsigned int)can_iterate(v10) )
{
v10 = 0LL;
v20 = dcgettext(0LL, "invalid loop finalization", 5);
err_include(3LL, v20, 0LL, v13, v9);
}
}
v14 = (char *)v10;
if ( !(unsigned int)can_assign(v7, v10) )
{
s = (char *)malloc(0x800uLL);
v17 = get_type_name(v10);
v18 = get_type_name(v7);
v19 = dcgettext(0LL, "expected '%s' but got '%s'", 5);
sprintf(s, v19, v18, v17);
v14 = dcgettext(0LL, "type mismatch:", 5);
err_include(3LL, v14, s, v13, v9);
}
free(v1);
accept(404, (struct sockaddr *)v14, v15);
return parse_g_operator(a1, 0LL);
}

canonical_decompiled_code:
__int64 __fastcall func4(__int64 a1)
{
void *v1; // rbp
struct sockaddr *v2; // rsi
socklen_t *v3; // rdx
char *v4; // rsi
unsigned int v5; // er14
unsigned int v6; // ebx
__int64 v7; // r13
socklen_t *v8; // rdx
unsigned int v9; // ebx
__int64 v10; // r15
__int64 v11; // r14
int v12; // eax
unsigned int v13; // er14
char *v14; // rsi
socklen_t *v15; // rdx
__int64 v17; // r15
__int64 v18; // r13
char *v19; // rax
char *v20; // rax
char *s; // [rsp+8h] [rbp-40h]

v1 = (void *)balloc();
bits_disjunct(a1, parser_for_operator_aux1, v1);
v2 = (struct sockaddr *)parser_for_operator_aux2;
bits_disjunct(v1, parser_for_operator_aux2, v1);
accept(505, v2, v3);
v4 = (char *)parser_for_operator_aux1;
v5 = syn_line;
v6 = syn_c;
v7 = func1((__int64)v1, (__int64)parser_for_operator_aux1);
if ( !(unsigned int)can_iterate(v7) )
{
v7 = 0LL;
v4 = dcgettext(0LL, "invalid loop initialization", 5);
err_include(3LL, v4, 0LL, v5, v6);
}
if ( (unsigned int)lex_get_s() == 401 )
accept(401, (struct sockaddr *)v4, v8);
else
accept(801, (struct sockaddr *)v4, v8);
v9 = 0;
v10 = 0LL;
bits_disjunct(a1, parser_for_operator_aux2, v1);
v11 = parser_start_expr;
v12 = lex_get_s();
v13 = bits_belong(v12, v11);
if ( v13 )
{
v13 = syn_line;
v9 = syn_c;
v10 = parse_expr(v1, 0LL);
if ( !(unsigned int)can_iterate(v10) )
{
v10 = 0LL;
v20 = dcgettext(0LL, "invalid loop finalization", 5);
err_include(3LL, v20, 0LL, v13, v9);
}
}
v14 = (char *)v10;
if ( !(unsigned int)can_assign(v7, v10) )
{
s = (char *)malloc(0x800uLL);
v17 = get_type_name(v10);
v18 = get_type_name(v7);
v19 = dcgettext(0LL, "expected '%s' but got '%s'", 5);
sprintf(s, v19, v18, v17);
v14 = dcgettext(0LL, "type mismatch:", 5);
err_include(3LL, v14, s, v13, v9);
}
free(v1);
accept(404, (struct sockaddr *)v14, v15);
return func3(a1, 0LL);
}

original_code:
void *int_parse_for_operator (unsigned long *folls, unsigned long *ex)
{
    unsigned long *tmp;
    tmp = balloc();
    bits_disjunct(folls, parser_for_operator_aux1, tmp);
    bits_disjunct(tmp, parser_for_operator_aux2, tmp);
    type_table_elem *tp1 = 0, *tp2 = 0;
    int sl1 = 0, sc1 = 0;
    accept(L_FOR);
    int sl = syn_line, sc = syn_c;
    tp1 = parse_assign_operator(tmp, parser_for_operator_aux1);
    if (!can_iterate(tp1))
    {
        err_include(ERROR, gettext("invalid loop initialization"), 0, sl, sc);
        tp1 = 0;
    }
    if (lex_get_s() == L_TO)
        accept(L_TO);
    else
        accept(L_DOWNTO);
    bits_disjunct(folls, parser_for_operator_aux2, tmp);
    if (bits_belong(lex_get_s(), parser_start_expr))
    {
        sl1 = syn_line, sc1 = syn_c;
        tp2 = parse_expr(tmp, 0);
        if (!can_iterate(tp2))
        {
            err_include(ERROR, gettext("invalid loop finalization"), 0, sl1, sc1);
            tp2 = 0;
        }
    } else {
    }
    if (!can_assign(tp1, tp2))
    {
        char *st = malloc(1024*2);
        sprintf(st, gettext("expected '%s' but got '%s'"), get_type_name(tp1), get_type_name(tp2));
        err_include(ERROR, gettext("type mismatch:"), st, sl1, sc1);
    }
    free(tmp);
    accept(L_DO);
    parse_g_operator(folls, 0);
}

canonical_original_code:
void *int_parse_for_operator(unsigned long *folls, unsigned long *ex)
{
    unsigned long *tmp;
    tmp = balloc();
    bits_disjunct(folls, parser_for_operator_aux1, tmp);
    bits_disjunct(tmp, parser_for_operator_aux2, tmp);
    struct _type_table_elem *tp1 = 0; struct _type_table_elem *tp2 = 0;
    int sl1 = 0; int sc1 = 0;
    accept(L_FOR);
    int sl = syn_line; int sc = syn_c;
    tp1 = parse_assign_operator(tmp, parser_for_operator_aux1);
    if (!can_iterate(tp1))
    {
        err_include(ERROR, gettext("invalid loop initialization"), 0, sl, sc);
        tp1 = 0;
    }
    if (lex_get_s() == L_TO)
        accept(L_TO);
    else
        accept(L_DOWNTO);
    bits_disjunct(folls, parser_for_operator_aux2, tmp);
    if (bits_belong(lex_get_s(), parser_start_expr))
    {
        sl1 = syn_line, sc1 = syn_c;
        tp2 = parse_expr(tmp, 0);
        if (!can_iterate(tp2))
        {
            err_include(ERROR, gettext("invalid loop finalization"), 0, sl1, sc1);
            tp2 = 0;
        }
    } else {
    }
    if (!can_assign(tp1, tp2))
    {
        char *st = malloc(1024*2);
        sprintf(st, gettext("expected '%s' but got '%s'"), get_type_name(tp1), get_type_name(tp2));
        err_include(ERROR, gettext("type mismatch:"), st, sl1, sc1);
    }
    free(tmp);
    accept(L_DO);
    parse_g_operator(folls, 0);
}


decompiled_code:
void __fastcall int_parse_complex_operator(__int64 a1)
{
__int64 v1; // rax
struct sockaddr *v2; // rsi
void *v3; // r12
socklen_t *v4; // rdx
int i; // edi
struct sockaddr *v6; // rbp
__int64 v7; // rdi

v1 = balloc();
v2 = (struct sockaddr *)parser_complex_operator_aux;
v3 = (void *)v1;
bits_disjunct(a1, parser_complex_operator_aux, v1);
for ( i = 700; ; i = 59 )
{
accept(i, v2, v4);
v6 = (struct sockaddr *)parser_start_g_operator;
v7 = (int)lex_get_s();
v2 = v6;
if ( (unsigned int)bits_belong(v7, v6) )
break;
if ( (unsigned int)lex_get_s() != 59 )
goto LABEL_6;
LABEL_3:
;
}
v2 = 0LL;
parse_g_operator((__int64)v3, 0LL);
if ( (unsigned int)lex_get_s() == 59 )
goto LABEL_3;
LABEL_6:
accept(500, v2, v4);
free(v3);
}

canonical_decompiled_code:
void __fastcall func5(__int64 a1)
{
__int64 v1; // rax
struct sockaddr *v2; // rsi
void *v3; // r12
socklen_t *v4; // rdx
int i; // edi
struct sockaddr *v6; // rbp
__int64 v7; // rdi

v1 = balloc();
v2 = (struct sockaddr *)parser_complex_operator_aux;
v3 = (void *)v1;
bits_disjunct(a1, parser_complex_operator_aux, v1);
for ( i = 700; ; i = 59 )
{
accept(i, v2, v4);
v6 = (struct sockaddr *)parser_start_g_operator;
v7 = (int)lex_get_s();
v2 = v6;
if ( (unsigned int)bits_belong(v7, v6) )
break;
if ( (unsigned int)lex_get_s() != 59 )
goto LABEL_6;
LABEL_3:
;
}
v2 = 0LL;
func3((__int64)v3, 0LL);
if ( (unsigned int)lex_get_s() == 59 )
goto LABEL_3;
LABEL_6:
accept(500, v2, v4);
free(v3);
}

original_code:
void *int_parse_complex_operator (unsigned long *folls, unsigned long *ex)
{
    unsigned long *tmp = balloc();
    bits_disjunct(folls, parser_complex_operator_aux, tmp);
    accept(L_BEGIN);
    if (bits_belong(lex_get_s(), parser_start_g_operator))
    {
        parse_g_operator(tmp, 0);
    }
    while (lex_get_s() == L_SEMICOLON)
    {
        accept(L_SEMICOLON);
        if (bits_belong(lex_get_s(), parser_start_g_operator))
            parse_g_operator(tmp, 0);
    }
    accept(L_END);
    free(tmp);
}

canonical_original_code:
void *int_parse_complex_operator(unsigned long *folls, unsigned long *ex)
{
    unsigned long *tmp = balloc();
    bits_disjunct(folls, parser_complex_operator_aux, tmp);
    accept(L_BEGIN);
    if (bits_belong(lex_get_s(), parser_start_g_operator))
    {
        parse_g_operator(tmp, 0);
    }
    while (lex_get_s() == L_SEMICOLON)
    {
        accept(L_SEMICOLON);
        if (bits_belong(lex_get_s(), parser_start_g_operator))
            parse_g_operator(tmp, 0);
    }
    accept(L_END);
    free(tmp);
}


decompiled_code:
__int64 __fastcall parse_complex_operator(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_complex_operator, a1, a2, int_parse_complex_operator, "complex_operator");
}

canonical_decompiled_code:
__int64 __fastcall func6(__int64 a1, __int64 a2)
{
return parser_exec(parser_start_complex_operator, a1, a2, int_parse_complex_operator, "complex_operator");
}

original_code: void *parse_complex_operator (unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_complex_operator, folls, ex, int_parse_complex_operator, parser_name_complex_operator); }

canonical_original_code: void *parse_complex_operator(unsigned long *folls, unsigned long *ex) { return parser_exec(parser_start_complex_operator, folls, ex, int_parse_complex_operator, parser_name_complex_operator); }


decompiled_code:
__int64 __fastcall int_parse_g_operator(__int64 a1)
{
void *v2; // rbp
__int64 v3; // rdi
__int64 result; // rax
unsigned int v5; // ebp
unsigned int v6; // er12
unsigned int v7; // eax
__int64 v8; // rax

while ( 1 )
{
v2 = parser_start_g_operator;
v3 = (int)lex_get_s();
result = bits_belong(v3, v2);
if ( !(_DWORD)result )
break;
if ( (unsigned int)lex_get_s() == 700 )
{
parse_complex_operator(a1, 0LL);
}
else if ( (unsigned int)lex_get_s() == 505 )
{
parse_for_operator(a1, 0LL);
}
else if ( (unsigned int)lex_get_s() == 1000 )
{
parse_assign_operator(a1, 0LL);
}
else
{
v5 = syn_c;
v6 = syn_line;
v7 = lex_get_s();
v8 = sym_get_sym(v7);
err_include(4LL, "unsupported operator:", v8, v6, v5);
}
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func7(__int64 a1)
{
void *v2; // rbp
__int64 v3; // rdi
__int64 result; // rax
unsigned int v5; // ebp
unsigned int v6; // er12
unsigned int v7; // eax
__int64 v8; // rax

while ( 1 )
{
v2 = parser_start_g_operator;
v3 = (int)lex_get_s();
result = bits_belong(v3, v2);
if ( !(_DWORD)result )
break;
if ( (unsigned int)lex_get_s() == 700 )
{
func6(a1, 0LL);
}
else if ( (unsigned int)lex_get_s() == 505 )
{
func2(a1, 0LL);
}
else if ( (unsigned int)lex_get_s() == 1000 )
{
func1(a1, 0LL);
}
else
{
v5 = syn_c;
v6 = syn_line;
v7 = lex_get_s();
v8 = sym_get_sym(v7);
err_include(4LL, "unsupported operator:", v8, v6, v5);
}
}
return result;
}

original_code:
void *int_parse_g_operator (unsigned long *folls, unsigned long *ex)
{
    while (bits_belong(lex_get_s(), parser_start_g_operator))
    {
        if (lex_get_s() == L_BEGIN) {
            parse_complex_operator(folls, 0);
        } else if (lex_get_s() == L_FOR) {
            parse_for_operator(folls, 0);
        } else if (lex_get_s() == L_IDENT) {
            parse_assign_operator(folls, 0);
        } else {
            err_include(EFATAL, "unsupported operator:", sym_get_sym(lex_get_s()), syn_line, syn_c);
        }
    }
}

canonical_original_code:
void *int_parse_g_operator(unsigned long *folls, unsigned long *ex)
{
    while (bits_belong(lex_get_s(), parser_start_g_operator))
    {
        if (lex_get_s() == L_BEGIN) {
            parse_complex_operator(folls, 0);
        } else if (lex_get_s() == L_FOR) {
            parse_for_operator(folls, 0);
        } else if (lex_get_s() == L_IDENT) {
            parse_assign_operator(folls, 0);
        } else {
            err_include(EFATAL, "unsupported operator:", sym_get_sym(lex_get_s()), syn_line, syn_c);
        }
    }
}