LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CoinXu[P]reviser-compiler/src/compiler/code_generator.cpp
// Function: reviser::compiler::CodeGenerator::Generate[abi:cxx11]()
string CodeGenerator::Generate() {
    string code;
    for (StmtSeqItem it: seq) {
      switch(it.type) {
        case STMT_TYPE_STRUCT:
          code += StmtStruct(structures.at(it.index));
          break;

        case STMT_TYPE_ENUM:
          code += StmtEnum(enums.at(it.index));
          break;

        default:
          break;
      }
    }

    return code;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x99650
movq -0x98(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb7470
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb74a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb74d0
testb $0x1, %al
jne 0xb6ee7
jmp 0xb7031
leaq -0x28(%rbp), %rdi
callq 0xb7510
movups (%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0xac(%rbp)
testl %eax, %eax
je 0xb6fa2
jmp 0xb6f0a
movl -0xac(%rbp), %eax
subl $0x1, %eax
jne 0xb701f
jmp 0xb6f1b
movq -0x98(%rbp), %rdi
addq $0x20, %rdi
movq -0x38(%rbp), %rsi
callq 0xb7530
movq %rax, -0xb8(%rbp)
jmp 0xb6f38
movq -0x98(%rbp), %rsi
movq -0xb8(%rbp), %rax
movq (%rax), %rdx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x60(%rbp), %rdi
callq *%rax
jmp 0xb6f57
movq -0xa8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x995d0
jmp 0xb6f69
leaq -0x60(%rbp), %rdi
callq 0x992c0
jmp 0xb7021
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xb7057
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x992c0
jmp 0xb7057
movq -0x98(%rbp), %rdi
addq $0x38, %rdi
movq -0x38(%rbp), %rsi
callq 0xb7570
movq %rax, -0xc0(%rbp)
jmp 0xb6fbf
movq -0x98(%rbp), %rsi
movq -0xc0(%rbp), %rax
movq (%rax), %rdx
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x90(%rbp), %rdi
callq *%rax
jmp 0xb6fe2
movq -0xa8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x995d0
jmp 0xb6ff7
leaq -0x90(%rbp), %rdi
callq 0x992c0
jmp 0xb7021
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x992c0
jmp 0xb7057
jmp 0xb7021
jmp 0xb7023
leaq -0x28(%rbp), %rdi
callq 0xb75b0
jmp 0xb6ed1
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xb7047
movq -0xa8(%rbp), %rdi
callq 0x992c0
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x992c0
movq -0x68(%rbp), %rdi
callq 0x99840
nopl (%rax)
// File: CoinXu[P]reviser-compiler/src/compiler/code_generator.cpp
// Function: reviser::compiler::CodeGenerator::IncludeArrayType()
bool CodeGenerator::IncludeArrayType() {
    vector<Struct*> structs(structures.begin(), structures.end());

    for (Struct* s: structs) {
      for (StructProperty* p: s->properties) {
        if (p->declare->array_type) {
          return true;
        }
      }

      if (s->structs.size() > 0) {
        structs.insert(structs.end(), s->structs.begin(), s->structs.end());
      }
    }

    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0xd0(%rbp)
callq 0xb6290
movq -0xd0(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0xb6120
movq %rax, -0x38(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xb4920
movq -0xc8(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0xb75d0
jmp 0xb71d1
leaq -0x39(%rbp), %rdi
callq 0xb4e10
leaq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0xb6290
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0xb6120
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb7650
testb $0x1, %al
jne 0xb7212
jmp 0xb7389
leaq -0x60(%rbp), %rdi
callq 0xb7690
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0xb5c00
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0xb5a90
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xb76b0
testb $0x1, %al
jne 0xb7261
jmp 0xb72bf
leaq -0x80(%rbp), %rdi
callq 0xb76f0
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq 0x48(%rax), %rax
testb $0x1, 0x4(%rax)
je 0xb72b2
movb $0x1, -0x1(%rbp)
movl $0x1, -0x94(%rbp)
jmp 0xb7397
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xb4e10
jmp 0xb73ae
jmp 0xb72b4
leaq -0x80(%rbp), %rdi
callq 0xb7710
jmp 0xb724b
movq -0x70(%rbp), %rdi
addq $0x50, %rdi
callq 0xb4700
cmpq $0x0, %rax
jbe 0xb7379
leaq -0x28(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xb6120
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xb77e0
movq -0x70(%rbp), %rdi
addq $0x50, %rdi
callq 0xb6290
movq %rax, -0xb0(%rbp)
movq -0x70(%rbp), %rdi
addq $0x50, %rdi
callq 0xb6120
movq -0xe0(%rbp), %rdi
movq %rax, -0xb8(%rbp)
movq -0xa0(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq -0xb8(%rbp), %rcx
callq 0xb7730
movq %rax, -0xd8(%rbp)
jmp 0xb7352
movq -0xd8(%rbp), %rax
movq %rax, -0xc0(%rbp)
jmp 0xb7379
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb4580
jmp 0xb73ae
jmp 0xb737b
leaq -0x60(%rbp), %rdi
callq 0xb7820
jmp 0xb71fc
movb $0x0, -0x1(%rbp)
movl $0x1, -0x94(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb4580
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x99840
nopw (%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/compiler/descriptor.cpp
// Function: reviser::compiler::Descriptor::FindContextVariableById(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Descriptor::ContextVariable* Descriptor::FindContextVariableById(string id) {
    if (context.size() < 1) {
      return nullptr;
    }

    for (int i = context.size() - 1; i >= 0; i--) {
      vector<ContextVariable> v = context.at(i);
      if (v.size() < 1) {
        continue;
      }

      for (int j = v.size() - 1; j >= 0; j--) {
        if (v.at(j).id == id) {
          return &v.at(j);
        }
      }
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x48, %rdi
callq 0xbd760
cmpq $0x1, %rax
jae 0xbccab
movq $0x0, -0x8(%rbp)
jmp 0xbcdc5
movq -0x58(%rbp), %rdi
addq $0x48, %rdi
callq 0xbd760
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xbcdbd
movq -0x58(%rbp), %rdi
addq $0x48, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xbd790
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0xbd7d0
leaq -0x38(%rbp), %rdi
callq 0xbd8c0
cmpq $0x1, %rax
jae 0xbcd01
movl $0x4, -0x3c(%rbp)
jmp 0xbcd8c
leaq -0x38(%rbp), %rdi
callq 0xbd8c0
subq $0x1, %rax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jl 0xbcd85
movslq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xbd8f0
movq %rax, -0x68(%rbp)
jmp 0xbcd2a
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0xa4830
testb $0x1, %al
jne 0xbcd3d
jmp 0xbcd78
movslq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xbd8f0
movq %rax, -0x70(%rbp)
jmp 0xbcd50
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0xbcd8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbd620
jmp 0xbcdd2
jmp 0xbcd7a
movl -0x40(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xbcd11
movl $0x0, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbd620
movl -0x3c(%rbp), %eax
movl %eax, -0x74(%rbp)
testl %eax, %eax
je 0xbcdad
jmp 0xbcda1
movl -0x74(%rbp), %eax
subl $0x1, %eax
je 0xbcdc5
jmp 0xbcdab
jmp 0xbcdaf
jmp 0xbcdaf
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbccbf
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x99840
nopl (%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/compiler/descriptor.cpp
// Function: reviser::compiler::Descriptor::FindCurrentContextVariableById(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Descriptor::ContextVariable* Descriptor::FindCurrentContextVariableById(string id) {
    if (context.size() < 1) {
      return nullptr;
    }

    vector<ContextVariable> v = context.back();
    for (int i = v.size() - 1; i >= 0; i--) {
      if (v.at(i).id == id) {
        return &v.at(i);
      }
    }

    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x48, %rdi
callq 0xbd760
cmpq $0x1, %rax
jae 0xbce18
movq $0x0, -0x8(%rbp)
jmp 0xbcecd
movq -0x50(%rbp), %rdi
addq $0x48, %rdi
callq 0xbd6d0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0xbd7d0
leaq -0x30(%rbp), %rdi
callq 0xbd8c0
subq $0x1, %rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0xbceb5
movslq -0x34(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xbd8f0
movq %rax, -0x60(%rbp)
jmp 0xbce5a
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0xa4830
testb $0x1, %al
jne 0xbce6d
jmp 0xbcea8
movslq -0x34(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xbd8f0
movq %rax, -0x68(%rbp)
jmp 0xbce80
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xbcec4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbd620
jmp 0xbced7
jmp 0xbceaa
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xbce41
movq $0x0, -0x8(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbd620
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x99840
// File: CoinXu[P]reviser-compiler/src/compiler/descriptor.cpp
// Function: reviser::compiler::Descriptor::FindContextVariableTypeById(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
DeclareType Descriptor::FindContextVariableTypeById(string id) {
    ContextVariable* variable = FindContextVariableById(id);
    if (!variable) {
      return DECLARE_UNDEFINED;
    }

    return variable->type;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x991c0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xbcc70
movq %rax, -0x58(%rbp)
jmp 0xbcf18
leaq -0x40(%rbp), %rdi
callq 0x992c0
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbcf50
movl $0x2, -0x4(%rbp)
jmp 0xbcf5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x992c0
jmp 0xbcf63
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x99840
nopl (%rax)
// File: CoinXu[P]reviser-compiler/src/compiler/descriptor.cpp
// Function: reviser::compiler::Descriptor::FindEnumContextVariableById(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Enum* Descriptor::FindEnumContextVariableById(string id) {
    ContextVariable* variable = FindContextVariableById(id);
    if (!variable) {
      return nullptr;
    }

    if (variable->type == DECLARE_ENUM) {
      return variable->node.e;
    }

    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x991c0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xbcc70
movq %rax, -0x58(%rbp)
jmp 0xbcfa8
leaq -0x40(%rbp), %rdi
callq 0x992c0
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbcfe1
movq $0x0, -0x8(%rbp)
jmp 0xbd001
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x992c0
jmp 0xbd00b
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xbcff9
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xbd001
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x99840
nopw %cs:(%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/compiler/descriptor.cpp
// Function: reviser::compiler::Descriptor::EnumInlcudeProperty(reviser::ast::Enum*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Descriptor::EnumInlcudeProperty(Enum* e, string name) {
    if (!e) {
      return false;
    }

    for (auto item : e->properties) {
      if (item->id->text == name) {
        return true;
      }
    }

    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbd045
movb $0x0, -0x1(%rbp)
jmp 0xbd0c0
movq -0x18(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xad7c0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xad650
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xbd930
testb $0x1, %al
jne 0xbd07e
jmp 0xbd0bc
leaq -0x30(%rbp), %rdi
callq 0xbd970
movq -0x48(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rdi
addq $0x8, %rdi
callq 0xa4830
testb $0x1, %al
jne 0xbd0a9
jmp 0xbd0af
movb $0x1, -0x1(%rbp)
jmp 0xbd0c0
jmp 0xbd0b1
leaq -0x30(%rbp), %rdi
callq 0xbd990
jmp 0xbd06b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/compiler/descriptor.cpp
// Function: reviser::compiler::Descriptor::FindStructContextVariableById(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Struct* Descriptor::FindStructContextVariableById(string id) {
    ContextVariable* variable = FindContextVariableById(id);
    if (!variable) {
      return nullptr;
    }

    if (variable->type == DECLARE_STRUCT) {
      return variable->node.s;
    }

    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x991c0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xbcc70
movq %rax, -0x58(%rbp)
jmp 0xbd108
leaq -0x40(%rbp), %rdi
callq 0x992c0
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbd141
movq $0x0, -0x8(%rbp)
jmp 0xbd161
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x992c0
jmp 0xbd16b
movq -0x20(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0xbd159
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xbd161
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x99840
nopw %cs:(%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/compiler/descriptor.cpp
// Function: reviser::compiler::Descriptor::StructIncludeProperty(reviser::ast::Struct*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Descriptor::StructIncludeProperty(Struct* s, string id) {
    if (!s) {
      return false;
    }

    for (auto item : s->properties) {
      if (item->declare->id->text == id) {
        return true;
      }
    }

    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbd1a5
movb $0x0, -0x1(%rbp)
jmp 0xbd224
movq -0x18(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb5c00
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb5a90
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb76b0
testb $0x1, %al
jne 0xbd1de
jmp 0xbd220
leaq -0x30(%rbp), %rdi
callq 0xb76f0
movq -0x48(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rdi
callq 0xa4830
testb $0x1, %al
jne 0xbd20d
jmp 0xbd213
movb $0x1, -0x1(%rbp)
jmp 0xbd224
jmp 0xbd215
leaq -0x30(%rbp), %rdi
callq 0xb7710
jmp 0xbd1cb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: CoinXu[P]reviser-compiler/src/compiler/descriptor.cpp
// Function: reviser::compiler::Descriptor::AddGlobalVariableOnce(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, reviser::compiler::DeclareType)
void Descriptor::AddGlobalVariableOnce(string variable, DeclareType type) {
    for (auto it: global_variables_) {
      if (it.id == variable) {
        return;
      }
    }
    global_variables_.push_back({ variable, type });
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbdd40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbdd70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbdda0
testb $0x1, %al
jne 0xbd35d
jmp 0xbd3b9
leaq -0x28(%rbp), %rdi
callq 0xbdde0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0xbde00
movq -0xa8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xa4830
testb $0x1, %al
jne 0xbd388
jmp 0xbd391
movl $0x1, -0x5c(%rbp)
jmp 0xbd398
movl $0x0, -0x5c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xbde40
movl -0x5c(%rbp), %eax
testl %eax, %eax
je 0xbd3ac
jmp 0xbd3aa
jmp 0xbd40c
jmp 0xbd3ae
leaq -0x28(%rbp), %rdi
callq 0xbde60
jmp 0xbd34a
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xb8(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x991c0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, -0x68(%rbp)
callq 0xbde80
jmp 0xbd400
leaq -0x88(%rbp), %rdi
callq 0xbde40
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xbde40
movq -0x90(%rbp), %rdi
callq 0x99840
nop
// File: CoinXu[P]reviser-compiler/src/compiler/descriptor.cpp
// Function: bool reviser::compiler::VectorIncludeItem<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*)
bool VectorIncludeItem(vector<T>* v, const T* item) {
    for (auto it: *v) {
      if (it == *item) {
        return true;
      }
    }
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa3540
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa33c0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xafc80
testb $0x1, %al
jne 0xbdcc5
jmp 0xbdd22
leaq -0x28(%rbp), %rdi
callq 0xb3150
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0x991c0
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa4830
testb $0x1, %al
jne 0xbdced
jmp 0xbdcfa
movb $0x1, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0xbdd01
movl $0x0, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x992c0
movl -0x54(%rbp), %eax
testl %eax, %eax
je 0xbdd15
jmp 0xbdd13
jmp 0xbdd26
jmp 0xbdd17
leaq -0x28(%rbp), %rdi
callq 0xb3130
jmp 0xbdcb2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/io/path.cpp
// Function: reviser::io::join(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string join(const string& a, const string& b) {
    string temp_a = a;
    string temp_b = b;
    if (temp_a.back() != separator) {
      temp_a += separator;
    }

    if (temp_b.front() != separator) {
      temp_b = separator + temp_b;
    }

    return normalize(temp_a + temp_b);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x991c0
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x991c0
jmp 0xc2064
leaq -0x38(%rbp), %rdi
callq 0x99370
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0xc20a9
leaq -0x38(%rbp), %rdi
movl $0x2f, %esi
callq 0x992e0
jmp 0xc2085
jmp 0xc20a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xc2167
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xc215e
leaq -0x58(%rbp), %rdi
callq 0x99100
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0xc20ed
leaq -0x88(%rbp), %rdi
movl $0x2f, %esi
leaq -0x58(%rbp), %rdx
callq 0xc24f0
jmp 0xc20d1
leaq -0x58(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x99590
leaq -0x88(%rbp), %rdi
callq 0x992c0
leaq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0xc25f0
jmp 0xc2103
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xc2180
jmp 0xc2118
leaq -0xa8(%rbp), %rdi
callq 0x992c0
leaq -0x58(%rbp), %rdi
callq 0x992c0
leaq -0x38(%rbp), %rdi
callq 0x992c0
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x992c0
leaq -0x58(%rbp), %rdi
callq 0x992c0
leaq -0x38(%rbp), %rdi
callq 0x992c0
movq -0x60(%rbp), %rdi
callq 0x99840
nopl (%rax)
// File: CoinXu[P]reviser-compiler/src/io/path.cpp
// Function: reviser::io::normalize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string normalize(const string& path) {
    string result = path;
    size_t index = 0;
    while (index < result.length()) {
      if (result[index] == separator && result[index + 1] == separator) {
        result.erase(index, 1);
        continue;
      }
      index++;
    }

    if (result.back() == separator) {
      result.erase(result.length() - 1, 1);
    }

    return result;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x991c0
movq $0x0, -0x20(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x996f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0xc224c
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x998f0
movq %rax, -0x50(%rbp)
jmp 0xc21e0
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xc223b
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x998f0
movq %rax, -0x58(%rbp)
jmp 0xc2202
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xc223b
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x990d0
jmp 0xc2222
jmp 0xc21b0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x992c0
jmp 0xc229b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xc21b0
movq -0x40(%rbp), %rdi
callq 0x99370
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xc227e
movq -0x40(%rbp), %rdi
callq 0x996f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
decq %rsi
movl $0x1, %edx
callq 0x990d0
jmp 0xc227c
jmp 0xc227e
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xc2291
movq -0x40(%rbp), %rdi
callq 0x992c0
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x99840
nopw %cs:(%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/io/path.cpp
// Function: reviser::io::is_dir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool is_dir(const string& path) {
    if (path.size() == 0) {
      return false;
    }

    struct stat s;
    if (stat(path.c_str(), &s) == -1) {
      return false;
    }

    return s.st_mode & S_IFDIR;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x99350
cmpq $0x0, %rax
jne 0xc23b4
movb $0x0, -0x1(%rbp)
jmp 0xc23ed
movq -0x10(%rbp), %rdi
callq 0x991a0
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x99420
cmpl $-0x1, %eax
jne 0xc23d7
movb $0x0, -0x1(%rbp)
jmp 0xc23ed
movl -0x88(%rbp), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/io/path.cpp
// Function: reviser::io::mkdir_parents(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
bool mkdir_parents(const string& path, int mode) {
    int size = 0;
    string current;
    while (size < path.size()) {
      current.push_back(path[size++]);
      if (current.back() == separator) {
        if (!is_dir(current)) {
          if (mkdir(current.c_str(), mode) == -1) {
            return false;
          }
        }
      }
    }

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x99650
movslq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x99350
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0xc24c6
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
movl %esi, %eax
incl %eax
movl %eax, -0x18(%rbp)
callq 0x99510
movsbl (%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0x993e0
jmp 0xc2462
leaq -0x38(%rbp), %rdi
callq 0x99370
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xc24c1
leaq -0x38(%rbp), %rdi
callq 0xc2390
testb $0x1, %al
jne 0xc24bf
leaq -0x38(%rbp), %rdi
callq 0x991a0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x99200
cmpl $-0x1, %eax
jne 0xc24bd
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xc24d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x992c0
jmp 0xc24e5
jmp 0xc24bf
jmp 0xc24c1
jmp 0xc241f
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x992c0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x99840
nop
// File: CoinXu[P]reviser-compiler/src/io/printer_file.cpp
// Function: reviser::io::PrinterFile::PrinterFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
PrinterFile::PrinterFile(std::string path): path(path) {
    mkdir_parents(path);
    stream.open(path, std::ios::out | std::ios::trunc);
    if (!stream.is_open()) {
      throw std::runtime_error("not found file in path [" + path + "]");
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xeb1e0
movq -0x80(%rbp), %rdi
leaq 0x44ce1(%rip), %rax     # 0x12fc50
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x88(%rbp)
callq 0x997e0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
addq $0x208, %rdi            # imm = 0x208
movq %rdi, -0x70(%rbp)
callq 0x991c0
jmp 0xeaf9c
movq -0x78(%rbp), %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0xc2400
jmp 0xeafac
movq -0x80(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x98(%rbp)
movl $0x10, %edi
movl $0x20, %esi
callq 0xeb200
movl %eax, -0x8c(%rbp)
jmp 0xeafd2
movl -0x8c(%rbp), %edx
movq -0x78(%rbp), %rsi
movq -0x98(%rbp), %rdi
callq 0x99220
jmp 0xeafea
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0x99390
movb %al, -0x99(%rbp)
jmp 0xeafff
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0xeb0f1
jmp 0xeb00f
movb $0x1, -0x61(%rbp)
movl $0x10, %edi
callq 0x99230
movq -0x78(%rbp), %rdx
movq %rax, -0xa8(%rbp)
leaq 0x1597a(%rip), %rsi     # 0x1009a9
leaq -0x60(%rbp), %rdi
callq 0xa6e30
jmp 0xeb03a
leaq 0x15a41(%rip), %rdx     # 0x100a82
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa10c0
jmp 0xeb050
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x99760
jmp 0xeb062
movq -0xa8(%rbp), %rdi
movb $0x0, -0x61(%rbp)
movq 0x44f74(%rip), %rsi     # 0x12ffe8
movq 0x44f05(%rip), %rdx     # 0x12ff80
callq 0x997f0
jmp 0xeb118
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xeb103
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xeb0fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xeb0db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xeb0d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x992c0
leaq -0x60(%rbp), %rdi
callq 0x992c0
testb $0x1, -0x61(%rbp)
jne 0xeb0e3
jmp 0xeb0ef
movq -0xa8(%rbp), %rdi
callq 0x99380
jmp 0xeb0fa
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x992c0
movq -0x88(%rbp), %rdi
callq 0x996e0
movq -0x18(%rbp), %rdi
callq 0x99840
nopl (%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/compiler/javascript/javascript_common.h
// Function: reviser::javascript::JavaScriptCommon::Indent[abi:cxx11](int)
const static string Indent(int level) {
      string s;
      for (int i = 0; i < level * IndentSize; i++) {
        s = s + " ";
      }
      return s;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x99650
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0xeba44
movq -0x58(%rbp), %rsi
leaq 0x13e5a(%rip), %rdx     # 0xff85b
leaq -0x38(%rbp), %rdi
callq 0xaaee0
jmp 0xeba0c
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x99590
leaq -0x38(%rbp), %rdi
callq 0x992c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xeb9ea
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x992c0
jmp 0xeba61
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0xeba57
movq -0x58(%rbp), %rdi
callq 0x992c0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x99840
nopw (%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/compiler/javascript/javascript_common.h
// Function: reviser::javascript::JavaScriptCommon::JoinVector(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
const static string JoinVector(vector<string> v, string separator) {
      string result;

      for (vector<string>::const_iterator it = begin(v); it != end(v); it++) {
        result += *it;
        if (next(it) != end(v)) {
          result += separator;
        }
      }

      return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x90(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x99650
movq -0x78(%rbp), %rdi
callq 0xafc20
movq %rax, -0x70(%rbp)
jmp 0xecb78
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xecd90
movq -0x78(%rbp), %rdi
callq 0xafc50
movq %rax, -0x98(%rbp)
jmp 0xecb9f
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xecdd0
testb $0x1, %al
jne 0xecbc0
jmp 0xecc7b
leaq -0x28(%rbp), %rdi
callq 0xc0300
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x995d0
jmp 0xecbda
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movl $0x1, %esi
callq 0xece10
movq %rax, -0xa0(%rbp)
jmp 0xecbf9
movq -0x78(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0xafc50
movq %rax, -0xa8(%rbp)
jmp 0xecc16
movq -0xa8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xecdd0
testb $0x1, %al
jne 0xecc34
jmp 0xecc65
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x995d0
jmp 0xecc49
jmp 0xecc65
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x992c0
jmp 0xecc9e
jmp 0xecc67
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0xece40
movq %rax, -0x68(%rbp)
jmp 0xecb8d
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xecc91
movq -0x88(%rbp), %rdi
callq 0x992c0
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x99840
nopw (%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/compiler/javascript/javascript_common.h
// Function: reviser::javascript::JavaScriptCommon::FindReviserSyntaxDefinitionByDataType(reviser::compiler::DataType)
const static vector<ReviserSyntaxDefinition> FindReviserSyntaxDefinitionByDataType(DataType type) {
      vector<ReviserSyntaxDefinition> defs;

      if (JavaScriptDataTypeReviserMap.find(type) == JavaScriptDataTypeReviserMap.end()) {
        return defs;
      }

      for (ReviserType t : JavaScriptDataTypeReviserMap.at(type)) {
        if (ReviserMethodMap.find(t) != ReviserMethodMap.end()) {
          defs.push_back(ReviserMethodMap.at(t));
        }
      }

      return defs;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0xf0080
leaq 0x41f0b(%rip), %rdi     # 0x130de8
leaq -0xc(%rbp), %rsi
callq 0xf00d0
movq %rax, -0x70(%rbp)
jmp 0xeeeec
movq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x41eed(%rip), %rdi     # 0x130de8
callq 0xf0100
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xf00a0
testb $0x1, %al
jne 0xeef17
jmp 0xeef41
movb $0x1, -0xd(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0xef032
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xef2b0
jmp 0xef04e
leaq 0x41ea0(%rip), %rdi     # 0x130de8
leaq -0xc(%rbp), %rsi
callq 0xf0130
movq %rax, -0x88(%rbp)
jmp 0xeef5a
movq -0x88(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xf01d0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0xf0200
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xf0230
testb $0x1, %al
jne 0xeef95
jmp 0xef027
leaq -0x48(%rbp), %rdi
callq 0xf0270
movl (%rax), %eax
movl %eax, -0x54(%rbp)
leaq 0x41c96(%rip), %rdi     # 0x130c40
leaq -0x54(%rbp), %rsi
callq 0xf02c0
movq %rax, -0x90(%rbp)
jmp 0xeefbc
movq -0x90(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x41c72(%rip), %rdi     # 0x130c40
callq 0xf02f0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xf0290
testb $0x1, %al
jne 0xeefea
jmp 0xef017
leaq 0x41c4f(%rip), %rdi     # 0x130c40
leaq -0x54(%rbp), %rsi
callq 0xf0390
movq %rax, -0x98(%rbp)
jmp 0xef003
movq -0x98(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0xf0320
jmp 0xef015
jmp 0xef017
jmp 0xef019
leaq -0x48(%rbp), %rdi
callq 0xf0430
jmp 0xeef7f
movb $0x1, -0xd(%rbp)
movl $0x1, -0x34(%rbp)
testb $0x1, -0xd(%rbp)
jne 0xef041
movq -0x80(%rbp), %rdi
callq 0xef2b0
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x99840
nopw (%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/compiler/javascript/javascript_struct.cpp
// Function: reviser::javascript::JavaScriptDecorater::Generate[abi:cxx11]()
string JavaScriptDecorater::Generate() {
    if (ReviserSyntaxBuildIn.find(node->id->text) == ReviserSyntaxBuildIn.end()) {
      return "";
    }

    return JavaScriptCommon::Indent(node->level + 1)
      + "@"
      + JavaScriptCommon::DecoraterDefinition(ReviserSyntaxBuildIn.at(node->id->text))
      + "\n";
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x110(%rbp)
movq %rdi, %rax
movq %rax, -0x108(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x100(%rbp)
movq 0x20(%rax), %rax
movq 0x30(%rax), %rsi
addq $0x8, %rsi
leaq 0x3aa2e(%rip), %rdi     # 0x130c10
callq 0xeebe0
movq %rax, -0x18(%rbp)
leaq 0x3aa1e(%rip), %rdi     # 0x130c10
callq 0xeec10
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xbb8e0
testb $0x1, %al
jne 0xf620e
jmp 0xf6262
leaq -0x21(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x99850
movq -0x110(%rbp), %rdi
movq -0x118(%rbp), %rdx
leaq 0xa97c(%rip), %rsi      # 0x100baf
callq 0x99640
jmp 0xf623a
leaq -0x21(%rbp), %rdi
callq 0x994f0
jmp 0xf63d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x994f0
jmp 0xf63e7
movq -0x100(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %esi
incl %esi
leaq -0x98(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0xeb9c0
movq -0x120(%rbp), %rsi
leaq 0xa981(%rip), %rdx      # 0x100c14
leaq -0x78(%rbp), %rdi
callq 0xaaee0
jmp 0xf629e
movq -0x100(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rax), %rsi
addq $0x8, %rsi
leaq 0x3a958(%rip), %rdi     # 0x130c10
callq 0xeec70
movq %rax, -0x128(%rbp)
jmp 0xf62c6
movq -0x128(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0xb99d0
jmp 0xf62db
xorl %eax, %eax
movl %eax, %edx
leaq -0xb8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0xf6610
jmp 0xf62f4
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0xa1070
jmp 0xf630a
movq -0x110(%rbp), %rdi
leaq 0xa896(%rip), %rdx      # 0x100bae
leaq -0x58(%rbp), %rsi
callq 0xa10c0
jmp 0xf6323
leaq -0x58(%rbp), %rdi
callq 0x992c0
leaq -0xb8(%rbp), %rdi
callq 0x992c0
leaq -0xf8(%rbp), %rdi
callq 0xb97b0
leaq -0x78(%rbp), %rdi
callq 0x992c0
leaq -0x98(%rbp), %rdi
callq 0x992c0
jmp 0xf63d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xf63c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xf63c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xf63b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xf63a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x992c0
leaq -0xb8(%rbp), %rdi
callq 0x992c0
leaq -0xf8(%rbp), %rdi
callq 0xb97b0
leaq -0x78(%rbp), %rdi
callq 0x992c0
leaq -0x98(%rbp), %rdi
callq 0x992c0
jmp 0xf63e7
movq -0x108(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x99840
// File: CoinXu[P]reviser-compiler/src/compiler/javascript/javascript_common.h
// Function: reviser::javascript::JavaScriptCommon::DecoraterDefinition[abi:cxx11](reviser::compiler::ReviserSyntaxDefinition, std::vector<reviser::compiler::DecoraterArg, std::allocator<reviser::compiler::DecoraterArg>>*)
const static string DecoraterDefinition(ReviserSyntaxDefinition def, vector<DecoraterArg>* args = nullptr) {
      switch (def.type) {
        case SYNTAX_FUNCTION:
          return def.name;

        case SYNTAX_CALLABLE:
          return DecoraterSyntaxCallable(def, args);

        default:
          return "";
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl 0x20(%rsi), %eax
movl %eax, -0x6c(%rbp)
testl %eax, %eax
je 0xf6664
jmp 0xf6645
movl -0x6c(%rbp), %eax
subl $0x1, %eax
jne 0xf66b3
jmp 0xf664f
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x991c0
jmp 0xf66fe
movq -0x88(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xb99d0
movq -0x80(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf6920
jmp 0xf6691
leaq -0x58(%rbp), %rdi
callq 0xb97b0
jmp 0xf66fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xb97b0
jmp 0xf670b
leaq -0x65(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x99850
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rdx
leaq 0xa4da(%rip), %rsi      # 0x100baf
callq 0x99640
jmp 0xf66dc
leaq -0x65(%rbp), %rdi
callq 0x994f0
jmp 0xf66fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x65(%rbp), %rdi
callq 0x994f0
jmp 0xf670b
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x99840
nopw %cs:(%rax,%rax)
nop
// File: CoinXu[P]reviser-compiler/src/compiler/typescript/typescript_common.h
// Function: reviser::typescript::TypeScriptCommon::FindReviserSyntaxDefinitionByDataType(reviser::compiler::DataType)
const static vector<ReviserSyntaxDefinition> FindReviserSyntaxDefinitionByDataType(DataType type) {
      vector<ReviserSyntaxDefinition> defs;

      if (TypeScriptDataTypeReviserMap.find(type) == TypeScriptDataTypeReviserMap.end()) {
        return defs;
      }

      for (ReviserType t : TypeScriptDataTypeReviserMap.at(type)) {
        if (ReviserMethodMap.find(t) != ReviserMethodMap.end()) {
          defs.push_back(ReviserMethodMap.at(t));
        }
      }

      return defs;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0xf0080
leaq 0x3560b(%rip), %rdi     # 0x130f48
leaq -0xc(%rbp), %rsi
callq 0xf00d0
movq %rax, -0x70(%rbp)
jmp 0xfb94c
movq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x355ed(%rip), %rdi     # 0x130f48
callq 0xf0100
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xf00a0
testb $0x1, %al
jne 0xfb977
jmp 0xfb9a1
movb $0x1, -0xd(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0xfba92
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xef2b0
jmp 0xfbaae
leaq 0x355a0(%rip), %rdi     # 0x130f48
leaq -0xc(%rbp), %rsi
callq 0xf0130
movq %rax, -0x88(%rbp)
jmp 0xfb9ba
movq -0x88(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xf01d0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0xf0200
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xf0230
testb $0x1, %al
jne 0xfb9f5
jmp 0xfba87
leaq -0x48(%rbp), %rdi
callq 0xf0270
movl (%rax), %eax
movl %eax, -0x54(%rbp)
leaq 0x35236(%rip), %rdi     # 0x130c40
leaq -0x54(%rbp), %rsi
callq 0xf02c0
movq %rax, -0x90(%rbp)
jmp 0xfba1c
movq -0x90(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x35212(%rip), %rdi     # 0x130c40
callq 0xf02f0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xf0290
testb $0x1, %al
jne 0xfba4a
jmp 0xfba77
leaq 0x351ef(%rip), %rdi     # 0x130c40
leaq -0x54(%rbp), %rsi
callq 0xf0390
movq %rax, -0x98(%rbp)
jmp 0xfba63
movq -0x98(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0xf0320
jmp 0xfba75
jmp 0xfba77
jmp 0xfba79
leaq -0x48(%rbp), %rdi
callq 0xf0430
jmp 0xfb9df
movb $0x1, -0xd(%rbp)
movl $0x1, -0x34(%rbp)
testb $0x1, -0xd(%rbp)
jne 0xfbaa1
movq -0x80(%rbp), %rdi
callq 0xef2b0
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x99840
nopw (%rax,%rax)
// File: CoinXu[P]reviser-compiler/src/compiler/typescript/typescript_struct.cpp
// Function: reviser::typescript::TypeScriptDecorater::Generate[abi:cxx11]()
string TypeScriptDecorater::Generate() {
    if (ReviserSyntaxBuildIn.find(node->id->text) == ReviserSyntaxBuildIn.end()) {
      return "";
    }

    return TypeScriptCommon::Indent(node->level + 1)
      + "@"
      + TypeScriptCommon::DecoraterDefinition(ReviserSyntaxBuildIn.at(node->id->text))
      + "\n";
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x110(%rbp)
movq %rdi, %rax
movq %rax, -0x108(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x100(%rbp)
movq 0x20(%rax), %rax
movq 0x30(%rax), %rsi
addq $0x8, %rsi
leaq 0x3319e(%rip), %rdi     # 0x130c10
callq 0xeebe0
movq %rax, -0x18(%rbp)
leaq 0x3318e(%rip), %rdi     # 0x130c10
callq 0xeec10
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xbb8e0
testb $0x1, %al
jne 0xfda9e
jmp 0xfdaf2
leaq -0x21(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x99850
movq -0x110(%rbp), %rdi
movq -0x118(%rbp), %rdx
leaq 0x30ec(%rip), %rsi      # 0x100baf
callq 0x99640
jmp 0xfdaca
leaq -0x21(%rbp), %rdi
callq 0x994f0
jmp 0xfdc67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x994f0
jmp 0xfdc77
movq -0x100(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %esi
incl %esi
leaq -0x98(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0xf8390
movq -0x120(%rbp), %rsi
leaq 0x30f1(%rip), %rdx      # 0x100c14
leaq -0x78(%rbp), %rdi
callq 0xaaee0
jmp 0xfdb2e
movq -0x100(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rax), %rsi
addq $0x8, %rsi
leaq 0x330c8(%rip), %rdi     # 0x130c10
callq 0xeec70
movq %rax, -0x128(%rbp)
jmp 0xfdb56
movq -0x128(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0xb99d0
jmp 0xfdb6b
xorl %eax, %eax
movl %eax, %edx
leaq -0xb8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0xfe2a0
jmp 0xfdb84
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0xa1070
jmp 0xfdb9a
movq -0x110(%rbp), %rdi
leaq 0x3006(%rip), %rdx      # 0x100bae
leaq -0x58(%rbp), %rsi
callq 0xa10c0
jmp 0xfdbb3
leaq -0x58(%rbp), %rdi
callq 0x992c0
leaq -0xb8(%rbp), %rdi
callq 0x992c0
leaq -0xf8(%rbp), %rdi
callq 0xb97b0
leaq -0x78(%rbp), %rdi
callq 0x992c0
leaq -0x98(%rbp), %rdi
callq 0x992c0
jmp 0xfdc67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xfdc59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xfdc50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xfdc44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xfdc38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x992c0
leaq -0xb8(%rbp), %rdi
callq 0x992c0
leaq -0xf8(%rbp), %rdi
callq 0xb97b0
leaq -0x78(%rbp), %rdi
callq 0x992c0
leaq -0x98(%rbp), %rdi
callq 0x992c0
jmp 0xfdc77
movq -0x108(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x99840
// File: overfl0[P]iojack/iojack.cpp
// Function: getArgs(int, char**)
int getArgs(int argc, char **argv)
{
    int opt;
    while((opt = getopt(argc, argv, optString)) != -1)
    {
        switch(opt)
        {
            /*case 'p':
                globalArgs.langCode = optarg;
                break;
            */
            case 'a':
                globalSettings.sendANSI = 1;
                break;

            case 'h':
                displayUsage(argv[0]);
                exit(0);

            case '?':
                displayUsage(argv[0]);
                exit(1);
        }
    }

    if(argc <= optind)
    {
        displayUsage(argv[0]);
        exit(1);
    }

    int firstPid = atoi(argv[optind]);
    if(firstPid <= 1)
        pexit("Can't get correct pid from arguments\n");

    return firstPid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq 0x13be3(%rip), %rdx     # 0x161a0
callq 0x2070
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x261f
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x3f, %eax
je 0x2607
jmp 0x25d7
movl -0x1c(%rbp), %eax
subl $0x61, %eax
je 0x25eb
jmp 0x25e1
movl -0x1c(%rbp), %eax
subl $0x68, %eax
je 0x25f4
jmp 0x261d
movb $0x1, 0x13bc6(%rip)     # 0x161b8
jmp 0x261d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2560
xorl %edi, %edi
callq 0x21f0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2560
movl $0x1, %edi
callq 0x21f0
jmp 0x25af
movl -0x4(%rbp), %eax
movq 0x139b7(%rip), %rcx     # 0x15fe0
cmpl (%rcx), %eax
jg 0x2643
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2560
movl $0x1, %edi
callq 0x21f0
movq -0x10(%rbp), %rax
movq 0x13992(%rip), %rcx     # 0x15fe0
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x22b0
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jg 0x267d
jmp 0x2665
leaq 0xb9f0(%rip), %rdi      # 0xe05c
movb $0x0, %al
callq 0x2040
movl $0x1, %edi
callq 0x21f0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)