LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::GosASTError::ErrorToken(Gos::GosToken, Gos::GosToken)
void GosASTError::ErrorToken(GosToken token, GosToken correct) {
        gosASTHasError = true;
        if (!gosASTOffError) {
            std::cerr << "Error: " << gosASTFileName << ": " << token.line << ": unexpected token \"" << token.ToString() << "\" instead of \"" << correct.ToString() << "\"" << std::endl;
        }/* else {
            std::cerr << "offerror: ";
            std::cerr << "Error: " << gosASTFileName << ": " << token.line << ": unexpected token \"" << token.ToString() << "\" instead of \"" << correct.ToString() << "\"" << std::endl;
        }*/
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movb $0x1, 0x7ecc2(%rip)     # 0x11f1f0
cmpl $0x0, 0x7ecbf(%rip)     # 0x11f1f4
jne 0xa0677
movq %rsi, %rbx
movq %rdi, %r14
movq 0x7daa8(%rip), %r15     # 0x11dff0
leaq 0x2ff3b(%rip), %rsi     # 0xd048a
movl $0x7, %edx
movq %r15, %rdi
callq 0x113c0
movq 0x7ec6d(%rip), %rsi     # 0x11f1d0
movq 0x7ec6e(%rip), %rdx     # 0x11f1d8
movq %r15, %rdi
callq 0x113c0
movq %rax, %r15
leaq 0x1dd3d(%rip), %rsi     # 0xbe2b9
movl $0x2, %edx
movq %rax, %rdi
callq 0x113c0
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x11550
movq %rax, %r15
leaq 0x2ffe1(%rip), %rsi     # 0xd0580
movl $0x14, %edx
movq %rax, %rdi
callq 0x113c0
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x9ed56
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x113c0
movq %rax, %r14
leaq 0x2ffbe(%rip), %rsi     # 0xd0595
movl $0xe, %edx
movq %rax, %rdi
callq 0x113c0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x9ed56
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x113c0
movq %rax, %rbx
leaq 0x2ff71(%rip), %rsi     # 0xd057e
movl $0x1, %edx
movq %rax, %rdi
callq 0x113c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq %rbx, %rdi
callq 0x11040
movq %rax, %rdi
callq 0x11260
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa065c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0677
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xa0685
movq %rax, %rbx
jmp 0xa06a8
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa06a8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa06c3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::GosAST::CompileAST(Gos::Compiler::VMCompiler&)
int Gos::GosAST::CompileAST(Compiler::VMCompiler& code) {
    code.SetProgramFileName(gosASTFileName);
    auto setMemsize = code.vm.WriteAlloc();
    for (auto* ast : nodes) {
        ast->CompileAST(code);
    }
    for (int i = 0; i < code.lambdaDefStartPos.size(); i++) {
        code.vm.WriteCommandJmp()(code.lambdaDefStartPos[i]);
        code.lambdaDefJumpout[i](code.vm.GetProgress());
    }
    setMemsize(code.pos);
    code.vm.WriteFinish();
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7eae9(%rip), %rsi     # 0x11f1d0
movq %rbx, %rdi
callq 0xa7d8c
movq 0xe8(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x9ab8c
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0xa071e
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r15
jmp 0xa0708
movq 0x130(%rbx), %rax
cmpq 0x128(%rbx), %rax
je 0xa07de
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
xorl %r13d, %r13d
movq 0xe8(%rbx), %rsi
movq %r14, %rdi
callq 0x9a744
movq 0x128(%rbx), %rax
movl (%rax,%r13,4), %eax
movl %eax, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xa0833
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%rsp)
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xa078d
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq 0xe8(%rbx), %rdi
movq 0x140(%rbx), %rbp
callq 0x9ab88
movl %eax, 0x8(%rsp)
cmpq $0x0, 0x10(%rbp,%r12)
je 0xa0838
leaq (%r12,%rbp), %rdi
movq %r14, %rsi
callq *0x18(%rbp,%r12)
movq 0x130(%rbx), %rax
subq 0x128(%rbx), %rax
incq %r13
sarq $0x2, %rax
addq $0x20, %r12
cmpq %r13, %rax
ja 0xa0742
movl 0xe0(%rbx), %eax
movl %eax, 0x8(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0xa083d
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq *0x18(%rdi)
movq 0xe8(%rbx), %rdi
callq 0x9ab7e
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xa0822
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x11150
callq 0x11150
callq 0x11150
jmp 0xa0894
jmp 0xa0870
jmp 0xa0894
jmp 0xa0870
jmp 0xa084e
jmp 0xa0870
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xa0873
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa0873
jmp 0xa0894
jmp 0xa0870
movq %rax, %rbx
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xa088c
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x2789a
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::GosAST::Build(Gos::GosTokenizer&)
void Gos::GosAST::Build(Gos::GosTokenizer& tokenizer) {
    gosASTOffError = 0;
    gosASTHasError = false;
    while (!tokenizer.IsEOF() && !gosASTHasError) {
        nodes.push_back(new AST::Preprocess(tokenizer));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, 0x7e940(%rip)     # 0x11f1f4
movb $0x0, 0x7e935(%rip)     # 0x11f1f0
movq %rsi, %rdi
callq 0x9fe50
testb %al, %al
jne 0xa0913
testb $0x1, 0x7e922(%rip)     # 0x11f1f0
jne 0xa0913
addq $0x10, %r14
movq %rsp, %r15
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa3f32
movq %r12, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa7742
movq %rbx, %rdi
callq 0x9fe50
testb %al, %al
jne 0xa0913
testb $0x1, 0x7e8df(%rip)     # 0x11f1f0
je 0xa08d7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x60, %esi
movq %r12, %rdi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::GosAST::PrintAST(int)
void Gos::GosAST::PrintAST(int indent) {
    for (int i = 0; i < indent; i++) {
        std::cout << "  ";
    }
    for (auto* ast : nodes) {
        ast->PrintAST(indent);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0xa096d
movq 0x7d678(%rip), %r15     # 0x11dfc8
leaq 0x2fc4d(%rip), %r12     # 0xd05a4
movl %ebx, %ebp
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x113c0
decl %ebp
jne 0xa0959
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0xa098b
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x8(%rax)
addq $0x8, %r15
jmp 0xa0975
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Unary::Unary(Gos::GosTokenizer&)
Build(Unary) {
        Log(Unary);
        token = tokenizer.GetToken();
        if (token.type == ADD || token.type == SUB || token.type == NOT || token.type == MUL || token.type == ADDR) {
            branch = 1;
            Expect(Unary);
        } else {
            tokenizer.BackToken();
            Expect(PostFix);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7bd81(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r12
movq %r12, %rdi
callq 0x9ece0
leaq 0x7bf58(%rip), %rax     # 0x11d268
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7decb(%rip)     # 0x11f1f0
jne 0xa138e
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movups (%rax), %xmm0
movups %xmm0, (%r12)
leaq 0x40(%rbx), %rdi
addq $0x18, %rax
movq %rax, %rsi
callq 0x3a2e8
movl (%r12), %eax
leal -0x1a(%rax), %ecx
cmpl $0x4, %ecx
jb 0xa1361
cmpl $0x27, %eax
jne 0xa139a
movl $0x1, 0x8(%rbx)
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xa12d2
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xa7742
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x9fe44
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xa0fb4
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xa7742
jmp 0xa138e
jmp 0xa13ce
jmp 0xa13fb
movq %rax, %r15
movl $0x60, %esi
movq %r12, %rdi
callq 0x11360
jmp 0xa13fe
jmp 0xa13fb
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa1406
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa1406
movq %rax, %r15
movq %rbx, %rdi
callq 0xa0994
movq %r15, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Cast::Cast(Gos::GosTokenizer&)
Build(Cast) {
        Log(Cast);
        Expect(Unary);
        token = tokenizer.GetToken();
        if (token.type == AS) {
            Expect(Symbol);
        } else {
            tokenizer.BackToken();
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7bc40(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r12
movq %r12, %rdi
callq 0x9ece0
leaq 0x7be5f(%rip), %rax     # 0x11d2b0
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7dd8a(%rip)     # 0x11f1f0
jne 0xa14f6
movl $0x60, %edi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0xa12d2
leaq 0x8(%rsp), %rsi
movq %r13, (%rsi)
movq %r14, %rdi
callq 0xa7742
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movups (%rax), %xmm0
movups %xmm0, (%r12)
leaq 0x40(%rbx), %rdi
addq $0x18, %rax
movq %rax, %rsi
callq 0x3a2e8
cmpl $0xe, (%r12)
jne 0xa14ee
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xa0a7a
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xa7742
jmp 0xa14f6
movq %r15, %rdi
callq 0x9fe44
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x60, %esi
movq %r12, %rdi
jmp 0xa151e
jmp 0xa1540
movq %rax, %r15
movl $0x60, %esi
movq %r13, %rdi
callq 0x11360
jmp 0xa1543
jmp 0xa1540
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa154b
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa154b
movq %rax, %r15
movq %rbx, %rdi
callq 0xa0994
movq %r15, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Mul::Mul(Gos::GosTokenizer&)
Build(Mul) {
        Log(Mul);
        Expect(Cast);
        token = tokenizer.GetToken();
        while (token.type == MUL || token.type == DIV || token.type == REM) {
            Expect(Cast);
            tokenList.push_back(token);
            token = tokenizer.GetToken();
        }
        tokenizer.BackToken();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7baf9(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r13
movq %r13, %rdi
callq 0x9ece0
leaq 0x7bd60(%rip), %rax     # 0x11d2f8
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
movq %rbx, (%rsp)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7dc30(%rip)     # 0x11f1f0
jne 0xa16a8
movq (%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
movl $0x60, %edi
callq 0x11350
movq %rax, %rbp
movq %rax, %rdi
movq %r15, %rsi
callq 0xa140e
leaq 0x10(%rsp), %rsi
movq %rbp, (%rsi)
movq %r12, %rdi
callq 0xa7742
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
movq (%rsp), %rcx
leaq 0x40(%rcx), %rbp
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
leaq 0x10(%rsp), %rbx
movl (%r13), %eax
cmpl $0x1f, %eax
ja 0xa16a0
movl $0xd0000000, %ecx       # imm = 0xD0000000
btl %eax, %ecx
jae 0xa16a0
movl $0x60, %edi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xa140e
movq %r14, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa7742
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x9ff30
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
jmp 0xa162f
movq %r15, %rdi
callq 0x9fe44
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x60, %esi
movq %rbp, %rdi
jmp 0xa16f0
jmp 0xa16f9
movq %rbx, %rcx
movq %rax, %rbx
movq (%r12), %rdi
testq %rdi, %rdi
je 0xa170f
movq 0x20(%rcx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa170f
jmp 0xa16f9
movq %rax, %rbx
movl $0x60, %esi
movq %r14, %rdi
callq 0x11360
jmp 0xa16fc
jmp 0xa16f9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x9ff7c
movq (%rsp), %rdi
callq 0xa0994
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Add::Add(Gos::GosTokenizer&)
Build(Add) {
        Log(Add);
        Expect(Mul);
        token = tokenizer.GetToken();
        while (token.type == ADD || token.type == SUB) {
            Expect(Mul);
            tokenList.push_back(token);
            token = tokenizer.GetToken();
        }
        tokenizer.BackToken();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7b935(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r13
movq %r13, %rdi
callq 0x9ece0
leaq 0x7bbe4(%rip), %rax     # 0x11d340
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
movq %rbx, (%rsp)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7da6c(%rip)     # 0x11f1f0
jne 0xa1865
movq (%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
movl $0x78, %edi
callq 0x11350
movq %rax, %rbp
movq %rax, %rdi
movq %r15, %rsi
callq 0xa1554
leaq 0x10(%rsp), %rsi
movq %rbp, (%rsi)
movq %r12, %rdi
callq 0xa7742
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
movq (%rsp), %rcx
leaq 0x40(%rcx), %rbp
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
leaq 0x10(%rsp), %rbx
movl (%r13), %eax
andl $-0x2, %eax
cmpl $0x1a, %eax
jne 0xa185d
movl $0x78, %edi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xa1554
movq %r14, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa7742
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x9ff30
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
jmp 0xa17f3
movq %r15, %rdi
callq 0x9fe44
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x78, %esi
movq %rbp, %rdi
jmp 0xa18ad
jmp 0xa18b6
movq %rbx, %rcx
movq %rax, %rbx
movq (%r12), %rdi
testq %rdi, %rdi
je 0xa18cc
movq 0x20(%rcx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa18cc
jmp 0xa18b6
movq %rax, %rbx
movl $0x78, %esi
movq %r14, %rdi
callq 0x11360
jmp 0xa18b9
jmp 0xa18b6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x9ff7c
movq (%rsp), %rdi
callq 0xa0994
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Relation::Relation(Gos::GosTokenizer&)
Build(Relation) {
        Log(Relation);
        Expect(Add);
        token = tokenizer.GetToken();
        while (token.type == L || token.type == LE || token.type == G || token.type == GE) {
            Expect(Add);
            tokenList.push_back(token);
            token = tokenizer.GetToken();
        }
        tokenizer.BackToken();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7b779(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r13
movq %r13, %rdi
callq 0x9ece0
leaq 0x7ba70(%rip), %rax     # 0x11d388
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
movq %rbx, (%rsp)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7d8b0(%rip)     # 0x11f1f0
jne 0xa1a21
movq (%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
movl $0x78, %edi
callq 0x11350
movq %rax, %rbp
movq %rax, %rdi
movq %r15, %rsi
callq 0xa1718
leaq 0x10(%rsp), %rsi
movq %rbp, (%rsi)
movq %r12, %rdi
callq 0xa7742
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
movq (%rsp), %rcx
leaq 0x40(%rcx), %rbp
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
leaq 0x10(%rsp), %rbx
movl (%r13), %eax
addl $-0x23, %eax
cmpl $0x3, %eax
ja 0xa1a19
movl $0x78, %edi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xa1718
movq %r14, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa7742
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x9ff30
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
jmp 0xa19af
movq %r15, %rdi
callq 0x9fe44
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x78, %esi
movq %rbp, %rdi
jmp 0xa1a69
jmp 0xa1a72
movq %rbx, %rcx
movq %rax, %rbx
movq (%r12), %rdi
testq %rdi, %rdi
je 0xa1a88
movq 0x20(%rcx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa1a88
jmp 0xa1a72
movq %rax, %rbx
movl $0x78, %esi
movq %r14, %rdi
callq 0x11360
jmp 0xa1a75
jmp 0xa1a72
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x9ff7c
movq (%rsp), %rdi
callq 0xa0994
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Equality::Equality(Gos::GosTokenizer&)
Build(Equality) {
        Log(Equality);
        Expect(Relation);
        token = tokenizer.GetToken();
        while (token.type == E || token.type == NE) {
            Expect(Relation);
            tokenList.push_back(token);
            token = tokenizer.GetToken();
        }
        tokenizer.BackToken();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7b5bd(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r13
movq %r13, %rdi
callq 0x9ece0
leaq 0x7b8fc(%rip), %rax     # 0x11d3d0
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
movq %rbx, (%rsp)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7d6f4(%rip)     # 0x11f1f0
jne 0xa1bdd
movq (%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
movl $0x78, %edi
callq 0x11350
movq %rax, %rbp
movq %rax, %rdi
movq %r15, %rsi
callq 0xa18d4
leaq 0x10(%rsp), %rsi
movq %rbp, (%rsi)
movq %r12, %rdi
callq 0xa7742
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
movq (%rsp), %rcx
leaq 0x40(%rcx), %rbp
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
leaq 0x10(%rsp), %rbx
movl (%r13), %eax
addl $-0x21, %eax
cmpl $0x1, %eax
ja 0xa1bd5
movl $0x78, %edi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xa18d4
movq %r14, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa7742
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x9ff30
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
jmp 0xa1b6b
movq %r15, %rdi
callq 0x9fe44
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x78, %esi
movq %rbp, %rdi
jmp 0xa1c25
jmp 0xa1c2e
movq %rbx, %rcx
movq %rax, %rbx
movq (%r12), %rdi
testq %rdi, %rdi
je 0xa1c44
movq 0x20(%rcx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa1c44
jmp 0xa1c2e
movq %rax, %rbx
movl $0x78, %esi
movq %r14, %rdi
callq 0x11360
jmp 0xa1c31
jmp 0xa1c2e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x9ff7c
movq (%rsp), %rdi
callq 0xa0994
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::LogicAnd::LogicAnd(Gos::GosTokenizer&)
Build(LogicAnd) {
        Log(LogicAnd);
        Expect(Equality);
        token = tokenizer.GetToken();
        while (token.type == AND) {
            Expect(Equality);
            tokenList.push_back(token);
            token = tokenizer.GetToken();
        }
        tokenizer.BackToken();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7b401(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r13
movq %r13, %rdi
callq 0x9ece0
leaq 0x7b788(%rip), %rax     # 0x11d418
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
movq %rbx, (%rsp)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7d538(%rip)     # 0x11f1f0
jne 0xa1d94
movq (%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
movl $0x78, %edi
callq 0x11350
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0xa1a90
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
movq %r12, %rdi
callq 0xa7742
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
movq (%rsp), %rcx
leaq 0x40(%rcx), %rbp
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
leaq 0x10(%rsp), %rbx
cmpl $0x28, (%r13)
jne 0xa1d8c
movl $0x78, %edi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xa1a90
movq %r14, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa7742
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x9ff30
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
jmp 0xa1d27
movq %r15, %rdi
callq 0x9fe44
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x78, %esi
movq %rbx, %rdi
jmp 0xa1dd9
jmp 0xa1de2
movq %rax, %r15
movq (%r12), %rdi
testq %rdi, %rdi
je 0xa1df8
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa1df8
jmp 0xa1de2
movq %rax, %r15
movl $0x78, %esi
movq %r14, %rdi
callq 0x11360
jmp 0xa1de5
jmp 0xa1de2
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0x9ff7c
movq (%rsp), %rdi
callq 0xa0994
movq %r15, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::LogicOr::LogicOr(Gos::GosTokenizer&)
Build(LogicOr) {
        Log(LogicOr);
        Expect(LogicAnd);
        token = tokenizer.GetToken();
        while (token.type == OR) {
            Expect(LogicAnd);
            tokenList.push_back(token);
            token = tokenizer.GetToken();
        }
        tokenizer.BackToken();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7b24d(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r13
movq %r13, %rdi
callq 0x9ece0
leaq 0x7b61c(%rip), %rax     # 0x11d460
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
movq %rbx, (%rsp)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7d384(%rip)     # 0x11f1f0
jne 0xa1f48
movq (%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
movl $0x78, %edi
callq 0x11350
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0xa1c4c
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
movq %r12, %rdi
callq 0xa7742
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
movq (%rsp), %rcx
leaq 0x40(%rcx), %rbp
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
leaq 0x10(%rsp), %rbx
cmpl $0x29, (%r13)
jne 0xa1f40
movl $0x78, %edi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xa1c4c
movq %r14, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa7742
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x9ff30
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
jmp 0xa1edb
movq %r15, %rdi
callq 0x9fe44
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x78, %esi
movq %rbx, %rdi
jmp 0xa1f8d
jmp 0xa1f96
movq %rax, %r15
movq (%r12), %rdi
testq %rdi, %rdi
je 0xa1fac
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa1fac
jmp 0xa1f96
movq %rax, %r15
movl $0x78, %esi
movq %r14, %rdi
callq 0x11360
jmp 0xa1f99
jmp 0xa1f96
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0x9ff7c
movq (%rsp), %rdi
callq 0xa0994
movq %r15, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Cond::Cond(Gos::GosTokenizer&)
Build(Cond) {
        Log(Cond);
        Expect(LogicOr);
        token = tokenizer.GetToken();
        if (token.type == QUESTION) {
            branch = 1;
            Expect(Exp);
            tokenizer.EatToken(COLON);
            Expect(Exp);
        } else {
            tokenizer.BackToken();
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7b09a(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r12
movq %r12, %rdi
callq 0x9ece0
leaq 0x7b4b1(%rip), %rax     # 0x11d4a8
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7d1e4(%rip)     # 0x11f1f0
jne 0xa20d8
movl $0x78, %edi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0xa1e00
leaq 0x8(%rsp), %rsi
movq %r13, (%rsi)
movq %r14, %rdi
callq 0xa7742
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movups (%rax), %xmm0
movups %xmm0, (%r12)
leaq 0x40(%rbx), %rdi
addq $0x18, %rax
movq %rax, %rsi
callq 0x3a2e8
cmpl $0x31, (%r12)
jne 0xa20d0
movl $0x1, 0x8(%rbx)
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xa23a6
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xa7742
movq %r15, %rdi
movl $0x30, %esi
callq 0x9fc34
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xa23a6
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xa7742
jmp 0xa20d8
movq %r15, %rdi
callq 0x9fe44
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xa20e8
movq %rax, %r15
movl $0x60, %esi
movq %r12, %rdi
jmp 0xa2104
jmp 0xa2126
jmp 0xa2126
movq %rax, %r15
movl $0x78, %esi
movq %r13, %rdi
callq 0x11360
jmp 0xa2129
jmp 0xa2126
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa2131
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa2131
movq %rax, %r15
movq %rbx, %rdi
callq 0xa0994
movq %r15, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Assign::Assign(Gos::GosTokenizer&)
Build(Assign) {
        Log(Assign);
        Expect(Unary);
        token = tokenizer.GetToken();
        if (token.type != ASSIGN && token.type != ASSIGN_ADD &&
            token.type != ASSIGN_SUB && token.type != ASSIGN_MUL &&
            token.type != ASSIGN_DIV && token.type != ASSIGN_REM &&
            token.type != ASSIGN_XOR && token.type != ASSIGN_AND &&
            token.type != ASSIGN_OR) {
            GosASTError::UnexpectedToken(token);
            return;
        }
        Expect(Cond);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7ae52(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r12
movq %r12, %rdi
callq 0x9ece0
leaq 0x7b2f9(%rip), %rax     # 0x11d538
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7cf9c(%rip)     # 0x11f1f0
jne 0xa2332
movl $0x60, %edi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0xa12d2
leaq 0x8(%rsp), %rsi
movq %r13, (%rsi)
movq %r14, %rdi
callq 0xa7742
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movups (%rax), %xmm0
movups %xmm0, (%r12)
leaq 0x40(%rbx), %rdi
addq $0x18, %rax
movq %rax, %rsi
callq 0x3a2e8
movl (%r12), %eax
addl $-0xf, %eax
cmpl $0x9, %eax
jae 0xa22e1
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xa1fb4
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xa7742
jmp 0xa2332
movq 0x10(%r12), %rax
leaq 0x28(%rsp), %rdi
movq %rax, -0x8(%rdi)
movups (%r12), %xmm0
movaps %xmm0, -0x18(%rdi)
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
addq %rsi, %rdx
callq 0x37586
leaq 0x10(%rsp), %rdi
callq 0xa03ec
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0xa2332
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0xa2396
movq 0x38(%rsp), %rsi
incq %rsi
jmp 0xa2371
movq %rax, %r15
movl $0x60, %esi
movq %r12, %rdi
jmp 0xa2371
jmp 0xa2393
movq %rax, %r15
movl $0x60, %esi
movq %r13, %rdi
callq 0x11360
jmp 0xa2396
jmp 0xa2393
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa239e
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa239e
movq %rax, %r15
movq %rbx, %rdi
callq 0xa0994
movq %r15, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::DefVar::DefVar(Gos::GosTokenizer&)
Build(DefVar) {
        Log(DefVar);
        Expect(Symbol);
        token = tokenizer.GetToken();
        if (token.type == COLON) {
            branch += 1;
            tokenList.push_back(token);
            Expect(Symbol);
            token = tokenizer.GetToken();
        }
        if (token.type == ASSIGN) {
            branch += 2;
            tokenList.push_back(token);
            Expect(Exp);
        } else {
            tokenizer.BackToken();
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x7aa91(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r13
movq %r13, %rdi
callq 0x9ece0
leaq 0x7afc8(%rip), %rax     # 0x11d5c8
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7cbcc(%rip)     # 0x11f1f0
jne 0xa2736
leaq 0x60(%rbx), %rax
movq %rax, 0x8(%rsp)
movl $0x60, %edi
callq 0x11350
movq %rax, %rbp
movq %rax, %rdi
movq %r12, %rsi
callq 0xa0a7a
leaq 0x10(%rsp), %rsi
movq %rbp, (%rsi)
movq %r15, %rdi
callq 0xa7742
movq %r12, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
leaq 0x40(%rbx), %rbp
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
cmpl $0x30, (%r13)
jne 0xa26ec
incl 0x8(%rbx)
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x9ff30
movl $0x60, %edi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0xa0a7a
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
movq %r15, %rdi
callq 0xa7742
movq %r12, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r13)
movups (%rax), %xmm0
movups %xmm0, (%r13)
addq $0x18, %rax
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3a2e8
cmpl $0xf, (%r13)
jne 0xa272e
addl $0x2, 0x8(%rbx)
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x9ff30
movl $0x60, %edi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0xa23a6
leaq 0x10(%rsp), %rsi
movq %r14, (%rsi)
movq %r15, %rdi
callq 0xa7742
jmp 0xa2736
movq %r12, %rdi
callq 0x9fe44
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa2747
movq %rax, %r12
movl $0x60, %esi
movq %r14, %rdi
jmp 0xa2763
jmp 0xa2785
jmp 0xa2785
movq %rax, %r12
movl $0x60, %esi
movq %rbp, %rdi
callq 0x11360
jmp 0xa2788
jmp 0xa2785
movq %rax, %r12
movq (%r15), %rdi
testq %rdi, %rdi
je 0xa279a
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa279a
movq %rax, %r12
movq 0x8(%rsp), %rdi
callq 0x9ff7c
movq %rbx, %rdi
callq 0xa0994
movq %r12, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::StatBlock::StatBlock(Gos::GosTokenizer&)
Build(StatBlock) {
        Log(StatBlock);
        tokenizer.EatToken(L_CURLY);
        token = tokenizer.GetToken();
        while (token.type != R_CURLY) {
            tokenizer.BackToken();
            Expect(Statement);
            if (gosASTHasError) {
                return;
            }
            token = tokenizer.GetToken();
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7a229(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r12
movq %r12, %rdi
callq 0x9ece0
leaq 0x7a7f0(%rip), %rax     # 0x11d658
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, 0x8(%rsp)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7c36e(%rip)     # 0x11f1f0
je 0xa2e93
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movl $0x36, %esi
callq 0x9fc34
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movups (%rax), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rsp), %rcx
leaq 0x40(%rcx), %r13
addq $0x18, %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0x3a2e8
leaq 0x10(%rsp), %rbp
cmpl $0x37, (%r12)
je 0xa2e84
movq %r15, %rdi
callq 0x9fe44
movl $0x60, %edi
callq 0x11350
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0xa27a2
movq %rbx, 0x10(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
callq 0xa7742
cmpb $0x0, 0x7c2dc(%rip)     # 0x11f1f0
jne 0xa2e84
movq %r15, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movups (%rax), %xmm0
movups %xmm0, (%r12)
addq $0x18, %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0x3a2e8
jmp 0xa2ed6
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa2f80
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa2f80
jmp 0xa2f73
movq %rax, %r15
movl $0x60, %esi
movq %rbx, %rdi
callq 0x11360
jmp 0xa2f76
jmp 0xa2f73
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0xa0994
movq %r15, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::DefArg::DefArg(Gos::GosTokenizer&)
Build(DefArg) {
        Log(DefArg);
        Expect(Symbol);
        tokenizer.EatToken(COLON);
        Expect(Symbol);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7a0cb(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
addq $0x28, %rdi
callq 0x9ece0
leaq 0x7a725(%rip), %rax     # 0x11d6e8
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7c218(%rip)     # 0x11f1f0
jne 0xa3033
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xa0a7a
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xa7742
movq %r15, %rdi
movl $0x30, %esi
callq 0x9fc34
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xa0a7a
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xa7742
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xa3043
jmp 0xa3057
movq %rax, %r15
movl $0x60, %esi
movq %r12, %rdi
callq 0x11360
jmp 0xa305a
jmp 0xa3057
movq %rax, %r15
movq %rbx, %rdi
callq 0xa0994
movq %r15, %rdi
callq 0x11580
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa3062
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa3062
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::DefArgList::DefArgList(Gos::GosTokenizer&)
Build(DefArgList) {
        Log(DefArgList);
        Expect(DefArg);
        while (!tokenizer.IsEOF() && (token = tokenizer.GetToken()).type == COM) {
            Expect(DefArg);
        }
        tokenizer.BackToken();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x79fc9(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r12
movq %r12, %rdi
callq 0x9ece0
leaq 0x7a668(%rip), %rax     # 0x11d730
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, 0x8(%rsp)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7c10e(%rip)     # 0x11f1f0
jne 0xa318b
movl $0x60, %edi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0xa2f88
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
movq %r15, %rdi
callq 0xa7742
movq 0x8(%rsp), %rax
leaq 0x40(%rax), %r13
leaq 0x10(%rsp), %rbp
movq %r14, %rdi
callq 0x9fe50
testb %al, %al
jne 0xa3183
movq %r14, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movups (%rax), %xmm0
movups %xmm0, (%r12)
addq $0x18, %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0x3a2e8
cmpl $0x2d, (%r12)
jne 0xa3183
movl $0x60, %edi
callq 0x11350
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xa2f88
movq %rbx, 0x10(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0xa7742
jmp 0xa311e
movq %r14, %rdi
callq 0x9fe44
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa31d8
movq %rax, %r14
movl $0x60, %esi
movq %r13, %rdi
jmp 0xa31cf
jmp 0xa31d8
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0xa31e5
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa31e5
movq %rax, %r14
movl $0x60, %esi
movq %rbx, %rdi
callq 0x11360
jmp 0xa31db
jmp 0xa31d8
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xa0994
movq %r14, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::ArgsList::ArgsList(Gos::GosTokenizer&)
Build(ArgsList) {
        Log(ArgsList);
        Expect(Exp);
        while (!tokenizer.IsEOF() && (token = tokenizer.GetToken()).type == COM) {
            Expect(Exp);
        }
        tokenizer.BackToken();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x79e5f(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r12
movq %r12, %rdi
callq 0x9ece0
leaq 0x7a546(%rip), %rax     # 0x11d778
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, 0x8(%rsp)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7bfa4(%rip)     # 0x11f1f0
jne 0xa32f5
movl $0x60, %edi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0xa23a6
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
movq %r15, %rdi
callq 0xa7742
movq 0x8(%rsp), %rax
leaq 0x40(%rax), %r13
leaq 0x10(%rsp), %rbp
movq %r14, %rdi
callq 0x9fe50
testb %al, %al
jne 0xa32ed
movq %r14, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movups (%rax), %xmm0
movups %xmm0, (%r12)
addq $0x18, %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0x3a2e8
cmpl $0x2d, (%r12)
jne 0xa32ed
movl $0x60, %edi
callq 0x11350
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xa23a6
movq %rbx, 0x10(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0xa7742
jmp 0xa3288
movq %r14, %rdi
callq 0x9fe44
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa3342
movq %rax, %r14
movl $0x60, %esi
movq %r13, %rdi
jmp 0xa3339
jmp 0xa3342
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0xa334f
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa334f
movq %rax, %r14
movl $0x60, %esi
movq %rbx, %rdi
callq 0x11360
jmp 0xa3345
jmp 0xa3342
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xa0994
movq %r14, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::IDList::IDList(Gos::GosTokenizer&)
Build(IDList) {
        Log(IDList);
        Expect(Symbol);
        while (!tokenizer.IsEOF() && (token = tokenizer.GetToken()).type == COM) {
            Expect(Symbol);
        }
        tokenizer.BackToken();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7963b(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r12
movq %r12, %rdi
callq 0x9ece0
leaq 0x79db2(%rip), %rax     # 0x11d808
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, 0x8(%rsp)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7b780(%rip)     # 0x11f1f0
jne 0xa3b19
movl $0x60, %edi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0xa0a7a
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
movq %r15, %rdi
callq 0xa7742
movq 0x8(%rsp), %rax
leaq 0x40(%rax), %r13
leaq 0x10(%rsp), %rbp
movq %r14, %rdi
callq 0x9fe50
testb %al, %al
jne 0xa3b11
movq %r14, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movups (%rax), %xmm0
movups %xmm0, (%r12)
addq $0x18, %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0x3a2e8
cmpl $0x2d, (%r12)
jne 0xa3b11
movl $0x60, %edi
callq 0x11350
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xa0a7a
movq %rbx, 0x10(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0xa7742
jmp 0xa3aac
movq %r14, %rdi
callq 0x9fe44
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa3b66
movq %rax, %r14
movl $0x60, %esi
movq %r13, %rdi
jmp 0xa3b5d
jmp 0xa3b66
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0xa3b73
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa3b73
movq %rax, %r14
movl $0x60, %esi
movq %rbx, %rdi
callq 0x11360
jmp 0xa3b69
jmp 0xa3b66
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xa0994
movq %r14, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::SingleAttr::SingleAttr(Gos::GosTokenizer&)
Build(SingleAttr) {
        Log(SingleAttr);
        Expect(Symbol);
        token = tokenizer.GetToken();
        if (token.type == L_ROUND) {
            token = tokenizer.GetToken();
            if (token.type != R_ROUND) {
                tokenizer.BackToken();
                Expect(IDList);
                tokenizer.EatToken(R_ROUND);
            }
        } else {
            tokenizer.BackToken();
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x794d2(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r12
movq %r12, %rdi
callq 0x9ece0
leaq 0x79c91(%rip), %rax     # 0x11d850
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7b61c(%rip)     # 0x11f1f0
jne 0xa3cab
movl $0x60, %edi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0xa0a7a
leaq 0x8(%rsp), %rsi
movq %r13, (%rsi)
movq %r15, %rdi
callq 0xa7742
movq %r14, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movups (%rax), %xmm0
movups %xmm0, (%r12)
leaq 0x40(%rbx), %r13
addq $0x18, %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0x3a2e8
cmpl $0x32, (%r12)
jne 0xa3ca3
movq %r14, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movups (%rax), %xmm0
movups %xmm0, (%r12)
addq $0x18, %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0x3a2e8
cmpl $0x33, (%r12)
je 0xa3cab
movq %r14, %rdi
callq 0x9fe44
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0xa3a12
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0xa7742
movq %r14, %rdi
movl $0x33, %esi
callq 0x9fc34
jmp 0xa3cab
movq %r14, %rdi
callq 0x9fe44
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x60, %esi
movq %r12, %rdi
jmp 0xa3cd3
jmp 0xa3cf5
movq %rax, %r14
movl $0x60, %esi
movq %r13, %rdi
callq 0x11360
jmp 0xa3cf8
jmp 0xa3cf5
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0xa3d00
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa3d00
movq %rax, %r14
movq %rbx, %rdi
callq 0xa0994
movq %r14, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Attribute::Attribute(Gos::GosTokenizer&)
Build(Attribute) {
        Log(Attribute);
        tokenizer.EatToken(L_SQUARE);
        Expect(SingleAttr);
        while (!tokenizer.IsEOF() && (token = tokenizer.GetToken()).type != R_SQUARE) {
            if (token.type != COM) {
                GosASTError::ErrorToken(token, { COM, token.line });
                return;
            }
            Expect(SingleAttr);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x79342(%rip), %rax     # 0x11d068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r15
movq %r15, %rdi
callq 0x9ece0
leaq 0x79b49(%rip), %rax     # 0x11d898
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7b48c(%rip)     # 0x11f1f0
jne 0xa3e97
movq %r12, %rdi
movl $0x34, %esi
callq 0x9fc34
movl $0x60, %edi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0xa3b7c
leaq 0x8(%rsp), %rsi
movq %r13, (%rsi)
movq %r14, %rdi
callq 0xa7742
leaq 0x40(%rbx), %r13
movq %r12, %rdi
callq 0x9fe50
testb %al, %al
jne 0xa3e97
movq %r12, %rdi
callq 0x9fbee
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r15)
movups (%rax), %xmm0
movups %xmm0, (%r15)
addq $0x18, %rax
movq %r13, %rdi
movq %rax, %rsi
callq 0x3a2e8
movl (%r15), %eax
cmpl $0x2d, %eax
jne 0xa3e0d
movl $0x60, %edi
callq 0x11350
movq %rax, %rbp
movq %rax, %rdi
movq %r12, %rsi
callq 0xa3b7c
movq %rbp, 0x8(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
callq 0xa7742
jmp 0xa3da3
cmpl $0x35, %eax
je 0xa3e97
movq 0x10(%r15), %rax
leaq 0x28(%rsp), %rdi
movq %rax, -0x8(%rdi)
movups (%r15), %xmm0
movaps %xmm0, -0x18(%rdi)
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
addq %rsi, %rdx
callq 0x37586
movl 0x2c(%rbx), %edx
leaq 0x50(%rsp), %rdi
movl $0x2d, %esi
callq 0x9ecf6
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xa051c
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa3e80
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x11360
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0xa3e97
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa3ecc
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0xa3ecc
movq %rax, %r15
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0xa3f21
movq 0x38(%rsp), %rsi
incq %rsi
jmp 0xa3f15
movq %rax, %r15
movl $0x60, %esi
movq %r13, %rdi
jmp 0xa3f15
jmp 0xa3f1e
jmp 0xa3f1e
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa3f29
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa3f29
movq %rax, %r15
movl $0x60, %esi
movq %rbp, %rdi
callq 0x11360
jmp 0xa3f21
jmp 0xa3f1e
movq %rax, %r15
movq %rbx, %rdi
callq 0xa0994
movq %r15, %rdi
callq 0x11580
nop