LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/command_line_interface.cpp
// Function: reviser::CommandLineInterface::MakeSourceCodeInputs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CommandLineInterface::MakeSourceCodeInputs(const string& path) {
    const string file_path = io::absolute(path)
      ? path
      : io::join(string(getenv("PWD")), path);

    ifstream f(file_path, ifstream::binary);

    if (!f) {
      cerr << "not found file : " << file_path;
      return "";
    }

    f.seekg(0, f.end);
    int length = f.tellg();
    f.seekg(0, f.beg);
    char* buffer = new char[length];
    f.read(buffer, length);
    f.close();

    string content(buffer, length);
    delete[] buffer;
    return content;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x342c4
testb %al, %al
je 0x286c3
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x290da
jmp 0x2870a
leaq 0x26946(%rip), %rdi     # 0x4f010
callq 0x24410
leaq -0x248(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x24150
leaq -0x40(%rbp), %rdi
leaq -0x248(%rbp), %rsi
movq %r14, %rdx
callq 0x340e0
leaq -0x238(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2870a
callq 0x24320
leaq -0x248(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x4, %edx
callq 0x24560
movq -0x248(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x228(%rbp,%rax)
je 0x2877e
movq 0x378ad(%rip), %rdi     # 0x5ffe8
leaq 0x26b4c(%rip), %rsi     # 0x4f28e
movl $0x11, %edx
callq 0x243c0
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x3788d(%rip), %rdi     # 0x5ffe8
callq 0x243c0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x283e6(%rip), %rdx     # 0x50b54
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x29178
jmp 0x28807
leaq -0x248(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x24470
leaq -0x248(%rbp), %rdi
callq 0x245e0
movq %rax, %r14
leaq -0x248(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x24470
movslq %r14d, %r15
testq %r15, %r15
movq $-0x1, %rdi
cmovnsq %r15, %rdi
callq 0x24030
movq %rax, %r14
leaq -0x248(%rbp), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x24430
leaq -0x248(%rbp), %rdi
callq 0x24090
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdx
addq %r15, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29178
movq %r14, %rdi
callq 0x24460
leaq -0x248(%rbp), %rdi
callq 0x240c0
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28825
callq 0x24320
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28856
jmp 0x28856
jmp 0x28856
movq %rax, %rbx
leaq -0x238(%rbp), %rax
jmp 0x28869
movq %rax, %rbx
jmp 0x28877
jmp 0x28856
movq %rax, %rbx
jmp 0x28865
jmp 0x28856
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x240c0
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28877
callq 0x24320
movq %rbx, %rdi
callq 0x245f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/command_line_interface.cpp
// Function: reviser::CommandLineInterface::PrintHelpText()
void CommandLineInterface::PrintHelpText() {
    cerr << "Usage: " << executable_name << " [option] DR_FILE\n"
    "  --printer              Specify output type, <fs> will write code to a file on disk\n"
    "                         <terminal> will output to terminal. default <terminal>\n"
    "  --version              Show version info and exit.\n"
    "  -h, --help             Show this text and exit.\n"
    << endl;

    for (GeneratorMap::iterator iter = generators.begin();
      iter != generators.end(); iter++) {
      cerr << "  " << iter->first << "={OUT_DIR}"
        << string(13 - iter->first.size(), ' ')
        << iter->second.help_text << endl;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x3734f(%rip), %r14     # 0x5ffe8
leaq 0x264bc(%rip), %rsi     # 0x4f15c
movl $0x7, %edx
movq %r14, %rdi
callq 0x243c0
movq 0xa0(%rbx), %rsi
movq 0xa8(%rbx), %rdx
movq %r14, %rdi
callq 0x243c0
movq %rax, %r14
leaq 0x26497(%rip), %rsi     # 0x4f164
movl $0x11e, %edx            # imm = 0x11E
movq %rax, %rdi
callq 0x243c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x24330
movsbl %al, %esi
movq %r14, %rdi
callq 0x24040
movq %rax, %rdi
callq 0x24270
movq 0x18(%rbx), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x28ddf
leaq -0x38(%rbp), %r12
movq 0x372cb(%rip), %r15     # 0x5ffe8
movl $0x2, %edx
movq %r15, %rdi
leaq 0x26b59(%rip), %rsi     # 0x4f885
callq 0x243c0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x243c0
movq %rax, %r13
movl $0xa, %edx
movq %rax, %rdi
leaq 0x26530(%rip), %rsi     # 0x4f283
callq 0x243c0
movl $0xd, %esi
subq 0x28(%r14), %rsi
movq %r12, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
movl $0x20, %edx
callq 0x243e0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r13, %rdi
callq 0x243c0
movq 0x48(%r14), %rsi
movq 0x50(%r14), %rdx
movq %rax, %rdi
callq 0x243c0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x24330
movsbl %al, %esi
movq %r13, %rdi
callq 0x24040
movq %rax, %rdi
callq 0x24270
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x28dcb
callq 0x24320
movq %r14, %rdi
callq 0x24280
movq %rax, %r14
cmpq %rbx, %rax
jne 0x28d1d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x28dff
callq 0x24320
movq %rbx, %rdi
callq 0x245f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/helper.cpp
// Function: reviser::helper::numeric_is_int32(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool numeric_is_int32(string text) {
    long double value = std::stold(text);
    int min = numeric_limits<int>::lowest();
    int max = numeric_limits<int>::max();
    return value >= min && value <= max;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %r14
callq 0x24060
movq %rax, %rbx
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x245a0
cmpq %r14, (%r15)
je 0x29d1c
movl (%rbx), %eax
testl %eax, %eax
je 0x29cee
cmpl $0x22, %eax
jne 0x29cf1
fstp %st(0)
leaq 0x25697(%rip), %rdi     # 0x4f380
callq 0x244d0
movl %r12d, (%rbx)
flds 0x2563d(%rip)           # 0x4f334
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
setae %cl
fldl 0x25642(%rip)           # 0x4f348
fucompi %st(1), %st
fstp %st(0)
setae %al
andb %cl, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
leaq 0x2565b(%rip), %rdi     # 0x4f380
callq 0x24230
cmpl $0x0, (%rbx)
jne 0x29d32
movl %r12d, (%rbx)
movq %rax, %rdi
callq 0x245f0
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/helper.cpp
// Function: reviser::helper::numeric_is_int64(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool numeric_is_int64(string text) {
    long double value = std::stold(text);
    long int min = numeric_limits<long int>::lowest();
    long int max = numeric_limits<long int>::max();
    return value >= min && value <= max;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %r14
callq 0x24060
movq %rax, %rbx
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x245a0
cmpq %r14, (%r15)
je 0x29db8
movl (%rbx), %eax
testl %eax, %eax
je 0x29d8a
cmpl $0x22, %eax
jne 0x29d8d
fstp %st(0)
leaq 0x255fb(%rip), %rdi     # 0x4f380
callq 0x244d0
movl %r12d, (%rbx)
flds 0x255a5(%rip)           # 0x4f338
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
setae %cl
fldt 0x255be(%rip)           # 0x4f360
fucompi %st(1), %st
fstp %st(0)
setae %al
andb %cl, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
leaq 0x255bf(%rip), %rdi     # 0x4f380
callq 0x24230
cmpl $0x0, (%rbx)
jne 0x29dce
movl %r12d, (%rbx)
movq %rax, %rdi
callq 0x245f0
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/helper.cpp
// Function: reviser::helper::numeric_is_uint32(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool numeric_is_uint32(string text) {
    long double value = std::stold(text);
    unsigned int min = numeric_limits<unsigned int>::lowest();
    unsigned int max = numeric_limits<unsigned int>::max();
    return value >= min && value <= max;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %r14
callq 0x24060
movq %rax, %rbx
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x245a0
cmpq %r14, (%r15)
je 0x29e50
movl (%rbx), %eax
testl %eax, %eax
je 0x29e26
cmpl $0x22, %eax
jne 0x29e29
fstp %st(0)
leaq 0x2555f(%rip), %rdi     # 0x4f380
callq 0x244d0
movl %r12d, (%rbx)
fldz
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
setae %cl
fldl 0x25516(%rip)           # 0x4f350
fucompi %st(1), %st
fstp %st(0)
setae %al
andb %cl, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
leaq 0x25527(%rip), %rdi     # 0x4f380
callq 0x24230
cmpl $0x0, (%rbx)
jne 0x29e66
movl %r12d, (%rbx)
movq %rax, %rdi
callq 0x245f0
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/helper.cpp
// Function: reviser::helper::numeric_is_uint64(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool numeric_is_uint64(string text) {
    long double value = std::stold(text);
    unsigned long int min = numeric_limits<unsigned long int>::lowest();
    unsigned long int max = numeric_limits<unsigned long int>::max();
    return value >= min && value <= max;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %r14
callq 0x24060
movq %rax, %rbx
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x245a0
cmpq %r14, (%r15)
je 0x29ee8
movl (%rbx), %eax
testl %eax, %eax
je 0x29ebe
cmpl $0x22, %eax
jne 0x29ec1
fstp %st(0)
leaq 0x254c7(%rip), %rdi     # 0x4f380
callq 0x244d0
movl %r12d, (%rbx)
fldz
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
setae %cl
fldt 0x2549e(%rip)           # 0x4f370
fucompi %st(1), %st
fstp %st(0)
setae %al
andb %cl, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
leaq 0x2548f(%rip), %rdi     # 0x4f380
callq 0x24230
cmpl $0x0, (%rbx)
jne 0x29efe
movl %r12d, (%rbx)
movq %rax, %rdi
callq 0x245f0
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::Program()
void Parser::Program() {
    Accept(TOKEN_CODE_START);
    generator->descriptor->PushNewContext();

    do {
      if (LookAtType(TOKEN_STRUCT)) {
        Struct* s = ConsumeStruct();
        generator->descriptor->AddGlobalVariableOnce(s->id->text, DECLARE_STRUCT);
        generator->AddStmtStruct(s);
      } else if (LookAtType(TOKEN_ENUM)) {
        Enum* s = ConsumeEnum();
        generator->descriptor->AddGlobalVariableOnce(s->id->text, DECLARE_ENUM);
        generator->AddStmtEnum(s);
      } else {
        Next();
      }
    } while (!Accept(TOKEN_CODE_END));

    generator->descriptor->PopBackContext();
    printer->Print(generator->Generate());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movl $0x8, %esi
callq 0x2b86e
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
callq 0x32824
leaq -0x38(%rbp), %r13
leaq -0x58(%rbp), %r14
movq (%rbx), %rdi
callq 0x2f194
cmpl $0x2, (%rax)
jne 0x2b757
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2b8ec
movq %rax, %r12
movq 0x8(%rbx), %rax
movq 0x50(%rax), %r15
movq 0x30(%r12), %rax
movq %r14, -0x68(%rbp)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x290da
movq %r15, %rdi
leaq -0x68(%rbp), %rsi
movl $0x1, %edx
callq 0x32eb6
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0x2b749
callq 0x24320
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x3160a
jmp 0x2b7ce
movq (%rbx), %rdi
callq 0x2f194
cmpl $0x3, (%rax)
jne 0x2b7c6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2be64
movq %rax, %r12
movq 0x8(%rbx), %rax
movq %r13, %r15
movq 0x50(%rax), %r13
movq 0x30(%r12), %rax
movq %r15, -0x48(%rbp)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x290da
movq %r13, %rdi
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x32eb6
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
movq %r15, %r13
je 0x2b7b8
callq 0x24320
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x3158c
jmp 0x2b7ce
movq (%rbx), %rdi
callq 0x2f6ac
movq %rbx, %rdi
movl $0x9, %esi
callq 0x2b86e
testb %al, %al
je 0x2b6eb
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
callq 0x3287c
movq 0x8(%rbx), %rsi
movq 0x50(%rbx), %rbx
movq (%rsi), %rax
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b825
callq 0x24320
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x2b860
jmp 0x2b865
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
jne 0x2b860
jmp 0x2b865
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0x2b865
callq 0x24320
movq %rbx, %rdi
callq 0x245f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::Accept(reviser::compiler::TokenType)
bool Parser::Accept(TokenType type) {
    token = tokenizer->Current();
    if (token.type == type) {
      tokenizer->Next();
      return true;
    }
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x2f194
movq %rax, %r15
movl (%rax), %eax
movl %eax, 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x8(%r15), %rsi
callq 0x24210
movq 0x38(%r15), %rax
movq %rax, 0x48(%r14)
movups 0x28(%r15), %xmm0
movups %xmm0, 0x38(%r14)
movl 0x10(%r14), %r15d
cmpl %ebx, %r15d
jne 0x2b8be
movq (%r14), %rdi
callq 0x2f6ac
cmpl %ebx, %r15d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::CloneToken(reviser::compiler::Token const&)
Token* Parser::CloneToken(const Token& t) {
    return new Token {
      t.type,
      t.text,
      t.start_line,
      t.end_line,
      t.column_start,
      t.column_start,
      t.pos_start,
      t.pos_end
    };
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl $0x40, %edi
callq 0x24340
movq %rax, %rbx
movl (%r14), %eax
movl %eax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x290da
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
movl 0x2c(%r14), %eax
movl %eax, 0x2c(%rbx)
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movl %eax, 0x34(%rbx)
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
movl 0x3c(%r14), %eax
movl %eax, 0x3c(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24320
movq %r14, %rdi
callq 0x245f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::RuntimeError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, reviser::compiler::Token*)
void Parser::RuntimeError(string msg = "syntax error", Token* t = nullptr) {
    if (!t) {
      t = &token;
    }

    message.SetLine(t->start_line);
    message.SetColumn(t->column_start);
    message.Runtime(msg + ": " + t->text);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
testq %rdx, %rdx
cmovneq %rdx, %r12
movl 0x28(%r12), %eax
movl %eax, 0x58(%rdi)
movl 0x30(%r12), %eax
movl %eax, 0x5c(%rdi)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x290da
leaq 0x22f76(%rip), %rsi     # 0x4f29d
movq %r14, %rdi
callq 0x24650
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
leaq -0x40(%rbp), %rdi
callq 0x240f0
addq $0x58, %rbx
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2c36a
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
jmp 0x2c371
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq -0x60(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x2b2fc
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x2c3a2
callq 0x24320
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x2c3b0
callq 0x24320
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x2c3d5
callq 0x24320
jmp 0x2c3d5
jmp 0x2c3d2
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x2c3e3
callq 0x24320
movq %rbx, %rdi
callq 0x245f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::Expect(reviser::compiler::TokenType)
void Parser::Expect(TokenType type) {
    if (!Accept(type)) {
      RuntimeError(
        "expect token [" + TokenTypeNameMap[type] + "] but receive ["
        + TokenTypeNameMap[token.type] + "]"
      );
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl %esi, -0x24(%rbp)
callq 0x2b86e
testb %al, %al
jne 0x2c597
leaq 0x344a8(%rip), %rdi     # 0x608c0
leaq -0x24(%rbp), %rsi
callq 0x2e4d2
leaq 0x230fc(%rip), %rsi     # 0x4f524
leaq -0xa8(%rbp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x2b4b3
leaq 0x230f2(%rip), %rsi     # 0x4f533
movq %r14, %rdi
callq 0x24650
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2c46d
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x2c474
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10(%rbx), %rsi
leaq 0x3442a(%rip), %rdi     # 0x608c0
callq 0x2e4d2
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq -0x48(%rbp), %rdi
callq 0x240f0
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2c4cf
movq %rdx, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
jmp 0x2c4d6
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x68(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x2452a(%rip), %rsi     # 0x50a22
callq 0x24650
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2c525
movq %rdx, -0x88(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x78(%rbp)
jmp 0x2c52d
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq -0x88(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2c2d2
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x2c566
callq 0x24320
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x2c574
callq 0x24320
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x2c582
callq 0x24320
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c597
callq 0x24320
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x2c5c0
callq 0x24320
jmp 0x2c5c0
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x2c5d8
callq 0x24320
jmp 0x2c5d8
movq %rax, %rbx
jmp 0x2c5e6
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x2c5e6
callq 0x24320
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c5fb
callq 0x24320
movq %rbx, %rdi
callq 0x245f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::ConsumeStructProperty()
StructProperty* Parser::ConsumeStructProperty() {
    vector<Decorater*> v;
    if (Accept(TOKEN_DECORATER)) {
      do {
        v.push_back(ConsumeDecorater());
      } while (Accept(TOKEN_DECORATER));
    }

    Declare* declare = ConsumeDeclare();
    StructProperty* property = new StructProperty(declare);

    Expect(TOKEN_SEMICOLON);

    for (Decorater* d : v) {
      property->decoraters.push_back(d);
    }
    return property;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x1, %esi
callq 0x2b86e
testb %al, %al
je 0x2c789
leaq -0x50(%rbp), %r14
leaq -0x30(%rbp), %r15
movq %rbx, %rdi
callq 0x2c854
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x2c76d
movq %rax, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x2c778
movq %r14, %rdi
movq %r15, %rdx
callq 0x2e7fc
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2b86e
testb %al, %al
jne 0x2c74d
movq %rbx, %rdi
callq 0x2c8fa
movq %rax, %r15
movl $0x50, %edi
callq 0x24340
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x30cae
movq %rbx, %rdi
movl $0x3b, %esi
callq 0x2c3ec
movq -0x50(%rbp), %rbx
movq -0x48(%rbp), %r13
cmpq %r13, %rbx
je 0x2c804
movq %r14, %r15
addq $0x30, %r15
leaq -0x30(%rbp), %r12
movq (%rbx), %rax
movq %rax, -0x30(%rbp)
movq 0x38(%r14), %rsi
cmpq 0x40(%r14), %rsi
je 0x2c7ec
movq %rax, (%rsi)
addq $0x8, 0x38(%r14)
jmp 0x2c7f7
movq %r15, %rdi
movq %r12, %rdx
callq 0x2e936
addq $0x8, %rbx
cmpq %r13, %rbx
jne 0x2c7d1
movq -0x50(%rbp), %rbx
testq %rbx, %rbx
je 0x2c811
movq %rbx, %rdi
callq 0x24320
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x24320
jmp 0x2c83d
jmp 0x2c83a
jmp 0x2c83a
jmp 0x2c83a
jmp 0x2c83a
jmp 0x2c83a
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2c84b
callq 0x24320
movq %rbx, %rdi
callq 0x245f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::ConsumeDataTypeArrayDeclare(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Declare* Parser::ConsumeDataTypeArrayDeclare(string type_string) {
    Expect(TOKEN_RIGHT_BRACKET);

    if (DataTypeValue.find(type_string) == DataTypeValue.end()) {
      RuntimeError("unknow data type: " + type_string);
    }

    Expect(TOKEN_ID);
    const Token id = token;

    Expect(TOKEN_ASSIGN);
    Expect(TOKEN_LEFT_BRACKET);
    // TODO support initial values
    Expect(TOKEN_RIGHT_BRACKET);

    DataType type = DataTypeValue.at(type_string);

    generator->descriptor->include_type_array = true;
    generator->descriptor->AddDataTypesOnce(type);

    RightValue* rv = new RightValue(type, CloneToken(token), true);
    return new Declare(type, CloneToken(id), rv, true);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x5d, %esi
callq 0x2c3ec
leaq 0x33b04(%rip), %r15     # 0x60950
movq %r15, %rdi
movq %r14, %rsi
callq 0x2ea0c
addq $0x8, %r15
cmpq %r15, %rax
jne 0x2ce95
leaq 0x2275d(%rip), %rsi     # 0x4f5c4
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x2b4b3
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2c2d2
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ce95
callq 0x24320
movq %rbx, %rdi
movl $0x4, %esi
callq 0x2c3ec
movl 0x10(%rbx), %eax
leaq -0x80(%rbp), %rdi
movl %eax, -0x8(%rdi)
leaq -0x70(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
addq %rsi, %rdx
callq 0x290da
movq 0x48(%rbx), %rax
movq %rax, 0x20(%r13)
movups 0x38(%rbx), %xmm0
movups %xmm0, 0x10(%r13)
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x2c3ec
movq %rbx, %rdi
movl $0x5b, %esi
callq 0x2c3ec
movq %rbx, %rdi
movl $0x5d, %esi
callq 0x2c3ec
leaq 0x33a4d(%rip), %rdi     # 0x60950
movq %r14, %rsi
callq 0x2e53a
movl (%rax), %r14d
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
movb $0x1, 0x60(%rdi)
movl %r14d, %esi
callq 0x32fbc
movl $0x58, %edi
callq 0x24340
movq %rax, %r15
addq $0x10, %rbx
movq %rbx, %rsi
callq 0x2c258
movq %r15, %rdi
movl %r14d, %esi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x309a0
movl $0x20, %edi
callq 0x24340
movq %rax, %r12
leaq -0x88(%rbp), %rsi
callq 0x2c258
movq %r12, %rdi
movl %r14d, %esi
movq %rax, %rdx
movq %r15, %rcx
movl $0x1, %r8d
callq 0x30a6c
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x2cf8c
callq 0x24320
movq %r12, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x2cfd5
jmp 0x2cfda
movq %rax, %rbx
movq %r12, %rdi
jmp 0x2cfc0
jmp 0x2cfc9
movq %rax, %rbx
movq %r15, %rdi
callq 0x24320
jmp 0x2cfcc
jmp 0x2cfc9
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x2cfda
callq 0x24320
movq %rbx, %rdi
callq 0x245f0
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::ConsumeStructArrayDeclare(reviser::compiler::Token const&)
Declare* Parser::ConsumeStructArrayDeclare(const Token& struct_id) {
    Expect(TOKEN_RIGHT_BRACKET);
    Expect(TOKEN_ID);

    Token* sid = CloneToken(struct_id);
    Token* id = CloneToken(token);
    StructValue* sv;

    if (Accept(TOKEN_ASSIGN)) {
      if (Accept(TOKEN_LEFT_BRACKET)) {
        Expect(TOKEN_RIGHT_BRACKET);
        // TODO make TYPE_EMPTY_ARRAY type for data type
        sv = new StructValue(sid, CloneToken(token));
      } else {
        delete sid;
        delete id;
        RuntimeError("unknow struct array default value");
      }
    } else {
      sv = new StructValue(sid, nullptr);
    }

    generator->descriptor->include_struct_array = true;
    RightValue* rv = new RightValue(sv, true);
    return new Declare(TYPE_STRUCT, id, sid, rv, true);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x5d, %esi
callq 0x2c3ec
movq %r15, %rdi
movl $0x4, %esi
callq 0x2c3ec
movq %rbx, %rsi
callq 0x2c258
movq %rax, %rbx
leaq 0x10(%r15), %r13
movq %r13, %rsi
callq 0x2c258
movq %rax, %r14
movq %r15, %rdi
movl $0x3d, %esi
callq 0x2b86e
testb %al, %al
je 0x2d82f
movq %r15, %rdi
movl $0x5b, %esi
callq 0x2b86e
testb %al, %al
je 0x2d84b
movq %r15, %rdi
movl $0x5d, %esi
callq 0x2c3ec
movl $0x10, %edi
callq 0x24340
movq %rax, %r12
movq %r13, %rsi
callq 0x2c258
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x30a30
jmp 0x2d8c2
movl $0x10, %edi
callq 0x24340
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x30a30
jmp 0x2d8c2
movq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
cmpq %rax, %rdi
je 0x2d860
callq 0x24320
movq %rbx, %rdi
callq 0x24320
movq 0x8(%r14), %rdi
movq %r14, %rax
addq $0x18, %rax
cmpq %rax, %rdi
je 0x2d87d
callq 0x24320
movq %r14, %rdi
callq 0x24320
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x21ea2(%rip), %rsi     # 0x4f736
leaq 0x21ebc(%rip), %rdx     # 0x4f757
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x29178
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2c2d2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2d8c2
callq 0x24320
movq 0x8(%r15), %rax
movq 0x50(%rax), %rax
movb $0x1, 0x61(%rax)
movl $0x58, %edi
callq 0x24340
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x309be
movl $0x20, %edi
callq 0x24340
movq %rax, %r12
movq %rax, %rdi
movl $0xa, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
movl $0x1, %r9d
callq 0x30a88
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
jne 0x2d946
jmp 0x2d94b
jmp 0x2d938
jmp 0x2d938
movq %rax, %rbx
movq %r12, %rdi
jmp 0x2d946
movq %rax, %rbx
movq %r15, %rdi
callq 0x24320
movq %rbx, %rdi
callq 0x245f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::ConsumeEnumArrayDeclare(reviser::compiler::Token const&)
Declare* Parser::ConsumeEnumArrayDeclare(const Token& enum_id) {
    Expect(TOKEN_RIGHT_BRACKET);
    Expect(TOKEN_ID);

    Token* eid = CloneToken(enum_id);
    Token* id = CloneToken(token);

    generator->descriptor->include_enum_array = true;
    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x5d, %esi
callq 0x2c3ec
movq %r14, %rdi
movl $0x4, %esi
callq 0x2c3ec
movq %rbx, %rsi
callq 0x2c258
leaq 0x10(%r14), %rsi
callq 0x2c258
movq 0x8(%r14), %rax
movq 0x50(%rax), %rax
movb $0x1, 0x62(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/parser.cpp
// Function: reviser::compiler::Parser::ConsumeEnumProperty()
EnumProperty* Parser::ConsumeEnumProperty() {
    Expect(TOKEN_ID);
    Token* id = CloneToken(token);

    if (Accept(TOKEN_ASSIGN)) {
      Expect(TOKEN_DIGIT);
      RightValue* value = new RightValue(TYPE_INT32, CloneToken(token));
      EnumProperty* property = new EnumProperty(id, value);
      return property;
    }

    EnumProperty* property = new EnumProperty(id);
    return property;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x4, %esi
callq 0x2c3ec
leaq 0x10(%rbx), %r15
movq %r15, %rsi
callq 0x2c258
movq %rax, %r14
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x2b86e
testb %al, %al
je 0x2e48f
movq %rbx, %rdi
movl $0x6, %esi
callq 0x2c3ec
movl $0x58, %edi
callq 0x24340
movq %rax, %rbx
movq %r15, %rsi
callq 0x2c258
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x309a0
movl $0x40, %edi
callq 0x24340
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x30b04
movq %r15, %rbx
jmp 0x2e4a7
movl $0x40, %edi
callq 0x24340
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x30b3c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rbx
jmp 0x2e4c2
jmp 0x2e4bf
movq %rax, %r14
movq %rbx, %rdi
callq 0x24320
movq %r14, %rdi
callq 0x245f0
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/tokenizer.cpp
// Function: reviser::compiler::Tokenizer::NextChar()
void Tokenizer::NextChar() {
  if (peek == '\n') {
    line++;
    column = 1;
  } else if (peek == '\t') {
    column += CTabWidth - column % CTabWidth;
  } else {
    column++;
  }

  if (pos < input.size()) {
    peek = input.at(pos);
    pos++;
    return;
  }

  peek = EOF;
}

// Assembly:
movzbl 0xf8(%rdi), %eax
cmpl $0x9, %eax
je 0x2ef3d
cmpl $0xa, %eax
jne 0x2ef59
incl 0x100(%rdi)
movl $0x1, 0x104(%rdi)
jmp 0x2ef5f
movl 0x104(%rdi), %eax
leal 0x7(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $-0x8, %ecx
addl $0x8, %ecx
movl %ecx, 0x104(%rdi)
jmp 0x2ef5f
incl 0x104(%rdi)
movslq 0xfc(%rdi), %rcx
movb $-0x1, %al
cmpq %rcx, 0x8(%rdi)
jbe 0x2ef81
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movb (%rax,%rcx), %al
incl %ecx
movl %ecx, 0xfc(%rdi)
popq %rbp
movb %al, 0xf8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/tokenizer.cpp
// Function: reviser::compiler::Tokenizer::TryConsume(char)
bool Tokenizer::TryConsume(char c) {
  if (peek == c) {
    NextChar();
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movb 0xf8(%rdi), %r14b
cmpb %bl, %r14b
jne 0x2f010
callq 0x2ef1a
cmpb %bl, %r14b
sete %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CoinXu[P]reviser-compiler/src/tokenizer.cpp
// Function: reviser::compiler::Tokenizer::ConsumeNumber()
void Tokenizer::ConsumeNumber() {
  // 整数位
  ConsumeCharacters<CharDigit>();

  // 小数位
  if (TryConsume(TOKEN_CONNECTION)) {
    ConsumeCharacters<CharDigit>();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0xf8(%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x2f161
movq %rbx, %rdi
callq 0x2ef1a
movb 0xf8(%rbx), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x2f14b
cmpb $0x2e, %al
jne 0x2f18d
movq %rbx, %rdi
callq 0x2ef1a
movb 0xf8(%rbx), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x2f18d
movq %rbx, %rdi
callq 0x2ef1a
movb 0xf8(%rbx), %al
addb $-0x30, %al
cmpb $0xa, %al
jb 0x2f179
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %r13
cmpq %r13, %r12
je 0x31769
movq %rsi, %r14
leaq -0x48(%rbp), %r15
movl (%r12), %eax
movq 0x8(%r12), %rsi
testl %eax, %eax
je 0x31716
cmpl $0x1, %eax
jne 0x3175c
movq 0x20(%r14), %rax
movq 0x28(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x3177b
movq (%rax,%rsi,8), %rdx
movq (%r14), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *(%rax)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x240f0
jmp 0x3174a
movq 0x38(%r14), %rax
movq 0x40(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x31789
movq (%rax,%rsi,8), %rdx
movq (%r14), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x8(%rax)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x240f0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3175c
callq 0x24320
addq $0x10, %r12
cmpq %r13, %r12
jne 0x316cb
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1db48(%rip), %rdi     # 0x4f2ca
xorl %eax, %eax
callq 0x24510
leaq 0x1db3a(%rip), %rdi     # 0x4f2ca
xorl %eax, %eax
callq 0x24510
jmp 0x317b6
jmp 0x3179d
jmp 0x317b6
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x317b9
callq 0x24320
jmp 0x317b9
jmp 0x317b6
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x50(%rbp), %rdi
je 0x317c7
callq 0x24320
movq %r14, %rdi
callq 0x245f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
leaq -0x38(%rbp), %r14
leaq -0x19(%rbp), %rcx
movq %r14, %rdi
callq 0x318e8
movq (%r14), %rbx
movq 0x8(%r14), %r15
cmpq %r15, %rbx
je 0x318b0
movq (%rbx), %rax
movq 0x38(%rax), %rcx
movq 0x40(%rax), %rdx
cmpq %rdx, %rcx
je 0x31880
movq (%rcx), %rsi
movq 0x48(%rsi), %rsi
cmpb $0x0, 0x4(%rsi)
jne 0x318a7
addq $0x8, %rcx
jmp 0x31868
movq 0x50(%rax), %rdx
movq 0x58(%rax), %rcx
cmpq %rdx, %rcx
je 0x31899
movq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x31aee
addq $0x8, %rbx
cmpq %r15, %rbx
jne 0x3185d
xorl %r14d, %r14d
jmp 0x318aa
movb $0x1, %r14b
movq -0x38(%rbp), %rbx
jmp 0x318b3
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x318c0
movq %rbx, %rdi
callq 0x24320
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x318df
callq 0x24320
movq %rbx, %rdi
callq 0x245f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x50(%rdi), %rax
movq %rdi, -0x30(%rbp)
subq 0x48(%rdi), %rax
je 0x32aa8
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
decl %eax
js 0x32aa8
movq %rsi, %rbx
leaq -0x50(%rbp), %r14
movl %eax, %esi
movq -0x30(%rbp), %rcx
movq 0x48(%rcx), %rax
movq 0x50(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x32adc
movq %rsi, -0x38(%rbp)
leaq (%rsi,%rsi,2), %rcx
leaq (%rax,%rcx,8), %rsi
movq %r14, %rdi
callq 0x33104
movq -0x50(%rbp), %r12
movq -0x48(%rbp), %r15
subq %r12, %r15
je 0x32a8d
sarq $0x4, %r15
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r15
movl %r15d, %eax
decl %eax
js 0x32a8d
movl %r15d, %r13d
decl %r13d
cmpq %r13, %r15
jbe 0x32ac8
leaq (,%r13,2), %r14
addq %r13, %r14
shlq $0x4, %r14
movq 0x8(%r12,%r14), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x32a88
addq %r12, %r14
testq %rdx, %rdx
je 0x32aad
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x24360
testl %eax, %eax
je 0x32aad
testl %r13d, %r13d
jg 0x32a4f
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x330ac
movq -0x38(%rbp), %rcx
leal -0x1(%rcx), %eax
testl %ecx, %ecx
jg 0x329e6
xorl %r14d, %r14d
jmp 0x32ab6
leaq -0x50(%rbp), %rdi
callq 0x330ac
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c7fb(%rip), %rdi     # 0x4f2ca
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x24510
leaq 0x1c7e7(%rip), %rdi     # 0x4f2ca
xorl %eax, %eax
callq 0x24510
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x330ac
movq %rbx, %rdi
callq 0x245f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x50(%rdi), %rsi
cmpq 0x48(%rdi), %rsi
je 0x32b97
addq $-0x18, %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x33104
movq (%r14), %r13
movq 0x8(%r14), %rax
subq %r13, %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r14
movl %r14d, %eax
decl %eax
js 0x32b89
movl %r14d, %r12d
decl %r12d
cmpq %r12, %r14
jbe 0x32bac
leaq (%r12,%r12,2), %r15
shlq $0x4, %r15
movq 0x8(%r13,%r15), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x32b84
addq %r13, %r15
testq %rdx, %rdx
je 0x32b8c
movq (%rbx), %rsi
movq (%r15), %rdi
callq 0x24360
testl %eax, %eax
je 0x32b8c
testl %r12d, %r12d
jg 0x32b52
xorl %r15d, %r15d
leaq -0x40(%rbp), %rdi
callq 0x330ac
jmp 0x32b9a
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c717(%rip), %rdi     # 0x4f2ca
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x24510
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x330ac
movq %rbx, %rdi
callq 0x245f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x290da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x329aa
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x32c21
callq 0x24320
testq %rbx, %rbx
je 0x32c2b
movl 0x20(%rbx), %eax
jmp 0x32c30
movl $0x2, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x32c4c
callq 0x24320
movq %rbx, %rdi
callq 0x245f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x290da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x329aa
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x32ca1
callq 0x24320
testq %rbx, %rbx
je 0x32cac
cmpl $0x0, 0x20(%rbx)
je 0x32cb0
xorl %eax, %eax
jmp 0x32cb4
movq 0x28(%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x32cd0
callq 0x24320
movq %rbx, %rdi
callq 0x245f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x32d31
movq 0x38(%rsi), %r12
movq 0x40(%rsi), %r13
cmpq %r13, %r12
je 0x32d31
movq %rdx, %rbx
movq 0x8(%rdx), %r14
movq (%r12), %rax
movq 0x30(%rax), %rax
cmpq %r14, 0x10(%rax)
jne 0x32d28
movb $0x1, %r15b
testq %r14, %r14
je 0x32d34
movq (%rbx), %rsi
movq 0x8(%rax), %rdi
movq %r14, %rdx
callq 0x24360
testl %eax, %eax
je 0x32d34
addq $0x8, %r12
cmpq %r13, %r12
jne 0x32cff
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x290da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x329aa
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x32d93
callq 0x24320
testq %rbx, %rbx
je 0x32da4
cmpl $0x1, 0x20(%rbx)
jne 0x32da4
movq 0x28(%rbx), %rax
jmp 0x32da6
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x32dc2
callq 0x24320
movq %rbx, %rdi
callq 0x245f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x32e27
movq 0x38(%rsi), %r12
movq 0x40(%rsi), %r13
cmpq %r13, %r12
je 0x32e27
movq %rdx, %rbx
movq 0x8(%rdx), %r14
movq (%r12), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
cmpq %r14, 0x10(%rax)
jne 0x32e1e
movb $0x1, %r15b
testq %r14, %r14
je 0x32e2a
movq (%rbx), %rsi
movq 0x8(%rax), %rdi
movq %r14, %rdx
callq 0x24360
testl %eax, %eax
je 0x32e2a
addq $0x8, %r12
cmpq %r13, %r12
jne 0x32df1
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r15
movq 0x18(%rdi), %r14
movq %rdi, -0x60(%rbp)
movq 0x20(%rdi), %rbx
cmpq %rbx, %r14
je 0x32f4e
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x290da
movl 0x20(%r14), %eax
movl %eax, -0x38(%rbp)
movq -0x50(%rbp), %rdx
cmpq 0x8(%r15), %rdx
jne 0x32f26
movq -0x58(%rbp), %r13
testq %rdx, %rdx
je 0x32f2f
movq (%r15), %rsi
movq %r13, %rdi
callq 0x24360
testl %eax, %eax
sete %r12b
jmp 0x32f32
movq -0x58(%rbp), %r13
xorl %r12d, %r12d
jmp 0x32f32
movb $0x1, %r12b
leaq -0x48(%rbp), %rax
cmpq %rax, %r13
je 0x32f43
movq %r13, %rdi
callq 0x24320
testb %r12b, %r12b
jne 0x32f94
addq $0x28, %r14
jmp 0x32ed9
movq -0x60(%rbp), %rbx
addq $0x18, %rbx
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x290da
movl -0x2c(%rbp), %eax
movl %eax, 0x20(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x33d2c
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x32f94
callq 0x24320
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x32fb4
callq 0x24320
movq %rbx, %rdi
callq 0x245f0