LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a264
leaq 0x22d4a(%rip), %rsi     # 0x5029d
movq %r14, %rdi
callq 0x25650
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
leaq -0x40(%rbp), %rdi
callq 0x250f0
addq $0x58, %rbx
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2d596
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
jmp 0x2d59d
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 0x2c4f8
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x2d5ce
callq 0x25320
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x2d5dc
callq 0x25320
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 0x2d601
callq 0x25320
jmp 0x2d601
jmp 0x2d5fe
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x2d60f
callq 0x25320
movq %rbx, %rdi
callq 0x255f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ca72
testb %al, %al
jne 0x2d7c3
leaq 0x3427c(%rip), %rdi     # 0x618c0
leaq -0x24(%rbp), %rsi
callq 0x2f6be
leaq 0x22ed0(%rip), %rsi     # 0x50524
leaq -0xa8(%rbp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x2c6b4
leaq 0x22ec6(%rip), %rsi     # 0x50533
movq %r14, %rdi
callq 0x25650
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2d699
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x2d6a0
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 0x341fe(%rip), %rdi     # 0x618c0
callq 0x2f6be
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq -0x48(%rbp), %rdi
callq 0x250f0
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2d6fb
movq %rdx, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
jmp 0x2d702
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 0x242fe(%rip), %rsi     # 0x51a22
callq 0x25650
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2d751
movq %rdx, -0x88(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x78(%rbp)
jmp 0x2d759
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 0x2d4fe
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x2d792
callq 0x25320
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x2d7a0
callq 0x25320
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x2d7ae
callq 0x25320
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d7c3
callq 0x25320
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 0x2d7ec
callq 0x25320
jmp 0x2d7ec
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x2d804
callq 0x25320
jmp 0x2d804
movq %rax, %rbx
jmp 0x2d812
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x2d812
callq 0x25320
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d827
callq 0x25320
movq %rbx, %rdi
callq 0x255f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ca72
testb %al, %al
je 0x2d9ab
leaq -0x50(%rbp), %r14
leaq -0x30(%rbp), %r15
movq %rbx, %rdi
callq 0x2da74
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x2d98f
movq %rax, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x2d99a
movq %r14, %rdi
movq %r15, %rdx
callq 0x2f9f8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2ca72
testb %al, %al
jne 0x2d96f
movq %rbx, %rdi
callq 0x2db1a
movq %rax, %r15
movl $0x50, %edi
callq 0x25340
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x31eae
movq %rbx, %rdi
movl $0x3b, %esi
callq 0x2d618
movq -0x50(%rbp), %r12
movq -0x48(%rbp), %r13
cmpq %r13, %r12
je 0x2da23
movq %r14, %rbx
addq $0x30, %rbx
leaq -0x30(%rbp), %r15
movq (%r12), %rax
movq %rax, -0x30(%rbp)
movq 0x38(%r14), %rsi
cmpq 0x40(%r14), %rsi
je 0x2da0f
movq %rax, (%rsi)
addq $0x8, 0x38(%r14)
jmp 0x2da1a
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2fb32
addq $0x8, %r12
cmpq %r13, %r12
jne 0x2d9f3
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2da31
callq 0x25320
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 0x25320
jmp 0x2da5d
jmp 0x2da5a
jmp 0x2da5a
jmp 0x2da5a
jmp 0x2da5a
jmp 0x2da5a
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2da6b
callq 0x25320
movq %rbx, %rdi
callq 0x255f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d618
leaq 0x338e4(%rip), %r15     # 0x61950
movq %r15, %rdi
movq %r14, %rsi
callq 0x2fc08
addq $0x8, %r15
cmpq %r15, %rax
jne 0x2e0b5
leaq 0x2253d(%rip), %rsi     # 0x505c4
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x2c6b4
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2d4fe
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e0b5
callq 0x25320
movq %rbx, %rdi
movl $0x4, %esi
callq 0x2d618
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 0x2a264
movq 0x48(%rbx), %rax
movq %rax, 0x20(%r13)
movups 0x38(%rbx), %xmm0
movups %xmm0, 0x10(%r13)
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x2d618
movq %rbx, %rdi
movl $0x5b, %esi
callq 0x2d618
movq %rbx, %rdi
movl $0x5d, %esi
callq 0x2d618
leaq 0x3382d(%rip), %rdi     # 0x61950
movq %r14, %rsi
callq 0x2f726
movl (%rax), %r14d
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
movb $0x1, 0x60(%rdi)
movl %r14d, %esi
callq 0x3423e
movl $0x58, %edi
callq 0x25340
movq %rax, %r15
addq $0x10, %rbx
movq %rbx, %rsi
callq 0x2d484
movq %r15, %rdi
movl %r14d, %esi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x31ba0
movl $0x20, %edi
callq 0x25340
movq %rax, %r12
leaq -0x88(%rbp), %rsi
callq 0x2d484
movq %r12, %rdi
movl %r14d, %esi
movq %rax, %rdx
movq %r15, %rcx
movl $0x1, %r8d
callq 0x31c6c
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x2e1ac
callq 0x25320
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 0x2e1f5
jmp 0x2e1fa
movq %rax, %rbx
movq %r12, %rdi
jmp 0x2e1e0
jmp 0x2e1e9
movq %rax, %rbx
movq %r15, %rdi
callq 0x25320
jmp 0x2e1ec
jmp 0x2e1e9
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0x2e1fa
callq 0x25320
movq %rbx, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d618
movq %r15, %rdi
movl $0x4, %esi
callq 0x2d618
movq %rbx, %rsi
callq 0x2d484
movq %rax, %rbx
leaq 0x10(%r15), %r13
movq %r13, %rsi
callq 0x2d484
movq %rax, %r14
movq %r15, %rdi
movl $0x3d, %esi
callq 0x2ca72
testb %al, %al
je 0x2ea4f
movq %r15, %rdi
movl $0x5b, %esi
callq 0x2ca72
testb %al, %al
je 0x2ea6b
movq %r15, %rdi
movl $0x5d, %esi
callq 0x2d618
movl $0x10, %edi
callq 0x25340
movq %rax, %r12
movq %r13, %rsi
callq 0x2d484
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x31c30
jmp 0x2eae2
movl $0x10, %edi
callq 0x25340
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x31c30
jmp 0x2eae2
movq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
cmpq %rax, %rdi
je 0x2ea80
callq 0x25320
movq %rbx, %rdi
callq 0x25320
movq 0x8(%r14), %rdi
movq %r14, %rax
addq $0x18, %rax
cmpq %rax, %rdi
je 0x2ea9d
callq 0x25320
movq %r14, %rdi
callq 0x25320
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x21c82(%rip), %rsi     # 0x50736
leaq 0x21c9c(%rip), %rdx     # 0x50757
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x2a2fe
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2d4fe
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2eae2
callq 0x25320
movq 0x8(%r15), %rax
movq 0x50(%rax), %rax
movb $0x1, 0x61(%rax)
movl $0x58, %edi
callq 0x25340
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x31bbe
movl $0x20, %edi
callq 0x25340
movq %rax, %r12
movq %rax, %rdi
movl $0xa, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
movl $0x1, %r9d
callq 0x31c88
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 0x2eb66
jmp 0x2eb6b
jmp 0x2eb58
jmp 0x2eb58
movq %rax, %rbx
movq %r12, %rdi
jmp 0x2eb66
movq %rax, %rbx
movq %r15, %rdi
callq 0x25320
movq %rbx, %rdi
callq 0x255f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d618
movq %r14, %rdi
movl $0x4, %esi
callq 0x2d618
movq %rbx, %rsi
callq 0x2d484
leaq 0x10(%r14), %rsi
callq 0x2d484
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_O1/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 0x2d618
leaq 0x10(%rbx), %r15
movq %r15, %rsi
callq 0x2d484
movq %rax, %r14
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x2ca72
testb %al, %al
je 0x2f67b
movq %rbx, %rdi
movl $0x6, %esi
callq 0x2d618
movl $0x58, %edi
callq 0x25340
movq %rax, %rbx
movq %r15, %rsi
callq 0x2d484
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31ba0
movl $0x40, %edi
callq 0x25340
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x31d04
movq %r15, %rbx
jmp 0x2f693
movl $0x40, %edi
callq 0x25340
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d3c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rbx
jmp 0x2f6ae
jmp 0x2f6ab
movq %rax, %r14
movq %rbx, %rdi
callq 0x25320
movq %r14, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30137
cmpl $0xa, %eax
jne 0x30153
incl 0x100(%rdi)
movl $0x1, 0x104(%rdi)
jmp 0x30159
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 0x30159
incl 0x104(%rdi)
movslq 0xfc(%rdi), %rax
cmpq %rax, 0x8(%rdi)
jbe 0x30180
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movb (%rcx,%rax), %cl
movb %cl, 0xf8(%rdi)
incl %eax
movl %eax, 0xfc(%rdi)
popq %rbp
retq
movb $-0x1, 0xf8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30210
callq 0x30114
cmpb %bl, %r14b
sete %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
addb $-0x30, %al
cmpb $0x9, %al
ja 0x3034f
movq %rbx, %rdi
callq 0x30114
movb 0xf8(%rbx), %al
addb $-0x30, %al
cmpb $0xa, %al
jb 0x3033b
cmpb $0x2e, 0xf8(%rbx)
jne 0x30380
movq %rbx, %rdi
callq 0x30114
movb 0xf8(%rbx), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x30380
movq %rbx, %rdi
callq 0x30114
movb 0xf8(%rbx), %al
addb $-0x30, %al
cmpb $0xa, %al
jb 0x3036c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3295f
movq %rsi, %r14
leaq -0x48(%rbp), %r15
movl (%r12), %eax
movq 0x8(%r12), %rsi
testl %eax, %eax
je 0x3290c
cmpl $0x1, %eax
jne 0x32952
movq 0x20(%r14), %rax
movq 0x28(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x32971
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 0x250f0
jmp 0x32940
movq 0x38(%r14), %rax
movq 0x40(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x3297f
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 0x250f0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x32952
callq 0x25320
addq $0x10, %r12
cmpq %r13, %r12
jne 0x328c1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d952(%rip), %rdi     # 0x502ca
xorl %eax, %eax
callq 0x25510
leaq 0x1d944(%rip), %rdi     # 0x502ca
xorl %eax, %eax
callq 0x25510
jmp 0x329ac
jmp 0x32993
jmp 0x329ac
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x329af
callq 0x25320
jmp 0x329af
jmp 0x329ac
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x50(%rbp), %rdi
je 0x329bd
callq 0x25320
movq %r14, %rdi
callq 0x255f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
leaq -0x48(%rbp), %rbx
leaq -0x29(%rbp), %rcx
movq %rbx, %rdi
callq 0x32aea
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
setne %bl
je 0x32aaf
leaq -0x48(%rbp), %r14
movq (%r15), %rax
movq 0x38(%rax), %rcx
movq 0x40(%rax), %rdx
cmpq %rdx, %rcx
sete %r13b
je 0x32a85
movq (%rcx), %rsi
movq 0x48(%rsi), %rsi
cmpb $0x0, 0x4(%rsi)
jne 0x32aaf
addq $0x8, %rcx
jmp 0x32a69
movq 0x50(%rax), %rdx
movq 0x58(%rax), %rcx
cmpq %rdx, %rcx
je 0x32a9e
movq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x32cfe
testb %r13b, %r13b
je 0x32aaf
addq $0x8, %r15
cmpq %r12, %r15
setne %bl
jne 0x32a5e
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x32abd
callq 0x25320
andb $0x1, %bl
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x32ae2
callq 0x25320
movq %rbx, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq 0x50(%rdi), %rax
movq %rdi, -0x40(%rbp)
subq 0x48(%rdi), %rax
je 0x33d22
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
decl %eax
js 0x33d22
movq %rsi, -0x30(%rbp)
leaq -0x60(%rbp), %r14
movl %eax, %ebx
movq -0x40(%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 %rbx, %rdx
jbe 0x33d4b
leaq (%rbx,%rbx,2), %rcx
leaq (%rax,%rcx,8), %rsi
movq %r14, %rdi
callq 0x34394
movq -0x60(%rbp), %r12
movq -0x58(%rbp), %r14
subq %r12, %r14
movq %rbx, -0x48(%rbp)
je 0x33cf9
sarq $0x4, %r14
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r14
movl %r14d, %eax
decl %eax
movq -0x30(%rbp), %rcx
js 0x33d00
movq %r13, -0x38(%rbp)
movl %r14d, %r15d
decl %r15d
cmpq %r15, %r14
jbe 0x33d37
leaq (%r15,%r15,2), %r13
shlq $0x4, %r13
movq 0x8(%r12,%r13), %rdx
cmpq 0x8(%rcx), %rdx
jne 0x33cec
addq %r12, %r13
movl $0x1, %ebx
testq %rdx, %rdx
je 0x33d02
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq (%r13), %rdi
callq 0x25360
movq -0x30(%rbp), %rcx
testl %eax, %eax
je 0x33d02
testl %r15d, %r15d
jg 0x33ca8
xorl %ebx, %ebx
movq -0x38(%rbp), %r13
jmp 0x33d02
movl $0x4, %ebx
jmp 0x33d02
xorl %ebx, %ebx
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x34346
testb $0x3, %bl
jne 0x33d25
movq -0x48(%rbp), %rcx
leal -0x1(%rcx), %eax
testl %ecx, %ecx
jg 0x33c37
xorl %r13d, %r13d
movq %r13, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c58c(%rip), %rdi     # 0x502ca
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x25510
leaq 0x1c578(%rip), %rdi     # 0x502ca
movq %rbx, %rsi
xorl %eax, %eax
callq 0x25510
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x34346
movq %rbx, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33e09
addq $-0x18, %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x34394
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 0x33dfb
movl %r14d, %r12d
decl %r12d
cmpq %r12, %r14
jbe 0x33e1e
leaq (%r12,%r12,2), %r15
shlq $0x4, %r15
movq 0x8(%r13,%r15), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x33df6
addq %r13, %r15
testq %rdx, %rdx
je 0x33dfe
movq (%rbx), %rsi
movq (%r15), %rdi
callq 0x25360
testl %eax, %eax
je 0x33dfe
testl %r12d, %r12d
jg 0x33dc4
xorl %r15d, %r15d
leaq -0x40(%rbp), %rdi
callq 0x34346
jmp 0x33e0c
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c4a5(%rip), %rdi     # 0x502ca
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x25510
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x34346
movq %rbx, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a264
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33bfa
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x33e93
callq 0x25320
testq %rbx, %rbx
je 0x33e9d
movl 0x20(%rbx), %eax
jmp 0x33ea2
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 0x33ebe
callq 0x25320
movq %rbx, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a264
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33bfa
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x33f13
callq 0x25320
testq %rbx, %rbx
je 0x33f1e
cmpl $0x0, 0x20(%rbx)
je 0x33f22
xorl %eax, %eax
jmp 0x33f26
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 0x33f42
callq 0x25320
movq %rbx, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33fa7
movq 0x38(%rsi), %r15
movq 0x40(%rsi), %r12
cmpq %r12, %r15
setne %bl
je 0x33fa9
movq %rdx, %r14
movq 0x8(%rdx), %r13
movq (%r15), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rdx
cmpq %r13, %rdx
jne 0x33f99
testq %rdx, %rdx
je 0x33fa9
movq (%r14), %rsi
movq 0x8(%rax), %rdi
callq 0x25360
testl %eax, %eax
je 0x33fa9
addq $0x8, %r15
cmpq %r12, %r15
setne %bl
jne 0x33f74
jmp 0x33fa9
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a264
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33bfa
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3400b
callq 0x25320
testq %rbx, %rbx
je 0x3401c
cmpl $0x1, 0x20(%rbx)
jne 0x3401c
movq 0x28(%rbx), %rax
jmp 0x3401e
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 0x3403a
callq 0x25320
movq %rbx, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x340a3
movq 0x38(%rsi), %r15
movq 0x40(%rsi), %r12
cmpq %r12, %r15
setne %bl
je 0x340a5
movq %rdx, %r14
movq 0x8(%rdx), %r13
movq (%r15), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
cmpq %r13, %rdx
jne 0x34095
testq %rdx, %rdx
je 0x340a5
movq (%r14), %rsi
movq 0x8(%rax), %rdi
callq 0x25360
testl %eax, %eax
je 0x340a5
addq $0x8, %r15
cmpq %r12, %r15
setne %bl
jne 0x3406c
jmp 0x340a5
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r13
movq %rdi, -0x60(%rbp)
movq 0x20(%rdi), %r14
cmpq %r14, %r13
sete %bl
je 0x341cf
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x2a264
movl 0x20(%r13), %eax
movl %eax, -0x38(%rbp)
movq -0x50(%rbp), %rdx
cmpq 0x8(%r15), %rdx
jne 0x341a5
testq %rdx, %rdx
je 0x341aa
movq (%r15), %rsi
movq -0x58(%rbp), %rdi
callq 0x25360
testl %eax, %eax
sete %r12b
jmp 0x341ad
xorl %r12d, %r12d
jmp 0x341ad
movb $0x1, %r12b
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x341bf
callq 0x25320
testb %r12b, %r12b
jne 0x341ca
addq $0x28, %r13
jmp 0x34157
testb $0x1, %bl
je 0x34215
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 0x2a264
movl -0x2c(%rbp), %eax
movl %eax, 0x20(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x34fa6
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x34215
callq 0x25320
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 0x34235
callq 0x25320
movq %rbx, %rdi
callq 0x255f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r12
movq 0x8(%rdi), %r13
cmpq %r13, %r12
setne %r14b
je 0x3466e
movq %rsi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x2a264
movq -0x40(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x34642
testq %rdx, %rdx
je 0x34647
movq (%rbx), %rsi
movq -0x48(%rbp), %rdi
callq 0x25360
testl %eax, %eax
sete %r15b
jmp 0x3464a
xorl %r15d, %r15d
jmp 0x3464a
movb $0x1, %r15b
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3465c
callq 0x25320
testb %r15b, %r15b
jne 0x3466e
addq $0x20, %r12
cmpq %r13, %r12
setne %r14b
jne 0x34602
andb $0x1, %r14b
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x2a264
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x2a264
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x353c8
leaq -0x60(%rbp), %rdi
movl $0x2f, %esi
callq 0x252e0
movq -0x40(%rbp), %rax
cmpb $0x2f, (%rax)
je 0x35404
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movl $0x2f, %esi
callq 0x35740
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %r14
movq %r14, %rsi
callq 0x25420
movq (%r14), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x35404
callq 0x25320
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x357bd
leaq -0x80(%rbp), %rsi
movq %rbx, %rdi
callq 0x354a6
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35433
callq 0x25320
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x35441
callq 0x25320
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x3544f
callq 0x25320
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3547a
jmp 0x3547a
movq %rax, %rbx
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3547d
callq 0x25320
jmp 0x3547d
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x35490
callq 0x25320
jmp 0x35490
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x3549e
callq 0x25320
movq %rbx, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x2a264
xorl %r14d, %r14d
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
cmpq %rsi, %r14
jae 0x35501
cmpb $0x2f, (%rax,%r14)
jne 0x354fc
cmpb $0x2f, 0x1(%rax,%r14)
jne 0x354fc
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x250a0
jmp 0x354cf
incq %r14
jmp 0x354cf
cmpb $0x2f, -0x1(%rax,%rsi)
jne 0x35518
decq %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x250a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x35528
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x35538
callq 0x25320
movq %r14, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpq $0x0, 0x8(%rdi)
sete %bl
je 0x356fa
movl %esi, %r14d
movq %rdi, %r15
xorl %r13d, %r13d
leaq -0x48(%rbp), %r12
movq (%r15), %rax
movsbl (%rax,%r13), %esi
movq %r12, %rdi
callq 0x252e0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
cmpb $0x2f, -0x1(%rdi,%rax)
jne 0x356ee
testq %rax, %rax
je 0x356dd
leaq -0xd8(%rbp), %rsi
callq 0x25300
cmpl $-0x1, %eax
je 0x356dd
movl -0xc0(%rbp), %eax
movl $0x4000, %ecx           # imm = 0x4000
andl %ecx, %eax
jne 0x356ee
movq -0x48(%rbp), %rdi
movl %r14d, %esi
callq 0x251b0
cmpl $-0x1, %eax
je 0x356fa
incq %r13
cmpq %r13, 0x8(%r15)
setbe %bl
ja 0x35699
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3570c
callq 0x25320
andb $0x1, %bl
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x35738
callq 0x25320
movq %rbx, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %r15
leaq 0x1d5d2(%rip), %rax     # 0x60c70
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x255c0
leaq 0x208(%r15), %r14
leaq 0x218(%r15), %r13
movq %r13, 0x208(%r15)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x2a264
movq %r12, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x3565b
movq %rbx, %rdi
movq %r12, %rsi
movl $0x30, %edx
callq 0x251c0
addq $0x78, %r15
movq %r15, %rdi
callq 0x250b0
testb %al, %al
je 0x43712
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x251e0
movq %rax, -0x30(%rbp)
leaq 0xe222(%rip), %rsi      # 0x51949
leaq -0x70(%rbp), %rdi
movq %r12, %rdx
callq 0x2c6b4
leaq 0xe2e8(%rip), %rsi      # 0x51a22
leaq -0x70(%rbp), %rdi
callq 0x25650
leaq -0x40(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x43766
movups (%rcx), %xmm0
leaq -0x40(%rbp), %rdx
movups %xmm0, (%rdx)
jmp 0x43771
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r15b
movq -0x30(%rbp), %rdi
callq 0x25570
xorl %r15d, %r15d
movq 0x1d84e(%rip), %rsi     # 0x60ff0
movq 0x1d7e7(%rip), %rdx     # 0x60f90
movq -0x30(%rbp), %rdi
callq 0x255d0
movq %rax, %r12
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x437cf
callq 0x25320
jmp 0x437cf
movq %rax, %r12
movb $0x1, %r15b
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x437e9
callq 0x25320
jmp 0x437e9
movq %rax, %r12
movb $0x1, %r15b
testb %r15b, %r15b
je 0x43801
movq -0x30(%rbp), %rdi
callq 0x252a0
jmp 0x43801
movq %rax, %r12
jmp 0x4380e
movq %rax, %r12
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x4380e
callq 0x25320
movq %rbx, %rdi
callq 0x25500
movq %r12, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %esi, %esi
jle 0x44174
addl %esi, %esi
leaq -0x40(%rbp), %r13
cmpl $0x2, %esi
movl $0x1, %r12d
cmovgel %esi, %r12d
leaq -0x50(%rbp), %r14
leaq 0xc751(%rip), %r15      # 0x50886
movq %r13, -0x50(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x2a264
movq %r14, %rdi
movq %r15, %rsi
callq 0x25650
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25420
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x4416f
callq 0x25320
decl %r12d
jne 0x44135
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x4419c
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x4419c
callq 0x25320
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x441aa
callq 0x25320
movq %r14, %rdi
callq 0x255f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r13
cmpq 0x8(%rsi), %r13
je 0x44dd4
movq %rdx, %r14
movq %rsi, %r15
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x250f0
addq $0x20, %r13
cmpq 0x8(%r15), %r13
je 0x44dce
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x250f0
cmpq 0x8(%r15), %r13
jne 0x44da5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x44df6
callq 0x25320
movq %r14, %rdi
callq 0x255f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x1b56d(%rip), %rdx     # 0x61ca8
leaq 0x1b55e(%rip), %rcx     # 0x61ca0
movq %rcx, %rax
testq %rdx, %rdx
je 0x46768
leaq 0x1b54f(%rip), %rax     # 0x61ca0
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rax
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x46751
cmpq %rcx, %rax
je 0x467f4
cmpl %esi, 0x20(%rax)
jg 0x467f4
leaq 0x1b51b(%rip), %rdi     # 0x61c98
leaq -0x30(%rbp), %rsi
callq 0x469d4
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x467f4
leaq 0x1b357(%rip), %r14     # 0x61af0
leaq 0x8(%r14), %r15
movl (%r12), %eax
movl %eax, -0x2c(%rbp)
movq 0x10(%r14), %rdx
movq %r15, %rcx
testq %rdx, %rdx
je 0x467ca
movq %r15, %rcx
xorl %esi, %esi
cmpl %eax, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x467b3
cmpq %r15, %rcx
je 0x467eb
cmpl 0x20(%rcx), %eax
jl 0x467eb
movq %r14, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x46a5c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x46a24
addq $0x4, %r12
cmpq %r13, %r12
jne 0x4679d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x46808
movq %rax, %r14
movq %rbx, %rdi
callq 0x4689c
movq %r14, %rdi
callq 0x255f0
nop