IdentV

decompiled_code:
__int64 __fastcall IdentV(__int64 a1)
{
headPr("Ident");
if ( a1 )
{
switch ( *(_DWORD *)a1 )
{
case 0:
innerIdnlnPr(2LL, "type=", "Init_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "val=");
innerIntPr(*(unsigned int *)(a1 + 16));
innerIdnPr(1LL, "length=");
innerIntPr(*(unsigned int *)(a1 + 20));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 1:
innerIdnlnPr(2LL, "type=", "Proc_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 2:
innerIdnlnPr(2LL, "type=", "Int_Fun_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 3:
innerIdnlnPr(2LL, "type=", "Char_Fun_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 4:
innerIdnlnPr(2LL, "type=", "Int_Const_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "val=");
innerIntPr(*(unsigned int *)(a1 + 16));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 5:
innerIdnlnPr(2LL, "type=", "Char_Const_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "val=");
innerCharPr((unsigned int)*(char *)(a1 + 16));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 6:
innerIdnlnPr(2LL, "type=", "Int_Var_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 7:
innerIdnlnPr(2LL, "type=", "Char_Var_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 8:
innerIdnlnPr(2LL, "type=", "IntArr_Var_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "length=");
innerIntPr(*(unsigned int *)(a1 + 20));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 9:
innerIdnlnPr(2LL, "type=", "CharArr_Var_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "length=");
innerIntPr(*(unsigned int *)(a1 + 20));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 0xA:
innerIdnlnPr(2LL, "type=", "Int_Para_Val_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 0xB:
innerIdnlnPr(2LL, "type=", "Char_Para_Val_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 0xC:
innerIdnlnPr(2LL, "type=", "Int_Para_Ref_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 0xD:
innerIdnlnPr(2LL, "type=", "Char_Para_Ref_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
default:
fwrite("ANALYSER BUG:503\n", 1uLL, 0x11uLL, errlist);
break;
}
}
return tailPr("Ident");
}

canonical_decompiled_code:
__int64 __fastcall func0(__int64 a1)
{
headPr("Ident");
if ( a1 )
{
switch ( *(_DWORD *)a1 )
{
case 0:
innerIdnlnPr(2LL, "type=", "Init_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "val=");
innerIntPr(*(unsigned int *)(a1 + 16));
innerIdnPr(1LL, "length=");
innerIntPr(*(unsigned int *)(a1 + 20));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 1:
innerIdnlnPr(2LL, "type=", "Proc_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 2:
innerIdnlnPr(2LL, "type=", "Int_Fun_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 3:
innerIdnlnPr(2LL, "type=", "Char_Fun_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 4:
innerIdnlnPr(2LL, "type=", "Int_Const_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "val=");
innerIntPr(*(unsigned int *)(a1 + 16));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 5:
innerIdnlnPr(2LL, "type=", "Char_Const_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "val=");
innerCharPr((unsigned int)*(char *)(a1 + 16));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 6:
innerIdnlnPr(2LL, "type=", "Int_Var_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 7:
innerIdnlnPr(2LL, "type=", "Char_Var_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 8:
innerIdnlnPr(2LL, "type=", "IntArr_Var_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "length=");
innerIntPr(*(unsigned int *)(a1 + 20));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 9:
innerIdnlnPr(2LL, "type=", "CharArr_Var_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "length=");
innerIntPr(*(unsigned int *)(a1 + 20));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 0xA:
innerIdnlnPr(2LL, "type=", "Int_Para_Val_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 0xB:
innerIdnlnPr(2LL, "type=", "Char_Para_Val_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 0xC:
innerIdnlnPr(2LL, "type=", "Int_Para_Ref_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 0xD:
innerIdnlnPr(2LL, "type=", "Char_Para_Ref_Ident_t");
innerIdnPr(1LL, "name=");
innerlnPr(1LL, *(_QWORD *)(a1 + 8));
innerIdnPr(1LL, "line=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
default:
fwrite("ANALYSER BUG:503\n", 1uLL, 0x11uLL, errlist);
break;
}
}
return tailPr("Ident");
}

original_code:
void IdentV(IdentSP t)
{
  headPr("Ident");
  if (t != ((void *)0)) {
    switch (t->type) {
    case Init_Ident_t:
      innerIdnlnPr(2,"type=","Init_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"val=");
      innerIntPr(t->val);
      innerIdnPr(1,"length=");
      innerIntPr(t->length);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Proc_Ident_t:
      innerIdnlnPr(2,"type=","Proc_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Int_Fun_Ident_t:
      innerIdnlnPr(2,"type=","Int_Fun_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Char_Fun_Ident_t:
      innerIdnlnPr(2,"type=","Char_Fun_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Int_Const_Ident_t:
      innerIdnlnPr(2,"type=","Int_Const_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"val=");
      innerIntPr(t->val);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Char_Const_Ident_t:
      innerIdnlnPr(2,"type=","Char_Const_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"val=");
      innerCharPr( (char) t->val);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Int_Var_Ident_t:
      innerIdnlnPr(2,"type=","Int_Var_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Char_Var_Ident_t:
      innerIdnlnPr(2,"type=","Char_Var_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case IntArr_Var_Ident_t:
      innerIdnlnPr(2,"type=","IntArr_Var_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"length=");
      innerIntPr(t->length);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case CharArr_Var_Ident_t:
      innerIdnlnPr(2,"type=","CharArr_Var_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"length=");
      innerIntPr(t->length);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Int_Para_Val_Ident_t:
      innerIdnlnPr(2,"type=","Int_Para_Val_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Char_Para_Val_Ident_t:
      innerIdnlnPr(2,"type=","Char_Para_Val_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Int_Para_Ref_Ident_t:
      innerIdnlnPr(2,"type=","Int_Para_Ref_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Char_Para_Ref_Ident_t:
      innerIdnlnPr(2,"type=","Char_Para_Ref_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:503\n");
    }
  }
  tailPr("Ident");
}

canonical_original_code:
void IdentV(struct _IdentS *t)
{
  headPr("Ident");
  if (t != ((void *)0)) {
    switch (t->type) {
    case Init_Ident_t:
      innerIdnlnPr(2,"type=","Init_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"val=");
      innerIntPr(t->val);
      innerIdnPr(1,"length=");
      innerIntPr(t->length);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Proc_Ident_t:
      innerIdnlnPr(2,"type=","Proc_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Int_Fun_Ident_t:
      innerIdnlnPr(2,"type=","Int_Fun_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Char_Fun_Ident_t:
      innerIdnlnPr(2,"type=","Char_Fun_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Int_Const_Ident_t:
      innerIdnlnPr(2,"type=","Int_Const_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"val=");
      innerIntPr(t->val);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Char_Const_Ident_t:
      innerIdnlnPr(2,"type=","Char_Const_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"val=");
      innerCharPr( (char) t->val);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Int_Var_Ident_t:
      innerIdnlnPr(2,"type=","Int_Var_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Char_Var_Ident_t:
      innerIdnlnPr(2,"type=","Char_Var_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case IntArr_Var_Ident_t:
      innerIdnlnPr(2,"type=","IntArr_Var_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"length=");
      innerIntPr(t->length);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case CharArr_Var_Ident_t:
      innerIdnlnPr(2,"type=","CharArr_Var_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"length=");
      innerIntPr(t->length);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Int_Para_Val_Ident_t:
      innerIdnlnPr(2,"type=","Int_Para_Val_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Char_Para_Val_Ident_t:
      innerIdnlnPr(2,"type=","Char_Para_Val_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Int_Para_Ref_Ident_t:
      innerIdnlnPr(2,"type=","Int_Para_Ref_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    case Char_Para_Ref_Ident_t:
      innerIdnlnPr(2,"type=","Char_Para_Ref_Ident_t");
      innerIdnPr(1,"name=");
      innerlnPr(1,t->name);
      innerIdnPr(1,"line=");
      innerIntPr(t->line);
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:503\n");
    }
  }
  tailPr("Ident");
}

variable_types: struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *


ConstDefV

repo: Jeanhwea/Compiler

decompiled_code:
__int64 __fastcall ConstDefV(__int64 *a1)
{
headPr("ConstDef");
if ( a1 )
IdentV(*a1);
return tailPr("ConstDef");
}

canonical_decompiled_code:
__int64 __fastcall func1(__int64 *a1)
{
headPr("ConstDef");
if ( a1 )
func0(*a1);
return tailPr("ConstDef");
}

original_code:
void ConstDefV(ConstDefSP t)
{
  headPr("ConstDef");
  if (t != ((void *)0)) {
    IdentV(t->idp);
  }
  tailPr("ConstDef");
}

canonical_original_code:
void ConstDefV(struct _ConstDefS *t)
{
  headPr("ConstDef");
  if (t != ((void *)0)) {
    IdentV(t->idp);
  }
  tailPr("ConstDef");
}

variable_types: struct _ConstDefS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; } *

return_type: void

user_defined_types: struct _ConstDefS { struct _IdentS *idp; }

user_defined_types: struct _IdentS { enum Ident_t type; char *name; int val; int length; int line; }


ConstDecV

decompiled_code:
__int64 __fastcall ConstDecV(__int64 a1)
{
__int64 v1; // rbx

v1 = a1;
headPr("ConstDec");
if ( a1 )
{
do
{
ConstDefV(*(__int64 **)v1);
v1 = *(_QWORD *)(v1 + 8);
}
while ( v1 );
}
return tailPr("ConstDec");
}

canonical_decompiled_code:
__int64 __fastcall func2(__int64 a1)
{
__int64 v1; // rbx

v1 = a1;
headPr("ConstDec");
if ( a1 )
{
do
{
func1(*(__int64 **)v1);
v1 = *(_QWORD *)(v1 + 8);
}
while ( v1 );
}
return tailPr("ConstDec");
}

original_code:
void ConstDecV(ConstDecSP t)
{
  headPr("ConstDec");
  for (; t != ((void *)0); t = t->next) {
    ConstDefV(t->cdp);
  }
  tailPr("ConstDec");
}

canonical_original_code:
void ConstDecV(struct _ConstDecS *t)
{
  headPr("ConstDec");
  for (; t != ((void *)0); t = t->next) {
    ConstDefV(t->cdp);
  }
  tailPr("ConstDec");
}

variable_types: struct _ConstDecS { struct _ConstDefS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; } *cdp; struct _ConstDecS *next; } *

user_defined_types: struct _ConstDecS { struct _ConstDefS *cdp; struct _ConstDecS *next; }


VarDefV

decompiled_code:
__int64 __fastcall VarDefV(__int64 *a1)
{
__int64 *v1; // rbx

v1 = a1;
headPr("VarDef");
if ( a1 )
{
do
{
IdentV(*v1);
v1 = (__int64 *)v1[1];
}
while ( v1 );
}
return tailPr("VarDef");
}

canonical_decompiled_code:
__int64 __fastcall func3(__int64 *a1)
{
__int64 *v1; // rbx

v1 = a1;
headPr("VarDef");
if ( a1 )
{
do
{
func0(*v1);
v1 = (__int64 *)v1[1];
}
while ( v1 );
}
return tailPr("VarDef");
}

original_code:
void VarDefV(VarDefSP t)
{
  headPr("VarDef");
  for (; t != ((void *)0); t = t->next) {
    IdentV(t->idp);
  }
  tailPr("VarDef");
}

canonical_original_code:
void VarDefV(struct _VarDefS *t)
{
  headPr("VarDef");
  for (; t != ((void *)0); t = t->next) {
    IdentV(t->idp);
  }
  tailPr("VarDef");
}

variable_types: struct _VarDefS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _VarDefS *next; } *

user_defined_types: struct _VarDefS { struct _IdentS *idp; struct _VarDefS *next; }


VarDecV

decompiled_code:
__int64 __fastcall VarDecV(__int64 a1)
{
__int64 v1; // rbx

v1 = a1;
headPr("VarDec");
if ( a1 )
{
do
{
VarDefV(*(__int64 **)v1);
v1 = *(_QWORD *)(v1 + 8);
}
while ( v1 );
}
return tailPr("VarDec");
}

canonical_decompiled_code:
__int64 __fastcall func4(__int64 a1)
{
__int64 v1; // rbx

v1 = a1;
headPr("VarDec");
if ( a1 )
{
do
{
func3(*(__int64 **)v1);
v1 = *(_QWORD *)(v1 + 8);
}
while ( v1 );
}
return tailPr("VarDec");
}

original_code:
void VarDecV(VarDecSP t)
{
  headPr("VarDec");
  for (; t != ((void *)0); t = t->next) {
    VarDefV(t->vdp);
  }
  tailPr("VarDec");
}

canonical_original_code:
void VarDecV(struct _VarDecS *t)
{
  headPr("VarDec");
  for (; t != ((void *)0); t = t->next) {
    VarDefV(t->vdp);
  }
  tailPr("VarDec");
}

variable_types: struct _VarDecS { struct _VarDefS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _VarDefS *next; } *vdp; struct _VarDecS *next; } *

user_defined_types: struct _VarDecS { struct _VarDefS *vdp; struct _VarDecS *next; }


ParaDefV

decompiled_code:
__int64 __fastcall ParaDefV(__int64 *a1)
{
__int64 *v1; // rbx

v1 = a1;
headPr("ParaDef");
if ( a1 )
{
do
{
IdentV(*v1);
v1 = (__int64 *)v1[1];
}
while ( v1 );
}
return tailPr("ParaDef");
}

canonical_decompiled_code:
__int64 __fastcall func5(__int64 *a1)
{
__int64 *v1; // rbx

v1 = a1;
headPr("ParaDef");
if ( a1 )
{
do
{
func0(*v1);
v1 = (__int64 *)v1[1];
}
while ( v1 );
}
return tailPr("ParaDef");
}

original_code:
void ParaDefV(ParaDefSP t)
{
  headPr("ParaDef");
  for (; t != ((void *)0); t = t->next) {
    IdentV(t->idp);
  }
  tailPr("ParaDef");
}

canonical_original_code:
void ParaDefV(struct _ParaDefS *t)
{
  headPr("ParaDef");
  for (; t != ((void *)0); t = t->next) {
    IdentV(t->idp);
  }
  tailPr("ParaDef");
}

variable_types: struct _ParaDefS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ParaDefS *next; } *

user_defined_types: struct _ParaDefS { struct _IdentS *idp; struct _ParaDefS *next; }


ParaListV

decompiled_code:
__int64 __fastcall ParaListV(__int64 a1)
{
__int64 v1; // rbx

v1 = a1;
headPr("ParaList");
if ( a1 )
{
do
{
ParaDefV(*(__int64 **)v1);
v1 = *(_QWORD *)(v1 + 8);
}
while ( v1 );
}
return tailPr("ParaList");
}

canonical_decompiled_code:
__int64 __fastcall func6(__int64 a1)
{
__int64 v1; // rbx

v1 = a1;
headPr("ParaList");
if ( a1 )
{
do
{
func5(*(__int64 **)v1);
v1 = *(_QWORD *)(v1 + 8);
}
while ( v1 );
}
return tailPr("ParaList");
}

original_code:
void ParaListV(ParaListSP t)
{
  headPr("ParaList");
  for (; t != ((void *)0); t = t->next) {
    ParaDefV(t->pdp);
  }
  tailPr("ParaList");
}

canonical_original_code:
void ParaListV(struct _ParaListS *t)
{
  headPr("ParaList");
  for (; t != ((void *)0); t = t->next) {
    ParaDefV(t->pdp);
  }
  tailPr("ParaList");
}

variable_types: struct _ParaListS { struct _ParaDefS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ParaDefS *next; } *pdp; struct _ParaListS *next; } *

user_defined_types: struct _ParaListS { struct _ParaDefS *pdp; struct _ParaListS *next; }


ProcHeadV

decompiled_code:
__int64 __fastcall ProcHeadV(__int64 *a1)
{
headPr("ProcHead");
if ( a1 )
{
IdentV(*a1);
ParaListV(a1[1]);
}
return tailPr("ProcHead");
}

canonical_decompiled_code:
__int64 __fastcall func7(__int64 *a1)
{
headPr("ProcHead");
if ( a1 )
{
func0(*a1);
func6(a1[1]);
}
return tailPr("ProcHead");
}

original_code:
void ProcHeadV(ProcHeadSP t)
{
  headPr("ProcHead");
  if (t != ((void *)0)) {
    IdentV(t->idp);
    ParaListV(t->plp);
  }
  tailPr("ProcHead");
}

canonical_original_code:
void ProcHeadV(struct _ProcHeadS *t)
{
  headPr("ProcHead");
  if (t != ((void *)0)) {
    IdentV(t->idp);
    ParaListV(t->plp);
  }
  tailPr("ProcHead");
}

variable_types: struct _ProcHeadS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ParaListS { struct _ParaDefS { struct _IdentS *idp; struct _ParaDefS *next; } *pdp; struct _ParaListS *next; } *plp; } *

user_defined_types: struct _ProcHeadS { struct _IdentS *idp; struct _ParaListS *plp; }


FunHeadV

decompiled_code:
__int64 __fastcall FunHeadV(__int64 *a1)
{
headPr("FunHead");
if ( a1 )
{
IdentV(*a1);
ParaListV(a1[1]);
}
return tailPr("FunHead");
}

canonical_decompiled_code:
__int64 __fastcall func8(__int64 *a1)
{
headPr("FunHead");
if ( a1 )
{
func0(*a1);
func6(a1[1]);
}
return tailPr("FunHead");
}

original_code:
void FunHeadV(FunHeadSP t)
{
  headPr("FunHead");
  if (t != ((void *)0)) {
    IdentV(t->idp);
    ParaListV(t->plp);
  }
  tailPr("FunHead");
}

canonical_original_code:
void FunHeadV(struct _FunHeadS *t)
{
  headPr("FunHead");
  if (t != ((void *)0)) {
    IdentV(t->idp);
    ParaListV(t->plp);
  }
  tailPr("FunHead");
}

variable_types: struct _FunHeadS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ParaListS { struct _ParaDefS { struct _IdentS *idp; struct _ParaDefS *next; } *pdp; struct _ParaListS *next; } *plp; } *

user_defined_types: struct _FunHeadS { struct _IdentS *idp; struct _ParaListS *plp; }


ReadStmtV

decompiled_code:
__int64 __fastcall ReadStmtV(__int64 *a1)
{
__int64 *v1; // rbx

v1 = a1;
headPr("ReadStmt");
if ( a1 )
{
do
{
IdentV(*v1);
v1 = (__int64 *)v1[1];
}
while ( v1 );
}
return tailPr("ReadStmt");
}

canonical_decompiled_code:
__int64 __fastcall func9(__int64 *a1)
{
__int64 *v1; // rbx

v1 = a1;
headPr("ReadStmt");
if ( a1 )
{
do
{
func0(*v1);
v1 = (__int64 *)v1[1];
}
while ( v1 );
}
return tailPr("ReadStmt");
}

original_code:
void ReadStmtV(ReadStmtSP t)
{
  headPr("ReadStmt");
  for (; t != ((void *)0); t = t->next) {
    IdentV(t->idp);
  }
  tailPr("ReadStmt");
}

canonical_original_code:
void ReadStmtV(struct _ReadStmtS *t)
{
  headPr("ReadStmt");
  for (; t != ((void *)0); t = t->next) {
    IdentV(t->idp);
  }
  tailPr("ReadStmt");
}

variable_types: struct _ReadStmtS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ReadStmtS *next; } *

user_defined_types: struct _ReadStmtS { struct _IdentS *idp; struct _ReadStmtS *next; }


TermV

decompiled_code:
__int64 __fastcall TermV(int *a1)
{
int *v1; // rbx
int v3; // eax

v1 = a1;
headPr("Term");
if ( a1 )
{
do
{
v3 = *v1;
if ( *v1 == 1 )
{
innerIdnlnPr(2LL, "op=", "Mult_Multop_t");
}
else if ( v3 == 2 )
{
innerIdnlnPr(2LL, "op=", "Div_Multop_t");
}
else if ( v3 )
{
fwrite("ANALYSER BUG:391\n", 1uLL, 0x11uLL, errlist);
}
else
{
innerIdnlnPr(2LL, "op=", "Nop_Multop_t");
}
FactorV(*((_QWORD *)v1 + 1));
v1 = (int *)*((_QWORD *)v1 + 2);
}
while ( v1 );
}
return tailPr("Term");
}

canonical_decompiled_code:
__int64 __fastcall func10(int *a1)
{
int *v1; // rbx
int v3; // eax

v1 = a1;
headPr("Term");
if ( a1 )
{
do
{
v3 = *v1;
if ( *v1 == 1 )
{
innerIdnlnPr(2LL, "op=", "Mult_Multop_t");
}
else if ( v3 == 2 )
{
innerIdnlnPr(2LL, "op=", "Div_Multop_t");
}
else if ( v3 )
{
fwrite("ANALYSER BUG:391\n", 1uLL, 0x11uLL, errlist);
}
else
{
innerIdnlnPr(2LL, "op=", "Nop_Multop_t");
}
func15(*((_QWORD *)v1 + 1));
v1 = (int *)*((_QWORD *)v1 + 2);
}
while ( v1 );
}
return tailPr("Term");
}

original_code:
void TermV(TermSP t)
{
  headPr("Term");
  for (; t != ((void *)0); t = t->next) {
    switch (t->op) {
    case Nop_Multop_t:
      innerIdnlnPr(2,"op=","Nop_Multop_t");
      break;
    case Mult_Multop_t:
      innerIdnlnPr(2,"op=","Mult_Multop_t");
      break;
    case Div_Multop_t:
      innerIdnlnPr(2,"op=","Div_Multop_t");
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:391\n");
    }
    FactorV(t->fp);
  }
  tailPr("Term");
}

canonical_original_code:
void TermV(struct _TermS *t)
{
  headPr("Term");
  for (; t != ((void *)0); t = t->next) {
    switch (t->op) {
    case Nop_Multop_t:
      innerIdnlnPr(2,"op=","Nop_Multop_t");
      break;
    case Mult_Multop_t:
      innerIdnlnPr(2,"op=","Mult_Multop_t");
      break;
    case Div_Multop_t:
      innerIdnlnPr(2,"op=","Div_Multop_t");
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:391\n");
    }
    FactorV(t->fp);
  }
  tailPr("Term");
}

variable_types: struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS *tp; struct _ExprS *next; } *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *

user_defined_types: struct _TermS { enum Multop_t op; struct _FactorS *fp; struct _TermS *next; }

user_defined_types: struct _FactorS { enum Factor_t type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS *fcsp; }

user_defined_types: struct _ExprS { enum Addop_t op; struct _TermS *tp; struct _ExprS *next; }

user_defined_types: struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; }


ExprV

decompiled_code:
__int64 __fastcall ExprV(__int64 a1)
{
__int64 v1; // rbx
unsigned int v3; // eax

v1 = a1;
headPr("Expr");
if ( a1 )
{
do
{
v3 = *(_DWORD *)v1;
if ( *(_DWORD *)v1 == 2 )
{
innerIdnlnPr(2LL, "op=", "Neg_Addop_t");
}
else if ( v3 > 2 )
{
if ( v3 == 3 )
innerIdnlnPr(2LL, "op=", "Minus_Addop_t");
else
fwrite("ANALYSER BUG:369\n", 1uLL, 0x11uLL, errlist);
}
else if ( v3 )
{
innerIdnlnPr(2LL, "op=", "Add_Addop_t");
}
else
{
innerIdnlnPr(2LL, "op=", "Nop_Addop_t");
}
TermV(*(int **)(v1 + 8));
v1 = *(_QWORD *)(v1 + 16);
}
while ( v1 );
}
return tailPr("Expr");
}

canonical_decompiled_code:
__int64 __fastcall func11(__int64 a1)
{
__int64 v1; // rbx
unsigned int v3; // eax

v1 = a1;
headPr("Expr");
if ( a1 )
{
do
{
v3 = *(_DWORD *)v1;
if ( *(_DWORD *)v1 == 2 )
{
innerIdnlnPr(2LL, "op=", "Neg_Addop_t");
}
else if ( v3 > 2 )
{
if ( v3 == 3 )
innerIdnlnPr(2LL, "op=", "Minus_Addop_t");
else
fwrite("ANALYSER BUG:369\n", 1uLL, 0x11uLL, errlist);
}
else if ( v3 )
{
innerIdnlnPr(2LL, "op=", "Add_Addop_t");
}
else
{
innerIdnlnPr(2LL, "op=", "Nop_Addop_t");
}
func10(*(int **)(v1 + 8));
v1 = *(_QWORD *)(v1 + 16);
}
while ( v1 );
}
return tailPr("Expr");
}

original_code:
void ExprV(ExprSP t)
{
  headPr("Expr");
  for (; t != ((void *)0); t = t->next) {
    switch (t->op) {
    case Nop_Addop_t:
      innerIdnlnPr(2,"op=","Nop_Addop_t");
      break;
    case Add_Addop_t:
      innerIdnlnPr(2,"op=","Add_Addop_t");
      break;
    case Neg_Addop_t:
      innerIdnlnPr(2,"op=","Neg_Addop_t");
      break;
    case Minus_Addop_t:
      innerIdnlnPr(2,"op=","Minus_Addop_t");
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:369\n");
    }
    TermV(t->tp);
  }
  tailPr("Expr");
}

canonical_original_code:
void ExprV(struct _ExprS *t)
{
  headPr("Expr");
  for (; t != ((void *)0); t = t->next) {
    switch (t->op) {
    case Nop_Addop_t:
      innerIdnlnPr(2,"op=","Nop_Addop_t");
      break;
    case Add_Addop_t:
      innerIdnlnPr(2,"op=","Add_Addop_t");
      break;
    case Neg_Addop_t:
      innerIdnlnPr(2,"op=","Neg_Addop_t");
      break;
    case Minus_Addop_t:
      innerIdnlnPr(2,"op=","Minus_Addop_t");
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:369\n");
    }
    TermV(t->tp);
  }
  tailPr("Expr");
}

variable_types: struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *


ArgListV

decompiled_code:
__int64 __fastcall ArgListV(__int64 *a1)
{
__int64 *v1; // rbx

v1 = a1;
headPr("ArgList");
if ( a1 )
{
do
{
ExprV(*v1);
v1 = (__int64 *)v1[1];
}
while ( v1 );
}
return tailPr("ArgList");
}

canonical_decompiled_code:
__int64 __fastcall func12(__int64 *a1)
{
__int64 *v1; // rbx

v1 = a1;
headPr("ArgList");
if ( a1 )
{
do
{
func11(*v1);
v1 = (__int64 *)v1[1];
}
while ( v1 );
}
return tailPr("ArgList");
}

original_code:
void ArgListV(ArgListSP t)
{
  headPr("ArgList");
  for (; t != ((void *)0); t = t->next) {
    ExprV(t->ep);
  }
  tailPr("ArgList");
}

canonical_original_code:
void ArgListV(struct _ArgListS *t)
{
  headPr("ArgList");
  for (; t != ((void *)0); t = t->next) {
    ExprV(t->ep);
  }
  tailPr("ArgList");
}

variable_types: struct _ArgListS { struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *ep; struct _ArgListS *next; } *

user_defined_types: struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; }


FcallStmtV

decompiled_code:
__int64 __fastcall FcallStmtV(__int64 a1)
{
headPr("FcallStmt");
if ( a1 )
{
IdentV(*(_QWORD *)a1);
ArgListV(*(__int64 **)(a1 + 8));
}
return tailPr("FcallStmt");
}

canonical_decompiled_code:
__int64 __fastcall func13(__int64 a1)
{
headPr("FcallStmt");
if ( a1 )
{
func0(*(_QWORD *)a1);
func12(*(__int64 **)(a1 + 8));
}
return tailPr("FcallStmt");
}

original_code:
void FcallStmtV(FcallStmtSP t)
{
  headPr("FcallStmt");
  if (t != ((void *)0)) {
    IdentV(t->idp);
    ArgListV(t->alp);
  }
  tailPr("FcallStmt");
}

canonical_original_code:
void FcallStmtV(struct _FcallStmtS *t)
{
  headPr("FcallStmt");
  if (t != ((void *)0)) {
    IdentV(t->idp);
    ArgListV(t->alp);
  }
  tailPr("FcallStmt");
}

variable_types: struct _FcallStmtS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ArgListS { struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *ep; struct _ArgListS *next; } *alp; } *


PcallStmtV

decompiled_code:
__int64 __fastcall PcallStmtV(__int64 a1)
{
headPr("PcallStmt");
if ( a1 )
{
IdentV(*(_QWORD *)a1);
ArgListV(*(__int64 **)(a1 + 8));
}
return tailPr("PcallStmt");
}

canonical_decompiled_code:
__int64 __fastcall func14(__int64 a1)
{
headPr("PcallStmt");
if ( a1 )
{
func0(*(_QWORD *)a1);
func12(*(__int64 **)(a1 + 8));
}
return tailPr("PcallStmt");
}

original_code:
void PcallStmtV(PcallStmtSP t)
{
  headPr("PcallStmt");
  if (t != ((void *)0)) {
    IdentV(t->idp);
    ArgListV(t->alp);
  }
  tailPr("PcallStmt");
}

canonical_original_code:
void PcallStmtV(struct _PcallStmtS *t)
{
  headPr("PcallStmt");
  if (t != ((void *)0)) {
    IdentV(t->idp);
    ArgListV(t->alp);
  }
  tailPr("PcallStmt");
}

variable_types: struct _PcallStmtS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ArgListS { struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *ep; struct _ArgListS *next; } *alp; } *

user_defined_types: struct _PcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; }


FactorV

decompiled_code:
__int64 __fastcall FactorV(__int64 a1)
{
headPr("Factor");
if ( a1 )
{
switch ( *(_DWORD *)a1 )
{
case 0:
innerIdnlnPr(2LL, "type=", "Id_Factor_t");
IdentV(*(_QWORD *)(a1 + 8));
break;
case 1:
innerIdnlnPr(2LL, "type=", "Array_Factor_t");
IdentV(*(_QWORD *)(a1 + 8));
ExprV(*(_QWORD *)(a1 + 16));
break;
case 2:
innerIdnlnPr(2LL, "type=", "Unsign_Factor_t");
innerIdnPr(1LL, "usi=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 3:
innerIdnlnPr(2LL, "type=", "Expr_Factor_t");
ExprV(*(_QWORD *)(a1 + 16));
break;
case 4:
innerIdnlnPr(2LL, "type=", "Funcall_Factor_t");
FcallStmtV(*(_QWORD *)(a1 + 32));
break;
default:
fwrite("ANALYSER BUG:430\n", 1uLL, 0x11uLL, errlist);
break;
}
}
return tailPr("Factor");
}

canonical_decompiled_code:
__int64 __fastcall func15(__int64 a1)
{
headPr("Factor");
if ( a1 )
{
switch ( *(_DWORD *)a1 )
{
case 0:
innerIdnlnPr(2LL, "type=", "Id_Factor_t");
func0(*(_QWORD *)(a1 + 8));
break;
case 1:
innerIdnlnPr(2LL, "type=", "Array_Factor_t");
func0(*(_QWORD *)(a1 + 8));
func11(*(_QWORD *)(a1 + 16));
break;
case 2:
innerIdnlnPr(2LL, "type=", "Unsign_Factor_t");
innerIdnPr(1LL, "usi=");
innerIntPr(*(unsigned int *)(a1 + 24));
break;
case 3:
innerIdnlnPr(2LL, "type=", "Expr_Factor_t");
func11(*(_QWORD *)(a1 + 16));
break;
case 4:
innerIdnlnPr(2LL, "type=", "Funcall_Factor_t");
func13(*(_QWORD *)(a1 + 32));
break;
default:
fwrite("ANALYSER BUG:430\n", 1uLL, 0x11uLL, errlist);
break;
}
}
return tailPr("Factor");
}

original_code:
void FactorV(FactorSP t)
{
  headPr("Factor");
  if (t != ((void *)0)) {
    switch (t->type) {
    case Id_Factor_t:
      innerIdnlnPr(2,"type=","Id_Factor_t");
      IdentV(t->idp);
      break;
    case Array_Factor_t:
      innerIdnlnPr(2,"type=","Array_Factor_t");
      IdentV(t->idp);
      ExprV(t->ep);
      break;
    case Unsign_Factor_t:
      innerIdnlnPr(2,"type=","Unsign_Factor_t");
      innerIdnPr(1,"usi=");
      innerIntPr(t->usi);
      break;
    case Expr_Factor_t:
      innerIdnlnPr(2,"type=","Expr_Factor_t");
      ExprV(t->ep);
      break;
    case Funcall_Factor_t:
      innerIdnlnPr(2,"type=","Funcall_Factor_t");
      FcallStmtV(t->fcsp);
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:430\n");
    }
  }
  tailPr("Factor");
}

canonical_original_code:
void FactorV(struct _FactorS *t)
{
  headPr("Factor");
  if (t != ((void *)0)) {
    switch (t->type) {
    case Id_Factor_t:
      innerIdnlnPr(2,"type=","Id_Factor_t");
      IdentV(t->idp);
      break;
    case Array_Factor_t:
      innerIdnlnPr(2,"type=","Array_Factor_t");
      IdentV(t->idp);
      ExprV(t->ep);
      break;
    case Unsign_Factor_t:
      innerIdnlnPr(2,"type=","Unsign_Factor_t");
      innerIdnPr(1,"usi=");
      innerIntPr(t->usi);
      break;
    case Expr_Factor_t:
      innerIdnlnPr(2,"type=","Expr_Factor_t");
      ExprV(t->ep);
      break;
    case Funcall_Factor_t:
      innerIdnlnPr(2,"type=","Funcall_Factor_t");
      FcallStmtV(t->fcsp);
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:430\n");
    }
  }
  tailPr("Factor");
}

variable_types: struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *


AssignStmtV

decompiled_code:
__int64 __fastcall AssignStmtV(int *a1)
{
int v1; // eax
__int64 v2; // rdx
__int64 v3; // rdx

headPr("AssignStmt");
if ( a1 )
{
v1 = *a1;
if ( *a1 == 1 )
{
innerIdnlnPr(2LL, "type=", "Fun_Assgin_t");
}
else if ( v1 == 2 )
{
innerIdnlnPr(2LL, "type=", "Array_Assgin_t");
}
else if ( v1 )
{
fwrite("ANALYSER BUG:210\n", 1uLL, 0x11uLL, errlist);
}
else
{
innerIdnlnPr(2LL, "type=", "Norm_Assgin_t");
}
IdentV(*((_QWORD *)a1 + 1));
innerIdnlnPr(1LL, "**left", v2);
ExprV(*((_QWORD *)a1 + 2));
innerIdnlnPr(1LL, "**right", v3);
ExprV(*((_QWORD *)a1 + 3));
}
return tailPr("AssignStmt");
}

canonical_decompiled_code:
__int64 __fastcall func16(int *a1)
{
int v1; // eax
__int64 v2; // rdx
__int64 v3; // rdx

headPr("AssignStmt");
if ( a1 )
{
v1 = *a1;
if ( *a1 == 1 )
{
innerIdnlnPr(2LL, "type=", "Fun_Assgin_t");
}
else if ( v1 == 2 )
{
innerIdnlnPr(2LL, "type=", "Array_Assgin_t");
}
else if ( v1 )
{
fwrite("ANALYSER BUG:210\n", 1uLL, 0x11uLL, errlist);
}
else
{
innerIdnlnPr(2LL, "type=", "Norm_Assgin_t");
}
func0(*((_QWORD *)a1 + 1));
innerIdnlnPr(1LL, "**left", v2);
func11(*((_QWORD *)a1 + 2));
innerIdnlnPr(1LL, "**right", v3);
func11(*((_QWORD *)a1 + 3));
}
return tailPr("AssignStmt");
}

original_code:
void AssignStmtV(AssignStmtSP t)
{
  headPr("AssignStmt");
  if (t != ((void *)0)) {
    switch (t->type) {
    case Norm_Assgin_t:
      innerIdnlnPr(2,"type=","Norm_Assgin_t");
      break;
    case Fun_Assgin_t:
      innerIdnlnPr(2,"type=","Fun_Assgin_t");
      break;
    case Array_Assgin_t:
      innerIdnlnPr(2,"type=","Array_Assgin_t");
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:210\n");
    }
    IdentV(t->idp);
    innerIdnlnPr(1,"**left");
    ExprV(t->lep);
    innerIdnlnPr(1,"**right");
    ExprV(t->rep);
  }
  tailPr("AssignStmt");
}

canonical_original_code:
void AssignStmtV(struct _AssignStmtS *t)
{
  headPr("AssignStmt");
  if (t != ((void *)0)) {
    switch (t->type) {
    case Norm_Assgin_t:
      innerIdnlnPr(2,"type=","Norm_Assgin_t");
      break;
    case Fun_Assgin_t:
      innerIdnlnPr(2,"type=","Fun_Assgin_t");
      break;
    case Array_Assgin_t:
      innerIdnlnPr(2,"type=","Array_Assgin_t");
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:210\n");
    }
    IdentV(t->idp);
    innerIdnlnPr(1,"**left");
    ExprV(t->lep);
    innerIdnlnPr(1,"**right");
    ExprV(t->rep);
  }
  tailPr("AssignStmt");
}

variable_types: struct _AssignStmtS { enum Assgin_t { Norm_Assgin_t=0, Fun_Assgin_t=1, Array_Assgin_t=2 } type; struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; struct _ExprS *rep; } *

user_defined_types: struct _AssignStmtS { enum Assgin_t type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; }


CondV

decompiled_code:
__int64 __fastcall CondV(__int64 a1)
{
__int64 v1; // rdx
__int64 v2; // rdx

headPr("Cond");
if ( a1 )
{
switch ( *(_DWORD *)(a1 + 8) )
{
case 0:
innerIdnlnPr(2LL, "op=", "Equ_Rela_t");
break;
case 1:
innerIdnlnPr(2LL, "op=", "Neq_Rela_t");
break;
case 2:
innerIdnlnPr(2LL, "op=", "Gtt_Rela_t");
break;
case 3:
innerIdnlnPr(2LL, "op=", "Geq_Rela_t");
break;
case 4:
innerIdnlnPr(2LL, "op=", "Lst_Rela_t");
break;
case 5:
innerIdnlnPr(2LL, "op=", "Leq_Rela_t ");
break;
default:
fwrite("ANALYSER BUG:534\n", 1uLL, 0x11uLL, errlist);
break;
}
innerIdnlnPr(1LL, "**left", v1);
ExprV(*(_QWORD *)a1);
innerIdnlnPr(1LL, "**right", v2);
ExprV(*(_QWORD *)(a1 + 16));
}
return tailPr("Cond");
}

canonical_decompiled_code:
__int64 __fastcall func17(__int64 a1)
{
__int64 v1; // rdx
__int64 v2; // rdx

headPr("Cond");
if ( a1 )
{
switch ( *(_DWORD *)(a1 + 8) )
{
case 0:
innerIdnlnPr(2LL, "op=", "Equ_Rela_t");
break;
case 1:
innerIdnlnPr(2LL, "op=", "Neq_Rela_t");
break;
case 2:
innerIdnlnPr(2LL, "op=", "Gtt_Rela_t");
break;
case 3:
innerIdnlnPr(2LL, "op=", "Geq_Rela_t");
break;
case 4:
innerIdnlnPr(2LL, "op=", "Lst_Rela_t");
break;
case 5:
innerIdnlnPr(2LL, "op=", "Leq_Rela_t ");
break;
default:
fwrite("ANALYSER BUG:534\n", 1uLL, 0x11uLL, errlist);
break;
}
innerIdnlnPr(1LL, "**left", v1);
func11(*(_QWORD *)a1);
innerIdnlnPr(1LL, "**right", v2);
func11(*(_QWORD *)(a1 + 16));
}
return tailPr("Cond");
}

original_code:
void CondV(CondSP t)
{
  headPr("Cond");
  if (t != ((void *)0)) {
    switch (t->op) {
    case Equ_Rela_t:
      innerIdnlnPr(2,"op=","Equ_Rela_t");
      break;
    case Neq_Rela_t:
      innerIdnlnPr(2,"op=","Neq_Rela_t");
      break;
    case Gtt_Rela_t:
      innerIdnlnPr(2,"op=","Gtt_Rela_t");
      break;
    case Geq_Rela_t:
      innerIdnlnPr(2,"op=","Geq_Rela_t");
      break;
    case Lst_Rela_t:
      innerIdnlnPr(2,"op=","Lst_Rela_t");
      break;
    case Leq_Rela_t :
      innerIdnlnPr(2,"op=","Leq_Rela_t ");
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:534\n");
    }
    innerIdnlnPr(1,"**left");
    ExprV(t->lep);
    innerIdnlnPr(1,"**right");
    ExprV(t->rep);
  }
  tailPr("Cond");
}

canonical_original_code:
void CondV(struct _CondS *t)
{
  headPr("Cond");
  if (t != ((void *)0)) {
    switch (t->op) {
    case Equ_Rela_t:
      innerIdnlnPr(2,"op=","Equ_Rela_t");
      break;
    case Neq_Rela_t:
      innerIdnlnPr(2,"op=","Neq_Rela_t");
      break;
    case Gtt_Rela_t:
      innerIdnlnPr(2,"op=","Gtt_Rela_t");
      break;
    case Geq_Rela_t:
      innerIdnlnPr(2,"op=","Geq_Rela_t");
      break;
    case Lst_Rela_t:
      innerIdnlnPr(2,"op=","Lst_Rela_t");
      break;
    case Leq_Rela_t :
      innerIdnlnPr(2,"op=","Leq_Rela_t ");
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:534\n");
    }
    innerIdnlnPr(1,"**left");
    ExprV(t->lep);
    innerIdnlnPr(1,"**right");
    ExprV(t->rep);
  }
  tailPr("Cond");
}

variable_types: struct _CondS { struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; enum Rela_t { Equ_Rela_t=0, Neq_Rela_t=1, Gtt_Rela_t=2, Geq_Rela_t=3, Lst_Rela_t=4, Leq_Rela_t=5 } op; struct _ExprS *rep; } *

user_defined_types: struct _CondS { struct _ExprS *lep; enum Rela_t op; struct _ExprS *rep; }


WriteStmtV

decompiled_code:
__int64 __fastcall WriteStmtV(int *a1)
{
int v1; // eax

headPr("WriteStmt");
if ( a1 )
{
v1 = *a1;
if ( *a1 == 1 )
{
innerIdnlnPr(2LL, "type=", "Str_Write_t");
innerIdnPr(1LL, "string=");
innerlnPr(1LL, *((_QWORD *)a1 + 1));
}
else if ( v1 == 2 )
{
innerIdnlnPr(2LL, "type=", "Id_Write_t");
ExprV(*((_QWORD *)a1 + 2));
}
else if ( v1 )
{
fwrite("ANALYSER BUG:353\n", 1uLL, 0x11uLL, errlist);
}
else
{
innerIdnlnPr(2LL, "type=", "StrId_Write_tid");
innerIdnPr(1LL, "string=");
innerlnPr(1LL, *((_QWORD *)a1 + 1));
ExprV(*((_QWORD *)a1 + 2));
}
}
return tailPr("WriteStmt");
}

canonical_decompiled_code:
__int64 __fastcall func18(int *a1)
{
int v1; // eax

headPr("WriteStmt");
if ( a1 )
{
v1 = *a1;
if ( *a1 == 1 )
{
innerIdnlnPr(2LL, "type=", "Str_Write_t");
innerIdnPr(1LL, "string=");
innerlnPr(1LL, *((_QWORD *)a1 + 1));
}
else if ( v1 == 2 )
{
innerIdnlnPr(2LL, "type=", "Id_Write_t");
func11(*((_QWORD *)a1 + 2));
}
else if ( v1 )
{
fwrite("ANALYSER BUG:353\n", 1uLL, 0x11uLL, errlist);
}
else
{
innerIdnlnPr(2LL, "type=", "StrId_Write_tid");
innerIdnPr(1LL, "string=");
innerlnPr(1LL, *((_QWORD *)a1 + 1));
func11(*((_QWORD *)a1 + 2));
}
}
return tailPr("WriteStmt");
}

original_code:
void WriteStmtV(WriteStmtSP t)
{
  headPr("WriteStmt");
  if (t != ((void *)0)) {
    switch (t->type) {
    case Id_Write_t:
      innerIdnlnPr(2,"type=","Id_Write_t");
      ExprV(t->ep);
      break;
    case Str_Write_t:
      innerIdnlnPr(2,"type=","Str_Write_t");
      innerIdnPr(1,"string=");
      innerlnPr(1,t->sp);
      break;
    case StrId_Write_t:
      innerIdnlnPr(2,"type=","StrId_Write_tid");
      innerIdnPr(1,"string=");
      innerlnPr(1,t->sp);
      ExprV(t->ep);
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:353\n");
    }
  }
  tailPr("WriteStmt");
}

canonical_original_code:
void WriteStmtV(struct _WriteStmtS *t)
{
  headPr("WriteStmt");
  if (t != ((void *)0)) {
    switch (t->type) {
    case Id_Write_t:
      innerIdnlnPr(2,"type=","Id_Write_t");
      ExprV(t->ep);
      break;
    case Str_Write_t:
      innerIdnlnPr(2,"type=","Str_Write_t");
      innerIdnPr(1,"string=");
      innerlnPr(1,t->sp);
      break;
    case StrId_Write_t:
      innerIdnlnPr(2,"type=","StrId_Write_tid");
      innerIdnPr(1,"string=");
      innerlnPr(1,t->sp);
      ExprV(t->ep);
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:353\n");
    }
  }
  tailPr("WriteStmt");
}

variable_types: struct _WriteStmtS { enum Write_t { StrId_Write_t=0, Str_Write_t=1, Id_Write_t=2 } type; char *sp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *ep; } *

user_defined_types: struct _WriteStmtS { enum Write_t type; char *sp; struct _ExprS *ep; }

user_defined_types: struct _IdentS { enum Ident_t type; char *name; int val; int length; int line; }


StmtV

decompiled_code:
__int64 __fastcall StmtV(__int64 a1)
{
__int64 v1; // rdx

headPr("Stmt");
if ( a1 )
{
switch ( *(_DWORD *)a1 )
{
case 0:
AssignStmtV(*(int **)(a1 + 8));
break;
case 1:
IfStmtV(*(_QWORD *)(a1 + 16));
break;
case 2:
RepeStmtV(*(_QWORD *)(a1 + 24));
break;
case 3:
PcallStmtV(*(_QWORD *)(a1 + 40));
break;
case 4:
CompStmtV(*(_QWORD *)(a1 + 48));
break;
case 5:
ReadStmtV(*(__int64 **)(a1 + 56));
break;
case 6:
WriteStmtV(*(int **)(a1 + 64));
break;
case 7:
ForStmtV(*(_QWORD *)(a1 + 32));
break;
case 8:
innerIdnlnPr(1LL, "Null_Stmt_t", v1);
break;
default:
fwrite("ANALYSER BUG:192\n", 1uLL, 0x11uLL, errlist);
break;
}
}
return tailPr("Stmt");
}

canonical_decompiled_code:
__int64 __fastcall func19(__int64 a1)
{
__int64 v1; // rdx

headPr("Stmt");
if ( a1 )
{
switch ( *(_DWORD *)a1 )
{
case 0:
func16(*(int **)(a1 + 8));
break;
case 1:
func22(*(_QWORD *)(a1 + 16));
break;
case 2:
func23(*(_QWORD *)(a1 + 24));
break;
case 3:
func14(*(_QWORD *)(a1 + 40));
break;
case 4:
func21(*(_QWORD *)(a1 + 48));
break;
case 5:
func9(*(__int64 **)(a1 + 56));
break;
case 6:
func18(*(int **)(a1 + 64));
break;
case 7:
func20(*(_QWORD *)(a1 + 32));
break;
case 8:
innerIdnlnPr(1LL, "Null_Stmt_t", v1);
break;
default:
fwrite("ANALYSER BUG:192\n", 1uLL, 0x11uLL, errlist);
break;
}
}
return tailPr("Stmt");
}

original_code:
void StmtV(StmtSP t)
{
  headPr("Stmt");
  if (t != ((void *)0)) {
    switch (t->type) {
    case Assgin_Stmt_t:
      AssignStmtV(t->asp);
      break;
    case IF_Stmt_t:
      IfStmtV(t->ifp);
      break;
    case Repeat_Stmt_t:
      RepeStmtV(t->rpp);
      break;
    case For_Stmt_t:
      ForStmtV(t->frp);
      break;
    case Pcall_Stmt_t:
      PcallStmtV(t->pcp);
      break;
    case Comp_Stmt_t:
      CompStmtV(t->cpp);
      break;
    case Read_Stmt_t:
      ReadStmtV(t->rdp);
      break;
    case Write_Stmt_t:
      WriteStmtV(t->wtp);
      break;
    case Null_Stmt_t:
      innerIdnlnPr(1,"Null_Stmt_t");
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:192\n");
    }
  }
  tailPr("Stmt");
}

canonical_original_code:
void StmtV(struct _StmtS *t)
{
  headPr("Stmt");
  if (t != ((void *)0)) {
    switch (t->type) {
    case Assgin_Stmt_t:
      AssignStmtV(t->asp);
      break;
    case IF_Stmt_t:
      IfStmtV(t->ifp);
      break;
    case Repeat_Stmt_t:
      RepeStmtV(t->rpp);
      break;
    case For_Stmt_t:
      ForStmtV(t->frp);
      break;
    case Pcall_Stmt_t:
      PcallStmtV(t->pcp);
      break;
    case Comp_Stmt_t:
      CompStmtV(t->cpp);
      break;
    case Read_Stmt_t:
      ReadStmtV(t->rdp);
      break;
    case Write_Stmt_t:
      WriteStmtV(t->wtp);
      break;
    case Null_Stmt_t:
      innerIdnlnPr(1,"Null_Stmt_t");
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:192\n");
    }
  }
  tailPr("Stmt");
}

variable_types: struct _StmtS { enum Stmt_t { Assgin_Stmt_t=0, IF_Stmt_t=1, Repeat_Stmt_t=2, Pcall_Stmt_t=3, Comp_Stmt_t=4, Read_Stmt_t=5, Write_Stmt_t=6, For_Stmt_t=7, Null_Stmt_t=8 } type; struct _AssignStmtS { enum Assgin_t { Norm_Assgin_t=0, Fun_Assgin_t=1, Array_Assgin_t=2 } type; struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; struct _ExprS *rep; } *asp; struct _IfStmtS { struct _CondS { struct _ExprS *lep; enum Rela_t { Equ_Rela_t=0, Neq_Rela_t=1, Gtt_Rela_t=2, Geq_Rela_t=3, Lst_Rela_t=4, Leq_Rela_t=5 } op; struct _ExprS *rep; } *cp; struct _StmtS *tp; struct _StmtS *ep; } *ifp; struct _RepeStmtS { struct _StmtS *sp; struct _CondS *cp; } *rpp; struct _ForStmtS { enum For_t { To_For_t=0, Downto_For_t=1 } type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; struct _StmtS *sp; } *frp; struct _PcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *pcp; struct _CompStmtS { struct _StmtS *sp; struct _CompStmtS *next; } *cpp; struct _ReadStmtS { struct _IdentS *idp; struct _ReadStmtS *next; } *rdp; struct _WriteStmtS { enum Write_t { StrId_Write_t=0, Str_Write_t=1, Id_Write_t=2 } type; char *sp; struct _ExprS *ep; } *wtp; } *

user_defined_types: struct _StmtS { enum Stmt_t type; struct _AssignStmtS *asp; struct _IfStmtS *ifp; struct _RepeStmtS *rpp; struct _ForStmtS *frp; struct _PcallStmtS *pcp; struct _CompStmtS *cpp; struct _ReadStmtS *rdp; struct _WriteStmtS *wtp; }

user_defined_types: struct _IfStmtS { struct _CondS *cp; struct _StmtS *tp; struct _StmtS *ep; }

user_defined_types: struct _ForStmtS { enum For_t type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; struct _StmtS *sp; }


ForStmtV

decompiled_code:
__int64 __fastcall ForStmtV(__int64 a1)
{
__int64 v1; // rdx
__int64 v2; // rdx
__int64 v3; // rdx

headPr("ForStmt");
if ( a1 )
{
IdentV(*(_QWORD *)(a1 + 8));
if ( *(_DWORD *)a1 )
{
if ( *(_DWORD *)a1 == 1 )
innerIdnlnPr(2LL, "type=", "Downto_For_t");
else
fwrite("ANALYSER BUG:283\n", 1uLL, 0x11uLL, errlist);
}
else
{
innerIdnlnPr(2LL, "type=", "To_For_t");
}
innerIdnlnPr(1LL, "**start", v1);
ExprV(*(_QWORD *)(a1 + 16));
innerIdnlnPr(1LL, "**end", v2);
ExprV(*(_QWORD *)(a1 + 24));
innerIdnlnPr(1LL, "**do", v3);
StmtV(*(_QWORD *)(a1 + 32));
}
return tailPr("ForStmt");
}

canonical_decompiled_code:
__int64 __fastcall func20(__int64 a1)
{
__int64 v1; // rdx
__int64 v2; // rdx
__int64 v3; // rdx

headPr("ForStmt");
if ( a1 )
{
func0(*(_QWORD *)(a1 + 8));
if ( *(_DWORD *)a1 )
{
if ( *(_DWORD *)a1 == 1 )
innerIdnlnPr(2LL, "type=", "Downto_For_t");
else
fwrite("ANALYSER BUG:283\n", 1uLL, 0x11uLL, errlist);
}
else
{
innerIdnlnPr(2LL, "type=", "To_For_t");
}
innerIdnlnPr(1LL, "**start", v1);
func11(*(_QWORD *)(a1 + 16));
innerIdnlnPr(1LL, "**end", v2);
func11(*(_QWORD *)(a1 + 24));
innerIdnlnPr(1LL, "**do", v3);
func19(*(_QWORD *)(a1 + 32));
}
return tailPr("ForStmt");
}

original_code:
void ForStmtV(ForStmtSP t)
{
  headPr("ForStmt");
  if (t != ((void *)0)) {
    IdentV(t->idp);
    switch (t->type) {
    case To_For_t:
      innerIdnlnPr(2,"type=","To_For_t");
      break;
    case Downto_For_t:
      innerIdnlnPr(2,"type=","Downto_For_t");
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:283\n");
    }
    innerIdnlnPr(1,"**start");
    ExprV(t->lep);
    innerIdnlnPr(1,"**end");
    ExprV(t->rep);
    innerIdnlnPr(1,"**do");
    StmtV(t->sp);
  }
  tailPr("ForStmt");
}

canonical_original_code:
void ForStmtV(struct _ForStmtS *t)
{
  headPr("ForStmt");
  if (t != ((void *)0)) {
    IdentV(t->idp);
    switch (t->type) {
    case To_For_t:
      innerIdnlnPr(2,"type=","To_For_t");
      break;
    case Downto_For_t:
      innerIdnlnPr(2,"type=","Downto_For_t");
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:283\n");
    }
    innerIdnlnPr(1,"**start");
    ExprV(t->lep);
    innerIdnlnPr(1,"**end");
    ExprV(t->rep);
    innerIdnlnPr(1,"**do");
    StmtV(t->sp);
  }
  tailPr("ForStmt");
}

variable_types: struct _ForStmtS { enum For_t { To_For_t=0, Downto_For_t=1 } type; struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; struct _ExprS *rep; struct _StmtS { enum Stmt_t { Assgin_Stmt_t=0, IF_Stmt_t=1, Repeat_Stmt_t=2, Pcall_Stmt_t=3, Comp_Stmt_t=4, Read_Stmt_t=5, Write_Stmt_t=6, For_Stmt_t=7, Null_Stmt_t=8 } type; struct _AssignStmtS { enum Assgin_t { Norm_Assgin_t=0, Fun_Assgin_t=1, Array_Assgin_t=2 } type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; } *asp; struct _IfStmtS { struct _CondS { struct _ExprS *lep; enum Rela_t { Equ_Rela_t=0, Neq_Rela_t=1, Gtt_Rela_t=2, Geq_Rela_t=3, Lst_Rela_t=4, Leq_Rela_t=5 } op; struct _ExprS *rep; } *cp; struct _StmtS *tp; struct _StmtS *ep; } *ifp; struct _RepeStmtS { struct _StmtS *sp; struct _CondS *cp; } *rpp; struct _ForStmtS *frp; struct _PcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *pcp; struct _CompStmtS { struct _StmtS *sp; struct _CompStmtS *next; } *cpp; struct _ReadStmtS { struct _IdentS *idp; struct _ReadStmtS *next; } *rdp; struct _WriteStmtS { enum Write_t { StrId_Write_t=0, Str_Write_t=1, Id_Write_t=2 } type; char *sp; struct _ExprS *ep; } *wtp; } *sp; } *


CompStmtV

decompiled_code:
__int64 __fastcall CompStmtV(__int64 *a1)
{
__int64 *v1; // rbx

v1 = a1;
headPr("CompStmt");
if ( a1 )
{
do
{
StmtV(*v1);
v1 = (__int64 *)v1[1];
}
while ( v1 );
}
return tailPr("CompStmt");
}

canonical_decompiled_code:
__int64 __fastcall func21(__int64 *a1)
{
__int64 *v1; // rbx

v1 = a1;
headPr("CompStmt");
if ( a1 )
{
do
{
func19(*v1);
v1 = (__int64 *)v1[1];
}
while ( v1 );
}
return tailPr("CompStmt");
}

original_code:
void CompStmtV(CompStmtSP t)
{
  headPr("CompStmt");
  for (; t != ((void *)0); t = t->next) {
    StmtV(t->sp);
  }
  tailPr("CompStmt");
}

canonical_original_code:
void CompStmtV(struct _CompStmtS *t)
{
  headPr("CompStmt");
  for (; t != ((void *)0); t = t->next) {
    StmtV(t->sp);
  }
  tailPr("CompStmt");
}

variable_types: struct _CompStmtS { struct _StmtS { enum Stmt_t { Assgin_Stmt_t=0, IF_Stmt_t=1, Repeat_Stmt_t=2, Pcall_Stmt_t=3, Comp_Stmt_t=4, Read_Stmt_t=5, Write_Stmt_t=6, For_Stmt_t=7, Null_Stmt_t=8 } type; struct _AssignStmtS { enum Assgin_t { Norm_Assgin_t=0, Fun_Assgin_t=1, Array_Assgin_t=2 } type; struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; struct _ExprS *rep; } *asp; struct _IfStmtS { struct _CondS { struct _ExprS *lep; enum Rela_t { Equ_Rela_t=0, Neq_Rela_t=1, Gtt_Rela_t=2, Geq_Rela_t=3, Lst_Rela_t=4, Leq_Rela_t=5 } op; struct _ExprS *rep; } *cp; struct _StmtS *tp; struct _StmtS *ep; } *ifp; struct _RepeStmtS { struct _StmtS *sp; struct _CondS *cp; } *rpp; struct _ForStmtS { enum For_t { To_For_t=0, Downto_For_t=1 } type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; struct _StmtS *sp; } *frp; struct _PcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *pcp; struct _CompStmtS *cpp; struct _ReadStmtS { struct _IdentS *idp; struct _ReadStmtS *next; } *rdp; struct _WriteStmtS { enum Write_t { StrId_Write_t=0, Str_Write_t=1, Id_Write_t=2 } type; char *sp; struct _ExprS *ep; } *wtp; } *sp; struct _CompStmtS *next; } *

user_defined_types: struct _CompStmtS { struct _StmtS *sp; struct _CompStmtS *next; }


IfStmtV

decompiled_code:
__int64 __fastcall IfStmtV(__int64 *a1)
{
__int64 v1; // rdx
__int64 v2; // rdx

headPr("IfStmt");
if ( a1 )
{
CondV(*a1);
innerIdnlnPr(1LL, "**then", v1);
StmtV(a1[1]);
if ( a1[2] )
{
innerIdnlnPr(1LL, "**elsep", v2);
StmtV(a1[2]);
}
}
return tailPr("IfStmt");
}

canonical_decompiled_code:
__int64 __fastcall func22(__int64 *a1)
{
__int64 v1; // rdx
__int64 v2; // rdx

headPr("IfStmt");
if ( a1 )
{
func17(*a1);
innerIdnlnPr(1LL, "**then", v1);
func19(a1[1]);
if ( a1[2] )
{
innerIdnlnPr(1LL, "**elsep", v2);
func19(a1[2]);
}
}
return tailPr("IfStmt");
}

original_code:
void IfStmtV(IfStmtSP t)
{
  headPr("IfStmt");
  if (t != ((void *)0)) {
    CondV(t->cp);
    innerIdnlnPr(1,"**then");
    StmtV(t->tp);
    if (t->ep != ((void *)0)) {
      innerIdnlnPr(1,"**elsep");
      StmtV(t->ep);
    }
  }
  tailPr("IfStmt");
}

canonical_original_code:
void IfStmtV(struct _IfStmtS *t)
{
  headPr("IfStmt");
  if (t != ((void *)0)) {
    CondV(t->cp);
    innerIdnlnPr(1,"**then");
    StmtV(t->tp);
    if (t->ep != ((void *)0)) {
      innerIdnlnPr(1,"**elsep");
      StmtV(t->ep);
    }
  }
  tailPr("IfStmt");
}

variable_types: struct _IfStmtS { struct _CondS { struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; enum Rela_t { Equ_Rela_t=0, Neq_Rela_t=1, Gtt_Rela_t=2, Geq_Rela_t=3, Lst_Rela_t=4, Leq_Rela_t=5 } op; struct _ExprS *rep; } *cp; struct _StmtS { enum Stmt_t { Assgin_Stmt_t=0, IF_Stmt_t=1, Repeat_Stmt_t=2, Pcall_Stmt_t=3, Comp_Stmt_t=4, Read_Stmt_t=5, Write_Stmt_t=6, For_Stmt_t=7, Null_Stmt_t=8 } type; struct _AssignStmtS { enum Assgin_t { Norm_Assgin_t=0, Fun_Assgin_t=1, Array_Assgin_t=2 } type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; } *asp; struct _IfStmtS *ifp; struct _RepeStmtS { struct _StmtS *sp; struct _CondS *cp; } *rpp; struct _ForStmtS { enum For_t { To_For_t=0, Downto_For_t=1 } type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; struct _StmtS *sp; } *frp; struct _PcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *pcp; struct _CompStmtS { struct _StmtS *sp; struct _CompStmtS *next; } *cpp; struct _ReadStmtS { struct _IdentS *idp; struct _ReadStmtS *next; } *rdp; struct _WriteStmtS { enum Write_t { StrId_Write_t=0, Str_Write_t=1, Id_Write_t=2 } type; char *sp; struct _ExprS *ep; } *wtp; } *tp; struct _StmtS *ep; } *


RepeStmtV

decompiled_code:
__int64 __fastcall RepeStmtV(__int64 *a1)
{
__int64 v1; // rdx
__int64 v2; // rdx

headPr("RepeStmt");
if ( a1 )
{
innerIdnlnPr(1LL, "**repeat", v1);
StmtV(*a1);
innerIdnlnPr(1LL, "**until", v2);
CondV(a1[1]);
}
return tailPr("RepeStmt");
}

canonical_decompiled_code:
__int64 __fastcall func23(__int64 *a1)
{
__int64 v1; // rdx
__int64 v2; // rdx

headPr("RepeStmt");
if ( a1 )
{
innerIdnlnPr(1LL, "**repeat", v1);
func19(*a1);
innerIdnlnPr(1LL, "**until", v2);
func17(a1[1]);
}
return tailPr("RepeStmt");
}

original_code:
void RepeStmtV(RepeStmtSP t)
{
  headPr("RepeStmt");
  if (t != ((void *)0)) {
    innerIdnlnPr(1,"**repeat");
    StmtV(t->sp);
    innerIdnlnPr(1,"**until");
    CondV(t->cp);
  }
  tailPr("RepeStmt");
}

canonical_original_code:
void RepeStmtV(struct _RepeStmtS *t)
{
  headPr("RepeStmt");
  if (t != ((void *)0)) {
    innerIdnlnPr(1,"**repeat");
    StmtV(t->sp);
    innerIdnlnPr(1,"**until");
    CondV(t->cp);
  }
  tailPr("RepeStmt");
}

variable_types: struct _RepeStmtS { struct _StmtS { enum Stmt_t { Assgin_Stmt_t=0, IF_Stmt_t=1, Repeat_Stmt_t=2, Pcall_Stmt_t=3, Comp_Stmt_t=4, Read_Stmt_t=5, Write_Stmt_t=6, For_Stmt_t=7, Null_Stmt_t=8 } type; struct _AssignStmtS { enum Assgin_t { Norm_Assgin_t=0, Fun_Assgin_t=1, Array_Assgin_t=2 } type; struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; struct _ExprS *rep; } *asp; struct _IfStmtS { struct _CondS { struct _ExprS *lep; enum Rela_t { Equ_Rela_t=0, Neq_Rela_t=1, Gtt_Rela_t=2, Geq_Rela_t=3, Lst_Rela_t=4, Leq_Rela_t=5 } op; struct _ExprS *rep; } *cp; struct _StmtS *tp; struct _StmtS *ep; } *ifp; struct _RepeStmtS *rpp; struct _ForStmtS { enum For_t { To_For_t=0, Downto_For_t=1 } type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; struct _StmtS *sp; } *frp; struct _PcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *pcp; struct _CompStmtS { struct _StmtS *sp; struct _CompStmtS *next; } *cpp; struct _ReadStmtS { struct _IdentS *idp; struct _ReadStmtS *next; } *rdp; struct _WriteStmtS { enum Write_t { StrId_Write_t=0, Str_Write_t=1, Id_Write_t=2 } type; char *sp; struct _ExprS *ep; } *wtp; } *sp; struct _CondS *cp; } *

user_defined_types: struct _RepeStmtS { struct _StmtS *sp; struct _CondS *cp; }


PFDecListV

decompiled_code:
__int64 __fastcall PFDecListV(__int64 a1)
{
__int64 v1; // rbx

v1 = a1;
headPr("PFDecList");
if ( a1 )
{
do
{
if ( *(_DWORD *)v1 )
{
if ( *(_DWORD *)v1 == 1 )
ProcDecV(*(_QWORD *)(v1 + 8));
else
fwrite("ANALYSER BUG:104\n", 1uLL, 0x11uLL, errlist);
}
else
{
FunDecV(*(_QWORD *)(v1 + 16));
}
v1 = *(_QWORD *)(v1 + 24);
}
while ( v1 );
}
return tailPr("PFDecList");
}

canonical_decompiled_code:
__int64 __fastcall func24(__int64 a1)
{
__int64 v1; // rbx

v1 = a1;
headPr("PFDecList");
if ( a1 )
{
do
{
if ( *(_DWORD *)v1 )
{
if ( *(_DWORD *)v1 == 1 )
func28(*(_QWORD *)(v1 + 8));
else
fwrite("ANALYSER BUG:104\n", 1uLL, 0x11uLL, errlist);
}
else
{
func30(*(_QWORD *)(v1 + 16));
}
v1 = *(_QWORD *)(v1 + 24);
}
while ( v1 );
}
return tailPr("PFDecList");
}

original_code:
void PFDecListV(PFDecListSP t)
{
  headPr("PFDecList");
  for (; t != ((void *)0); t = t->next) {
    switch (t->type) {
    case Proc_PFDec_t:
      ProcDecV(t->pdp);
      break;
    case Fun_PFDec_t:
      FunDecV(t->fdp);
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:104\n");
    }
  }
  tailPr("PFDecList");
}

canonical_original_code:
void PFDecListV(struct _PFDecListS *t)
{
  headPr("PFDecList");
  for (; t != ((void *)0); t = t->next) {
    switch (t->type) {
    case Proc_PFDec_t:
      ProcDecV(t->pdp);
      break;
    case Fun_PFDec_t:
      FunDecV(t->fdp);
      break;
    default:
      fprintf(errlist, "ANALYSER BUG:104\n");
    }
  }
  tailPr("PFDecList");
}

variable_types: struct _PFDecListS { enum PFDec_t { Fun_PFDec_t=0, Proc_PFDec_t=1 } type; struct _ProcDecS { struct _ProcDefS { struct _ProcHeadS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ParaListS { struct _ParaDefS { struct _IdentS *idp; struct _ParaDefS *next; } *pdp; struct _ParaListS *next; } *plp; } *php; struct _BlockS { struct _ConstDecS { struct _ConstDefS { struct _IdentS *idp; } *cdp; struct _ConstDecS *next; } *cdp; struct _VarDecS { struct _VarDefS { struct _IdentS *idp; struct _VarDefS *next; } *vdp; struct _VarDecS *next; } *vdp; struct _PFDecListS *pfdlp; struct _CompStmtS { struct _StmtS { enum Stmt_t { Assgin_Stmt_t=0, IF_Stmt_t=1, Repeat_Stmt_t=2, Pcall_Stmt_t=3, Comp_Stmt_t=4, Read_Stmt_t=5, Write_Stmt_t=6, For_Stmt_t=7, Null_Stmt_t=8 } type; struct _AssignStmtS { enum Assgin_t { Norm_Assgin_t=0, Fun_Assgin_t=1, Array_Assgin_t=2 } type; struct _IdentS *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; struct _ExprS *rep; } *asp; struct _IfStmtS { struct _CondS { struct _ExprS *lep; enum Rela_t { Equ_Rela_t=0, Neq_Rela_t=1, Gtt_Rela_t=2, Geq_Rela_t=3, Lst_Rela_t=4, Leq_Rela_t=5 } op; struct _ExprS *rep; } *cp; struct _StmtS *tp; struct _StmtS *ep; } *ifp; struct _RepeStmtS { struct _StmtS *sp; struct _CondS *cp; } *rpp; struct _ForStmtS { enum For_t { To_For_t=0, Downto_For_t=1 } type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; struct _StmtS *sp; } *frp; struct _PcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *pcp; struct _CompStmtS *cpp; struct _ReadStmtS { struct _IdentS *idp; struct _ReadStmtS *next; } *rdp; struct _WriteStmtS { enum Write_t { StrId_Write_t=0, Str_Write_t=1, Id_Write_t=2 } type; char *sp; struct _ExprS *ep; } *wtp; } *sp; struct _CompStmtS *next; } *csp; } *bp; } *pdp; struct _ProcDecS *next; } *pdp; struct _FunDecS { struct _FunDefS { struct _FunHeadS { struct _IdentS *idp; struct _ParaListS *plp; } *fhp; struct _BlockS *bp; } *fdp; struct _FunDecS *next; } *fdp; struct _PFDecListS *next; } *

user_defined_types: struct _PFDecListS { enum PFDec_t type; struct _ProcDecS *pdp; struct _FunDecS *fdp; struct _PFDecListS *next; }

user_defined_types: struct _ProcDecS { struct _ProcDefS *pdp; struct _ProcDecS *next; }

user_defined_types: struct _FunDecS { struct _FunDefS *fdp; struct _FunDecS *next; }

user_defined_types: struct _ProcDefS { struct _ProcHeadS *php; struct _BlockS *bp; }

user_defined_types: struct _FunDefS { struct _FunHeadS *fhp; struct _BlockS *bp; }

user_defined_types: struct _ProcHeadS { struct _IdentS *idp; struct _ParaListS *plp; }

user_defined_types: struct _BlockS { struct _ConstDecS *cdp; struct _VarDecS *vdp; struct _PFDecListS *pfdlp; struct _CompStmtS *csp; }

user_defined_types: struct _ParaListS { struct _ParaDefS *pdp; struct _ParaListS *next; }

user_defined_types: struct _ConstDecS { struct _ConstDefS *cdp; struct _ConstDecS *next; }

user_defined_types: struct _VarDecS { struct _VarDefS *vdp; struct _VarDecS *next; }


BlockV

decompiled_code:
__int64 __fastcall BlockV(__int64 a1)
{
headPr("Block");
if ( a1 )
{
ConstDecV(*(_QWORD *)a1);
VarDecV(*(_QWORD *)(a1 + 8));
PFDecListV(*(_QWORD *)(a1 + 16));
CompStmtV(*(__int64 **)(a1 + 24));
}
return tailPr("Block");
}

original_code:
void BlockV(BlockSP t)
{
  headPr("Block");
  if (t != ((void *)0)) {
    ConstDecV(t->cdp);
    VarDecV(t->vdp);
    PFDecListV(t->pfdlp);
    CompStmtV(t->csp);
  }
  tailPr("Block");
}

canonical_original_code:
void BlockV(struct _BlockS *t)
{
  headPr("Block");
  if (t != ((void *)0)) {
    ConstDecV(t->cdp);
    VarDecV(t->vdp);
    PFDecListV(t->pfdlp);
    CompStmtV(t->csp);
  }
  tailPr("Block");
}

variable_types: struct _BlockS { struct _ConstDecS { struct _ConstDefS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; } *cdp; struct _ConstDecS *next; } *cdp; struct _VarDecS { struct _VarDefS { struct _IdentS *idp; struct _VarDefS *next; } *vdp; struct _VarDecS *next; } *vdp; struct _PFDecListS { enum PFDec_t { Fun_PFDec_t=0, Proc_PFDec_t=1 } type; struct _ProcDecS { struct _ProcDefS { struct _ProcHeadS { struct _IdentS *idp; struct _ParaListS { struct _ParaDefS { struct _IdentS *idp; struct _ParaDefS *next; } *pdp; struct _ParaListS *next; } *plp; } *php; struct _BlockS *bp; } *pdp; struct _ProcDecS *next; } *pdp; struct _FunDecS { struct _FunDefS { struct _FunHeadS { struct _IdentS *idp; struct _ParaListS *plp; } *fhp; struct _BlockS *bp; } *fdp; struct _FunDecS *next; } *fdp; struct _PFDecListS *next; } *pfdlp; struct _CompStmtS { struct _StmtS { enum Stmt_t { Assgin_Stmt_t=0, IF_Stmt_t=1, Repeat_Stmt_t=2, Pcall_Stmt_t=3, Comp_Stmt_t=4, Read_Stmt_t=5, Write_Stmt_t=6, For_Stmt_t=7, Null_Stmt_t=8 } type; struct _AssignStmtS { enum Assgin_t { Norm_Assgin_t=0, Fun_Assgin_t=1, Array_Assgin_t=2 } type; struct _IdentS *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; struct _ExprS *rep; } *asp; struct _IfStmtS { struct _CondS { struct _ExprS *lep; enum Rela_t { Equ_Rela_t=0, Neq_Rela_t=1, Gtt_Rela_t=2, Geq_Rela_t=3, Lst_Rela_t=4, Leq_Rela_t=5 } op; struct _ExprS *rep; } *cp; struct _StmtS *tp; struct _StmtS *ep; } *ifp; struct _RepeStmtS { struct _StmtS *sp; struct _CondS *cp; } *rpp; struct _ForStmtS { enum For_t { To_For_t=0, Downto_For_t=1 } type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; struct _StmtS *sp; } *frp; struct _PcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *pcp; struct _CompStmtS *cpp; struct _ReadStmtS { struct _IdentS *idp; struct _ReadStmtS *next; } *rdp; struct _WriteStmtS { enum Write_t { StrId_Write_t=0, Str_Write_t=1, Id_Write_t=2 } type; char *sp; struct _ExprS *ep; } *wtp; } *sp; struct _CompStmtS *next; } *csp; } *

user_defined_types: struct _ConstDefS { struct _IdentS *idp; }

user_defined_types: struct _AssignStmtS { enum Assgin_t type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; }

user_defined_types: struct _WriteStmtS { enum Write_t type; char *sp; struct _ExprS *ep; }

user_defined_types: struct _ExprS { enum Addop_t op; struct _TermS *tp; struct _ExprS *next; }

user_defined_types: struct _CondS { struct _ExprS *lep; enum Rela_t op; struct _ExprS *rep; }

user_defined_types: struct _TermS { enum Multop_t op; struct _FactorS *fp; struct _TermS *next; }

user_defined_types: struct _FactorS { enum Factor_t type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS *fcsp; }

user_defined_types: struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; }


PgmV

decompiled_code:
__int64 __fastcall PgmV(__int64 *a1)
{
headPr("Pgm");
if ( a1 )
BlockV(*a1);
return tailPr("Pgm");
}

canonical_decompiled_code:
__int64 __fastcall func26(__int64 *a1)
{
headPr("Pgm");
if ( a1 )
func25(*a1);
return tailPr("Pgm");
}

original_code:
void PgmV(PgmSP t)
{
  headPr("Pgm");
  if (t != ((void *)0)) {
    BlockV(t->bp);
  }
  tailPr("Pgm");
}

canonical_original_code:
void PgmV(struct _PgmS *t)
{
  headPr("Pgm");
  if (t != ((void *)0)) {
    BlockV(t->bp);
  }
  tailPr("Pgm");
}

variable_types: struct _PgmS { struct _BlockS { struct _ConstDecS { struct _ConstDefS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; } *cdp; struct _ConstDecS *next; } *cdp; struct _VarDecS { struct _VarDefS { struct _IdentS *idp; struct _VarDefS *next; } *vdp; struct _VarDecS *next; } *vdp; struct _PFDecListS { enum PFDec_t { Fun_PFDec_t=0, Proc_PFDec_t=1 } type; struct _ProcDecS { struct _ProcDefS { struct _ProcHeadS { struct _IdentS *idp; struct _ParaListS { struct _ParaDefS { struct _IdentS *idp; struct _ParaDefS *next; } *pdp; struct _ParaListS *next; } *plp; } *php; struct _BlockS *bp; } *pdp; struct _ProcDecS *next; } *pdp; struct _FunDecS { struct _FunDefS { struct _FunHeadS { struct _IdentS *idp; struct _ParaListS *plp; } *fhp; struct _BlockS *bp; } *fdp; struct _FunDecS *next; } *fdp; struct _PFDecListS *next; } *pfdlp; struct _CompStmtS { struct _StmtS { enum Stmt_t { Assgin_Stmt_t=0, IF_Stmt_t=1, Repeat_Stmt_t=2, Pcall_Stmt_t=3, Comp_Stmt_t=4, Read_Stmt_t=5, Write_Stmt_t=6, For_Stmt_t=7, Null_Stmt_t=8 } type; struct _AssignStmtS { enum Assgin_t { Norm_Assgin_t=0, Fun_Assgin_t=1, Array_Assgin_t=2 } type; struct _IdentS *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; struct _ExprS *rep; } *asp; struct _IfStmtS { struct _CondS { struct _ExprS *lep; enum Rela_t { Equ_Rela_t=0, Neq_Rela_t=1, Gtt_Rela_t=2, Geq_Rela_t=3, Lst_Rela_t=4, Leq_Rela_t=5 } op; struct _ExprS *rep; } *cp; struct _StmtS *tp; struct _StmtS *ep; } *ifp; struct _RepeStmtS { struct _StmtS *sp; struct _CondS *cp; } *rpp; struct _ForStmtS { enum For_t { To_For_t=0, Downto_For_t=1 } type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; struct _StmtS *sp; } *frp; struct _PcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *pcp; struct _CompStmtS *cpp; struct _ReadStmtS { struct _IdentS *idp; struct _ReadStmtS *next; } *rdp; struct _WriteStmtS { enum Write_t { StrId_Write_t=0, Str_Write_t=1, Id_Write_t=2 } type; char *sp; struct _ExprS *ep; } *wtp; } *sp; struct _CompStmtS *next; } *csp; } *bp; } *

user_defined_types: struct _PFDecListS { enum PFDec_t type; struct _ProcDecS *pdp; struct _FunDecS *fdp; struct _PFDecListS *next; }

user_defined_types: struct _CompStmtS { struct _StmtS *sp; struct _CompStmtS *next; }

user_defined_types: struct _ProcDecS { struct _ProcDefS *pdp; struct _ProcDecS *next; }

user_defined_types: struct _StmtS { enum Stmt_t type; struct _AssignStmtS *asp; struct _IfStmtS *ifp; struct _RepeStmtS *rpp; struct _ForStmtS *frp; struct _PcallStmtS *pcp; struct _CompStmtS *cpp; struct _ReadStmtS *rdp; struct _WriteStmtS *wtp; }

user_defined_types: struct _IdentS { enum Ident_t type; char *name; int val; int length; int line; }

user_defined_types: struct _IfStmtS { struct _CondS *cp; struct _StmtS *tp; struct _StmtS *ep; }

user_defined_types: struct _ForStmtS { enum For_t type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; struct _StmtS *sp; }


ProcDefV

decompiled_code:
__int64 __fastcall ProcDefV(__int64 a1)
{
headPr("ProcDef");
if ( a1 )
{
ProcHeadV(*(__int64 **)a1);
BlockV(*(_QWORD *)(a1 + 8));
}
return tailPr("ProcDef");
}

canonical_decompiled_code:
__int64 __fastcall func27(__int64 a1)
{
headPr("ProcDef");
if ( a1 )
{
func7(*(__int64 **)a1);
func25(*(_QWORD *)(a1 + 8));
}
return tailPr("ProcDef");
}

original_code:
void ProcDefV(ProcDefSP t)
{
  headPr("ProcDef");
  if (t != ((void *)0)) {
    ProcHeadV(t->php);
    BlockV(t->bp);
  }
  tailPr("ProcDef");
}

canonical_original_code:
void ProcDefV(struct _ProcDefS *t)
{
  headPr("ProcDef");
  if (t != ((void *)0)) {
    ProcHeadV(t->php);
    BlockV(t->bp);
  }
  tailPr("ProcDef");
}

variable_types: struct _ProcDefS { struct _ProcHeadS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ParaListS { struct _ParaDefS { struct _IdentS *idp; struct _ParaDefS *next; } *pdp; struct _ParaListS *next; } *plp; } *php; struct _BlockS { struct _ConstDecS { struct _ConstDefS { struct _IdentS *idp; } *cdp; struct _ConstDecS *next; } *cdp; struct _VarDecS { struct _VarDefS { struct _IdentS *idp; struct _VarDefS *next; } *vdp; struct _VarDecS *next; } *vdp; struct _PFDecListS { enum PFDec_t { Fun_PFDec_t=0, Proc_PFDec_t=1 } type; struct _ProcDecS { struct _ProcDefS *pdp; struct _ProcDecS *next; } *pdp; struct _FunDecS { struct _FunDefS { struct _FunHeadS { struct _IdentS *idp; struct _ParaListS *plp; } *fhp; struct _BlockS *bp; } *fdp; struct _FunDecS *next; } *fdp; struct _PFDecListS *next; } *pfdlp; struct _CompStmtS { struct _StmtS { enum Stmt_t { Assgin_Stmt_t=0, IF_Stmt_t=1, Repeat_Stmt_t=2, Pcall_Stmt_t=3, Comp_Stmt_t=4, Read_Stmt_t=5, Write_Stmt_t=6, For_Stmt_t=7, Null_Stmt_t=8 } type; struct _AssignStmtS { enum Assgin_t { Norm_Assgin_t=0, Fun_Assgin_t=1, Array_Assgin_t=2 } type; struct _IdentS *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; struct _ExprS *rep; } *asp; struct _IfStmtS { struct _CondS { struct _ExprS *lep; enum Rela_t { Equ_Rela_t=0, Neq_Rela_t=1, Gtt_Rela_t=2, Geq_Rela_t=3, Lst_Rela_t=4, Leq_Rela_t=5 } op; struct _ExprS *rep; } *cp; struct _StmtS *tp; struct _StmtS *ep; } *ifp; struct _RepeStmtS { struct _StmtS *sp; struct _CondS *cp; } *rpp; struct _ForStmtS { enum For_t { To_For_t=0, Downto_For_t=1 } type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; struct _StmtS *sp; } *frp; struct _PcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *pcp; struct _CompStmtS *cpp; struct _ReadStmtS { struct _IdentS *idp; struct _ReadStmtS *next; } *rdp; struct _WriteStmtS { enum Write_t { StrId_Write_t=0, Str_Write_t=1, Id_Write_t=2 } type; char *sp; struct _ExprS *ep; } *wtp; } *sp; struct _CompStmtS *next; } *csp; } *bp; } *

user_defined_types: struct _ProcDefS { struct _ProcHeadS *php; struct _BlockS *bp; }

user_defined_types: struct _ProcHeadS { struct _IdentS *idp; struct _ParaListS *plp; }

user_defined_types: struct _BlockS { struct _ConstDecS *cdp; struct _VarDecS *vdp; struct _PFDecListS *pfdlp; struct _CompStmtS *csp; }

user_defined_types: struct _ParaListS { struct _ParaDefS *pdp; struct _ParaListS *next; }

user_defined_types: struct _ConstDecS { struct _ConstDefS *cdp; struct _ConstDecS *next; }

user_defined_types: struct _FunDecS { struct _FunDefS *fdp; struct _FunDecS *next; }

user_defined_types: struct _FunDefS { struct _FunHeadS *fhp; struct _BlockS *bp; }


ProcDecV

decompiled_code:
__int64 __fastcall ProcDecV(__int64 *a1)
{
__int64 *v1; // rbx

v1 = a1;
headPr("ProcDec");
if ( a1 )
{
do
{
ProcDefV(*v1);
v1 = (__int64 *)v1[1];
}
while ( v1 );
}
return tailPr("ProcDec");
}

canonical_decompiled_code:
__int64 __fastcall func28(__int64 *a1)
{
__int64 *v1; // rbx

v1 = a1;
headPr("ProcDec");
if ( a1 )
{
do
{
func27(*v1);
v1 = (__int64 *)v1[1];
}
while ( v1 );
}
return tailPr("ProcDec");
}

original_code:
void ProcDecV(ProcDecSP t)
{
  headPr("ProcDec");
  for (; t != ((void *)0); t = t->next) {
    ProcDefV(t->pdp);
  }
  tailPr("ProcDec");
}

canonical_original_code:
void ProcDecV(struct _ProcDecS *t)
{
  headPr("ProcDec");
  for (; t != ((void *)0); t = t->next) {
    ProcDefV(t->pdp);
  }
  tailPr("ProcDec");
}

variable_types: struct _ProcDecS { struct _ProcDefS { struct _ProcHeadS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ParaListS { struct _ParaDefS { struct _IdentS *idp; struct _ParaDefS *next; } *pdp; struct _ParaListS *next; } *plp; } *php; struct _BlockS { struct _ConstDecS { struct _ConstDefS { struct _IdentS *idp; } *cdp; struct _ConstDecS *next; } *cdp; struct _VarDecS { struct _VarDefS { struct _IdentS *idp; struct _VarDefS *next; } *vdp; struct _VarDecS *next; } *vdp; struct _PFDecListS { enum PFDec_t { Fun_PFDec_t=0, Proc_PFDec_t=1 } type; struct _ProcDecS *pdp; struct _FunDecS { struct _FunDefS { struct _FunHeadS { struct _IdentS *idp; struct _ParaListS *plp; } *fhp; struct _BlockS *bp; } *fdp; struct _FunDecS *next; } *fdp; struct _PFDecListS *next; } *pfdlp; struct _CompStmtS { struct _StmtS { enum Stmt_t { Assgin_Stmt_t=0, IF_Stmt_t=1, Repeat_Stmt_t=2, Pcall_Stmt_t=3, Comp_Stmt_t=4, Read_Stmt_t=5, Write_Stmt_t=6, For_Stmt_t=7, Null_Stmt_t=8 } type; struct _AssignStmtS { enum Assgin_t { Norm_Assgin_t=0, Fun_Assgin_t=1, Array_Assgin_t=2 } type; struct _IdentS *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; struct _ExprS *rep; } *asp; struct _IfStmtS { struct _CondS { struct _ExprS *lep; enum Rela_t { Equ_Rela_t=0, Neq_Rela_t=1, Gtt_Rela_t=2, Geq_Rela_t=3, Lst_Rela_t=4, Leq_Rela_t=5 } op; struct _ExprS *rep; } *cp; struct _StmtS *tp; struct _StmtS *ep; } *ifp; struct _RepeStmtS { struct _StmtS *sp; struct _CondS *cp; } *rpp; struct _ForStmtS { enum For_t { To_For_t=0, Downto_For_t=1 } type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; struct _StmtS *sp; } *frp; struct _PcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *pcp; struct _CompStmtS *cpp; struct _ReadStmtS { struct _IdentS *idp; struct _ReadStmtS *next; } *rdp; struct _WriteStmtS { enum Write_t { StrId_Write_t=0, Str_Write_t=1, Id_Write_t=2 } type; char *sp; struct _ExprS *ep; } *wtp; } *sp; struct _CompStmtS *next; } *csp; } *bp; } *pdp; struct _ProcDecS *next; } *

user_defined_types: struct _VarDecS { struct _VarDefS *vdp; struct _VarDecS *next; }

user_defined_types: struct _AssignStmtS { enum Assgin_t type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; }

user_defined_types: struct _WriteStmtS { enum Write_t type; char *sp; struct _ExprS *ep; }

user_defined_types: struct _ExprS { enum Addop_t op; struct _TermS *tp; struct _ExprS *next; }

user_defined_types: struct _CondS { struct _ExprS *lep; enum Rela_t op; struct _ExprS *rep; }

user_defined_types: struct _TermS { enum Multop_t op; struct _FactorS *fp; struct _TermS *next; }


FunDefV

decompiled_code:
__int64 __fastcall FunDefV(__int64 a1)
{
headPr("FunDef");
if ( a1 )
{
FunHeadV(*(__int64 **)a1);
BlockV(*(_QWORD *)(a1 + 8));
}
return tailPr("FunDef");
}

canonical_decompiled_code:
__int64 __fastcall func29(__int64 a1)
{
headPr("FunDef");
if ( a1 )
{
func8(*(__int64 **)a1);
func25(*(_QWORD *)(a1 + 8));
}
return tailPr("FunDef");
}

original_code:
void FunDefV(FunDefSP t)
{
  headPr("FunDef");
  if (t != ((void *)0)) {
    FunHeadV(t->fhp);
    BlockV(t->bp);
  }
  tailPr("FunDef");
}

canonical_original_code:
void FunDefV(struct _FunDefS *t)
{
  headPr("FunDef");
  if (t != ((void *)0)) {
    FunHeadV(t->fhp);
    BlockV(t->bp);
  }
  tailPr("FunDef");
}

variable_types: struct _FunDefS { struct _FunHeadS { struct _IdentS { enum Ident_t { Init_Ident_t=0, Proc_Ident_t=1, Int_Fun_Ident_t=2, Char_Fun_Ident_t=3, Int_Const_Ident_t=4, Char_Const_Ident_t=5, Int_Var_Ident_t=6, Char_Var_Ident_t=7, IntArr_Var_Ident_t=8, CharArr_Var_Ident_t=9, Int_Para_Val_Ident_t=10, Char_Para_Val_Ident_t=11, Int_Para_Ref_Ident_t=12, Char_Para_Ref_Ident_t=13 } type; char *name; int val; int length; int line; } *idp; struct _ParaListS { struct _ParaDefS { struct _IdentS *idp; struct _ParaDefS *next; } *pdp; struct _ParaListS *next; } *plp; } *fhp; struct _BlockS { struct _ConstDecS { struct _ConstDefS { struct _IdentS *idp; } *cdp; struct _ConstDecS *next; } *cdp; struct _VarDecS { struct _VarDefS { struct _IdentS *idp; struct _VarDefS *next; } *vdp; struct _VarDecS *next; } *vdp; struct _PFDecListS { enum PFDec_t { Fun_PFDec_t=0, Proc_PFDec_t=1 } type; struct _ProcDecS { struct _ProcDefS { struct _ProcHeadS { struct _IdentS *idp; struct _ParaListS *plp; } *php; struct _BlockS *bp; } *pdp; struct _ProcDecS *next; } *pdp; struct _FunDecS { struct _FunDefS *fdp; struct _FunDecS *next; } *fdp; struct _PFDecListS *next; } *pfdlp; struct _CompStmtS { struct _StmtS { enum Stmt_t { Assgin_Stmt_t=0, IF_Stmt_t=1, Repeat_Stmt_t=2, Pcall_Stmt_t=3, Comp_Stmt_t=4, Read_Stmt_t=5, Write_Stmt_t=6, For_Stmt_t=7, Null_Stmt_t=8 } type; struct _AssignStmtS { enum Assgin_t { Norm_Assgin_t=0, Fun_Assgin_t=1, Array_Assgin_t=2 } type; struct _IdentS *idp; struct _ExprS { enum Addop_t { Nop_Addop_t=0, Add_Addop_t=1, Neg_Addop_t=2, Minus_Addop_t=3 } op; struct _TermS { enum Multop_t { Nop_Multop_t=0, Mult_Multop_t=1, Div_Multop_t=2 } op; struct _FactorS { enum Factor_t { Id_Factor_t=0, Array_Factor_t=1, Unsign_Factor_t=2, Expr_Factor_t=3, Funcall_Factor_t=4 } type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS { struct _ExprS *ep; struct _ArgListS *next; } *alp; } *fcsp; } *fp; struct _TermS *next; } *tp; struct _ExprS *next; } *lep; struct _ExprS *rep; } *asp; struct _IfStmtS { struct _CondS { struct _ExprS *lep; enum Rela_t { Equ_Rela_t=0, Neq_Rela_t=1, Gtt_Rela_t=2, Geq_Rela_t=3, Lst_Rela_t=4, Leq_Rela_t=5 } op; struct _ExprS *rep; } *cp; struct _StmtS *tp; struct _StmtS *ep; } *ifp; struct _RepeStmtS { struct _StmtS *sp; struct _CondS *cp; } *rpp; struct _ForStmtS { enum For_t { To_For_t=0, Downto_For_t=1 } type; struct _IdentS *idp; struct _ExprS *lep; struct _ExprS *rep; struct _StmtS *sp; } *frp; struct _PcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; } *pcp; struct _CompStmtS *cpp; struct _ReadStmtS { struct _IdentS *idp; struct _ReadStmtS *next; } *rdp; struct _WriteStmtS { enum Write_t { StrId_Write_t=0, Str_Write_t=1, Id_Write_t=2 } type; char *sp; struct _ExprS *ep; } *wtp; } *sp; struct _CompStmtS *next; } *csp; } *bp; } *

user_defined_types: struct _FunHeadS { struct _IdentS *idp; struct _ParaListS *plp; }

user_defined_types: struct _PFDecListS { enum PFDec_t type; struct _ProcDecS *pdp; struct _FunDecS *fdp; struct _PFDecListS *next; }

user_defined_types: struct _CompStmtS { struct _StmtS *sp; struct _CompStmtS *next; }

user_defined_types: struct _ProcDecS { struct _ProcDefS *pdp; struct _ProcDecS *next; }

user_defined_types: struct _StmtS { enum Stmt_t type; struct _AssignStmtS *asp; struct _IfStmtS *ifp; struct _RepeStmtS *rpp; struct _ForStmtS *frp; struct _PcallStmtS *pcp; struct _CompStmtS *cpp; struct _ReadStmtS *rdp; struct _WriteStmtS *wtp; }

user_defined_types: struct _FactorS { enum Factor_t type; struct _IdentS *idp; struct _ExprS *ep; int usi; struct _FcallStmtS *fcsp; }

user_defined_types: struct _FcallStmtS { struct _IdentS *idp; struct _ArgListS *alp; }