LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::PostFix::PrintAST(int)
Print(PostFix) {
        SkipIf(nodes.size() == 1);
        PrintIndent();
        PrintName();
        PrintToken();
        PrintNodes();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0xa3ddd
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movl %ebx, %esi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rdi, %r14
testl %ebx, %ebx
jle 0xa3e08
movq 0x791dd(%rip), %r15     # 0x11cfc8
leaq 0x2b782(%rip), %r12     # 0xcf574
movl %ebx, %ebp
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x113c0
decl %ebp
jne 0xa3df4
movabsq $-0x568e593ac6d15ff7, %rax # imm = 0xA971A6C5392EA009
movq %rsp, %rdi
movq %rax, (%rdi)
movq $0x13, 0x8(%rdi)
leaq 0x2b8a7(%rip), %rax     # 0xcf6ce
movq %rax, 0x10(%rdi)
movw $0x1, 0x18(%rdi)
callq 0x1f5e2
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rdx, %rax
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x27370
movq 0x8(%r15), %rcx
addq $-0xb, %rcx
movq %rsp, %rdi
movl $0xa, %edx
movq %r15, %rsi
callq 0x9a5ee
leaq 0x20(%rsp), %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x11d0f
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x7913c(%rip), %rdi     # 0x11cfc8
callq 0x113c0
movq 0x79130(%rip), %rdi     # 0x11cfc8
leaq 0x2b6d6(%rip), %rsi     # 0xcf575
movl $0x1, %edx
callq 0x113c0
leaq 0x28(%r14), %rsi
movq %rsp, %rdi
callq 0x9e0c2
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x79103(%rip), %r15     # 0x11cfc8
movq %r15, %rdi
callq 0x113c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa3ee8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq 0x790c2(%rip), %rdi     # 0x11cfc8
callq 0x11040
movq %rax, %rdi
callq 0x11260
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0xa3f36
incl %ebx
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r14, %r15
jne 0xa3f22
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xa3f4d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa3f83
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0xa3f83
jmp 0xa3f80
jmp 0xa3f80
jmp 0xa3f80
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xa3f9a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Unary::PrintAST(int)
Print(Unary) {
        SkipIf(token.type != ADD && token.type != SUB && token.type != NOT);
        PrintIndent();
        PrintName();
        PrintToken();
        PrintNodes();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa3ff1
movl 0x28(%r14), %ecx
cmpq $0x27, %rcx
ja 0xa3fd7
movabsq $0x800c000000, %rdx     # imm = 0x800C000000
btq %rcx, %rdx
jb 0xa3ff1
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movl %ebx, %esi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
testl %ebx, %ebx
jle 0xa4019
movq 0x78fcc(%rip), %r15     # 0x11cfc8
leaq 0x2b571(%rip), %r12     # 0xcf574
movl %ebx, %ebp
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x113c0
decl %ebp
jne 0xa4005
movabsq $0x63383b7dd662a3c3, %rax # imm = 0x63383B7DD662A3C3
movq %rsp, %rdi
movq %rax, (%rdi)
movq $0x11, 0x8(%rdi)
leaq 0x2b6df(%rip), %rax     # 0xcf717
movq %rax, 0x10(%rdi)
movw $0x1, 0x18(%rdi)
callq 0x1f5e2
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rdx, %rax
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x27370
movq 0x8(%r15), %rcx
addq $-0xb, %rcx
movq %rsp, %rdi
movl $0xa, %edx
movq %r15, %rsi
callq 0x9a5ee
leaq 0x20(%rsp), %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x11d31
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x78f2b(%rip), %rdi     # 0x11cfc8
callq 0x113c0
movq 0x78f1f(%rip), %rdi     # 0x11cfc8
leaq 0x2b4c5(%rip), %rsi     # 0xcf575
movl $0x1, %edx
callq 0x113c0
leaq 0x28(%r14), %rsi
movq %rsp, %rdi
callq 0x9e0c2
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x78ef2(%rip), %r15     # 0x11cfc8
movq %r15, %rdi
callq 0x113c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa40f9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq 0x78eb1(%rip), %rdi     # 0x11cfc8
callq 0x11040
movq %rax, %rdi
callq 0x11260
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0xa4147
incl %ebx
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r14, %r15
jne 0xa4133
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xa415e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4194
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0xa4194
jmp 0xa4191
jmp 0xa4191
jmp 0xa4191
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xa41ab
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Cast::PrintAST(int)
Print(Cast) {
        SkipIf(token.type != AS);
        PrintIndent();
        PrintName();
        PrintNodes();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa41f0
cmpl $0xe, 0x28(%r14)
je 0xa41f0
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movl %ebx, %esi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
testl %ebx, %ebx
jle 0xa4218
movq 0x78dcd(%rip), %r15     # 0x11cfc8
leaq 0x2b372(%rip), %r12     # 0xcf574
movl %ebx, %ebp
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x113c0
decl %ebp
jne 0xa4204
movabsq $0xce23feacd38c163, %rax # imm = 0xCE23FEACD38C163
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
movq $0x10, 0x8(%rdi)
leaq 0x2b525(%rip), %rax     # 0xcf75e
movq %rax, 0x10(%rdi)
movw $0x1, 0x18(%rdi)
callq 0x1f5e2
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rdx, %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x27370
movq 0x8(%r15), %rcx
addq $-0xb, %rcx
leaq 0x20(%rsp), %rdi
movl $0xa, %edx
movq %r15, %rsi
callq 0x9a5ee
movq %rsp, %r15
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x11d53
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x78d2a(%rip), %r15     # 0x11cfc8
movq %r15, %rdi
callq 0x113c0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq 0x78d04(%rip), %rdi     # 0x11cfc8
callq 0x11040
movq %rax, %rdi
callq 0x11260
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0xa42f4
incl %ebx
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r14, %r15
jne 0xa42e0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa430a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa431b
jmp 0xa431b
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa4334
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Cond::PrintAST(int)
Print(Cond) {
        SkipIf(token.type != QUESTION);
        PrintIndent();
        PrintName();
        PrintNodes();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa5308
cmpl $0x31, 0x28(%r14)
je 0xa5308
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movl %ebx, %esi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
testl %ebx, %ebx
jle 0xa5330
movq 0x77cb5(%rip), %r15     # 0x11cfc8
leaq 0x2a25a(%rip), %r12     # 0xcf574
movl %ebx, %ebp
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x113c0
decl %ebp
jne 0xa531c
movabsq $-0x49895c1563ab82bc, %rax # imm = 0xB676A3EA9C547D44
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
movq $0x10, 0x8(%rdi)
leaq 0x2a604(%rip), %rax     # 0xcf955
movq %rax, 0x10(%rdi)
movw $0x1, 0x18(%rdi)
callq 0x1f5e2
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rdx, %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x27370
movq 0x8(%r15), %rcx
addq $-0xb, %rcx
leaq 0x20(%rsp), %rdi
movl $0xa, %edx
movq %r15, %rsi
callq 0x9a5ee
movq %rsp, %r15
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x11e41
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x77c12(%rip), %r15     # 0x11cfc8
movq %r15, %rdi
callq 0x113c0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq 0x77bec(%rip), %rdi     # 0x11cfc8
callq 0x11040
movq %rax, %rdi
callq 0x11260
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0xa540c
incl %ebx
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r14, %r15
jne 0xa53f8
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa5422
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa5433
jmp 0xa5433
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa544c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Const::PrintAST(int)
Print(Const) {
        SkipIf(true);
        PrintIndent();
        PrintName();
        PrintNodes();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa5486
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movl %ebx, %esi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rdi, %r14
testl %ebx, %ebx
jle 0xa54b1
movq 0x77b34(%rip), %r15     # 0x11cfc8
leaq 0x2a0d9(%rip), %r12     # 0xcf574
movl %ebx, %ebp
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x113c0
decl %ebp
jne 0xa549d
movabsq $0x6048b9a7a3bc158f, %rax # imm = 0x6048B9A7A3BC158F
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
movq $0x11, 0x8(%rdi)
leaq 0x2a4c9(%rip), %rax     # 0xcf99b
movq %rax, 0x10(%rdi)
movw $0x1, 0x18(%rdi)
callq 0x1f5e2
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rdx, %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x27370
movq 0x8(%r15), %rcx
addq $-0xb, %rcx
leaq 0x20(%rsp), %rdi
movl $0xa, %edx
movq %r15, %rsi
callq 0x9a5ee
movq %rsp, %r15
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x11e63
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x77a91(%rip), %r15     # 0x11cfc8
movq %r15, %rdi
callq 0x113c0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq 0x77a6b(%rip), %rdi     # 0x11cfc8
callq 0x11040
movq %rax, %rdi
callq 0x11260
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0xa558d
incl %ebx
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r14, %r15
jne 0xa5579
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa55a3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa55b4
jmp 0xa55b4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa55cd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Exp::PrintAST(int)
Print(Exp) {
        SkipIf(true);
        PrintIndent();
        PrintName();
        PrintNodes();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa5766
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movl %ebx, %esi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rdi, %r14
testl %ebx, %ebx
jle 0xa5791
movq 0x77854(%rip), %r15     # 0x11cfc8
leaq 0x29df9(%rip), %r12     # 0xcf574
movl %ebx, %ebp
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x113c0
decl %ebp
jne 0xa577d
movabsq $0xf8e19a40859d01b, %rax # imm = 0xF8E19A40859D01B
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
movq $0xf, 0x8(%rdi)
leaq 0x2a278(%rip), %rax     # 0xcfa2a
movq %rax, 0x10(%rdi)
movw $0x1, 0x18(%rdi)
callq 0x1f5e2
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rdx, %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x27370
movq 0x8(%r15), %rcx
addq $-0xb, %rcx
leaq 0x20(%rsp), %rdi
movl $0xa, %edx
movq %r15, %rsi
callq 0x9a5ee
movq %rsp, %r15
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x11ea7
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x777b1(%rip), %r15     # 0x11cfc8
movq %r15, %rdi
callq 0x113c0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq 0x7778b(%rip), %rdi     # 0x11cfc8
callq 0x11040
movq %rax, %rdi
callq 0x11260
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0xa586d
incl %ebx
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r14, %r15
jne 0xa5859
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa5883
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa5894
jmp 0xa5894
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa58ad
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::Compiler::Scope::GetVarID(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>>&)
int Gos::Compiler::Scope::GetVarID(const std::string& name, std::string& errorInfo) {
    if (varID.find(name) != varID.end()) {
        return varID[name];
    }
    if (fa != nullptr) {
        return fa->GetVarID(name, errorInfo);
    }
    std::stringstream ss;
    ss << "Error: " << compilingFileName << ": " << compilingLine << ": no such variable: " << name;
    errorInfo = ss.str();
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x9b13a
testq %rax, %rax
jne 0xa6e0e
movq (%r15), %r15
testq %r15, %r15
jne 0xa6d13
leaq 0x20(%rsp), %rdi
callq 0x11280
leaq 0x30(%rsp), %r15
leaq 0x28711(%rip), %rsi     # 0xcf45a
movl $0x7, %edx
movq %r15, %rdi
callq 0x113c0
movq 0x774a3(%rip), %rsi     # 0x11e200
movq 0x774a4(%rip), %rdx     # 0x11e208
movq %r15, %rdi
callq 0x113c0
movq %rax, %r15
leaq 0x16513(%rip), %rsi     # 0xbd289
movl $0x2, %edx
movq %rax, %rdi
callq 0x113c0
movl 0x774ff(%rip), %esi     # 0x11e288
movq %r15, %rdi
callq 0x11550
movq %rax, %r15
leaq 0x29315(%rip), %rsi     # 0xd00b0
movl $0x14, %edx
movq %rax, %rdi
callq 0x113c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x113c0
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x112b0
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11a66
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xa6dec
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq 0x761a5(%rip), %rsi     # 0x11cf98
leaq 0x20(%rsp), %rdi
callq 0x112c0
leaq 0xa0(%rsp), %rdi
callq 0x11120
xorl %eax, %eax
jmp 0xa6e1b
movq %r12, %rdi
movq %r14, %rsi
callq 0x9b46a
movl (%rax), %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xa6e2c
movq %rax, %rbx
movq 0x76162(%rip), %rsi     # 0x11cf98
leaq 0x20(%rsp), %rdi
callq 0x112c0
leaq 0xa0(%rsp), %rdi
callq 0x11120
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::Compiler::Scope::GetVarType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Gos::Compiler::Scope::GetVarType(const std::string& name) {
    if (varType.find(name) != varType.end()) {
        return varType[name];
    }
    if (fa != nullptr) {
        return fa->GetVarType(name);
    }
    std::cerr << "Error: " << compilingFileName << ": " << compilingLine << ": unknown variable type of " << name << std::endl;
    return "unknown";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x60(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xac916
testq %rax, %rax
jne 0xa6f4c
movq (%r15), %r15
testq %r15, %r15
jne 0xa6e67
movq 0x76162(%rip), %r15     # 0x11cff0
leaq 0x285c5(%rip), %rsi     # 0xcf45a
movl $0x7, %edx
movq %r15, %rdi
callq 0x113c0
movq 0x77357(%rip), %rsi     # 0x11e200
movq 0x77358(%rip), %rdx     # 0x11e208
movq %r15, %rdi
callq 0x113c0
movq %rax, %r15
leaq 0x163c7(%rip), %rsi     # 0xbd289
movl $0x2, %edx
movq %rax, %rdi
callq 0x113c0
movl 0x773b3(%rip), %esi     # 0x11e288
movq %r15, %rdi
callq 0x11550
movq %rax, %r15
leaq 0x291de(%rip), %rsi     # 0xd00c5
movl $0x1b, %edx
movq %rax, %rdi
callq 0x113c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x113c0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq %r14, %rdi
callq 0x11040
movq %rax, %rdi
callq 0x11260
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x291a6(%rip), %rsi     # 0xd00e1
leaq 0x291a6(%rip), %rdx     # 0xd00e8
movq %rbx, %rdi
callq 0x27370
jmp 0xa6f70
movq %r12, %rdi
movq %r14, %rsi
callq 0xaca12
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x36954
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::Compiler::VMCompiler::MoveToNew()
void Gos::Compiler::VMCompiler::MoveToNew() {
    currentScope->subScopes.push_back(Scope());
    Scope* newScope = &currentScope->subScopes.back();
    newScope->pos = currentScope->pos;
    newScope->fa = currentScope;
    currentScope = newScope;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq 0xd0(%rdi), %r14
addq $0x8, %r14
leaq 0x60(%rsp), %r12
leaq 0x8(%rsp), %r15
movl $0xc0, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x111d0
movq %r12, 0x28(%r15)
movl $0x1, %eax
movq %rax, 0x30(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r15)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, 0x48(%r15)
movups %xmm0, 0x50(%r15)
leaq 0x98(%rsp), %rdx
movq %rdx, -0x30(%rdx)
movq %rax, -0x28(%rdx)
movups %xmm0, -0x20(%rdx)
movl %ecx, -0x10(%rdx)
movups %xmm0, -0x8(%rdx)
leaq 0xd0(%rsp), %rdx
movq %rdx, -0x30(%rdx)
movq %rax, -0x28(%rdx)
movups %xmm0, -0x20(%rdx)
movl %ecx, -0x10(%rdx)
movups %xmm0, -0x8(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0xacd62
leaq 0x30(%rsp), %r14
leaq 0x68(%rsp), %r15
leaq 0xa0(%rsp), %rdi
leaq 0x10(%rsp), %r12
callq 0xac664
movq %r15, %rdi
callq 0xac6d8
movq %r14, %rdi
callq 0xac664
movq %r12, %rdi
callq 0xac5fa
movq 0xd0(%rbx), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rax), %rdx
leaq -0xd0(%rcx), %rsi
movq %rdx, -0xb0(%rcx)
movq %rax, -0xd0(%rcx)
movq %rsi, 0xd0(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xabfd2
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Number::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Number) {
    compilingLine = token.line;
    int id = pc++;
    vm.WriteCommandNewNum(token.numType, id, token.num);
    return id;
}

// Assembly:
pushq %rbx
movl 0x2c(%rdi), %eax
movl %eax, 0x76d1a(%rip)     # 0x11e288
movl 0xe0(%rsi), %ebx
leal 0x1(%rbx), %eax
movl %eax, 0xe0(%rsi)
movq 0xe8(%rsi), %rax
movsbl 0x30(%rdi), %esi
movq 0x38(%rdi), %rcx
movq %rax, %rdi
movl %ebx, %edx
callq 0x9942a
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::String::CompileAST(Gos::Compiler::VMCompiler&)
Compile(String) {
    compilingLine = token.line;
    int id = pc++;
    vm.WriteCommandNewStr(id, token.str);
    return id;
}

// Assembly:
pushq %rbx
movl 0x2c(%rdi), %eax
movl %eax, 0x76ce4(%rip)     # 0x11e288
movl 0xe0(%rsi), %ebx
leal 0x1(%rbx), %eax
movl %eax, 0xe0(%rsi)
movq 0xe8(%rsi), %rax
leaq 0x40(%rdi), %rdx
movq %rax, %rdi
movl %ebx, %esi
callq 0x99376
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Primary::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Primary) {
    START();
    if (branch & 1) {
        std::vector<int> params;
        if (branch & 2) {
            GosAST* argsList = nodes[1];
            for (auto* expr : argsList->nodes) {
                params.push_back(expr->CompileAST(code));
            }
        }
        int id = code.GetTmpVar();
        vm.WriteCommandNew(nodes[0]->token.str, id, params);
        return id;
    }
    return SUB(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl 0x2c(%rdi), %eax
movl %eax, 0x76ca5(%rip)     # 0x11e288
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa7617
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %ecx
testb $0x1, %cl
jne 0xa761f
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %r15d, %r15d
jmp 0xa76f3
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testb $0x2, %cl
je 0xa768d
movq 0x8(%rax), %rax
movq 0x10(%rax), %r13
movq 0x18(%rax), %rbp
cmpq %rbp, %r13
je 0xa768d
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq (%r13), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0xa7679
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0xa7684
movq %r15, %rdi
movq %r12, %rdx
callq 0xad1be
addq $0x8, %r13
cmpq %rbp, %r13
jne 0xa7650
leaq 0x100(%rbx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0xa76ac
cmpb $0x0, 0xc(%rax)
jne 0xa7694
movb $0x1, 0xc(%rax)
movl 0x8(%rax), %r15d
jmp 0xa76bd
movl 0xe0(%rbx), %r15d
leal 0x1(%r15), %eax
movl %eax, 0xe0(%rbx)
movq 0xe8(%rbx), %rdi
movq 0x10(%r14), %rax
movq (%rax), %rsi
addq $0x40, %rsi
leaq 0x10(%rsp), %rcx
movl %r15d, %edx
callq 0x99248
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xa76f3
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa7707
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xa7721
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Cast::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Cast) {
    START();
    if (token.type == AS) {
        int tmp = code.GetTmpVar();
        vm.WriteCommandNew(nodes[1]->token.str, tmp, {});
        vm.WriteCommandMov(tmp, SUB(0));
        return tmp;
    }
    return SUB(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x2c(%rdi), %eax
movl %eax, 0x76360(%rip)     # 0x11e288
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa7f5d
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xe, 0x28(%rdi)
jne 0xa7f65
leaq 0x100(%rbx), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xa7f7e
cmpb $0x0, 0xc(%rcx)
jne 0xa7f45
movb $0x1, 0xc(%rcx)
movl 0x8(%rcx), %r15d
jmp 0xa7f8f
xorl %r15d, %r15d
jmp 0xa7ff0
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movl 0xe0(%rbx), %r15d
leal 0x1(%r15), %ecx
movl %ecx, 0xe0(%rbx)
movq 0xe8(%rbx), %rdi
movq 0x8(%rax), %rsi
addq $0x40, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movl %r15d, %edx
callq 0x99248
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xa7fcd
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
movq 0xe8(%rbx), %r12
movq 0x10(%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x994b4
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xa8018
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Mul::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Mul) {
    START();
    if (tokenList.size() == 0) {
        return SUB(0);
    }
    int tmp = code.GetTmpVar();
    vm.WriteCommandClone(tmp, SUB(0));
    for (int i = 0; i < tokenList.size(); i++) {
        if (tokenList[i].type == MUL) {
            vm.WriteCommandMul(tmp, SUB(i + 1));
        } else if (tokenList[i].type == DIV) {
            vm.WriteCommandDiv(tmp, SUB(i + 1));
        } else if (tokenList[i].type == REM) {
            vm.WriteCommandRem(tmp, SUB(i + 1));
        }
    }
    return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2c(%rdi), %eax
movl %eax, 0x76254(%rip)     # 0x11e288
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa806d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rcx
cmpq 0x60(%rdi), %rcx
je 0xa8075
leaq 0x100(%rbx), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xa8091
cmpb $0x0, 0xc(%rcx)
jne 0xa8055
movb $0x1, 0xc(%rcx)
movl 0x8(%rcx), %r15d
jmp 0xa80a2
xorl %r15d, %r15d
jmp 0xa8187
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl 0xe0(%rbx), %r15d
leal 0x1(%r15), %ecx
movl %ecx, 0xe0(%rbx)
movq 0xe8(%rbx), %r12
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x99588
movq 0x60(%r14), %rax
cmpq %rax, 0x68(%r14)
je 0xa8187
xorl %r13d, %r13d
xorl %ebp, %ebp
movl (%rax,%r13), %eax
cmpl $0x1f, %eax
je 0xa8135
cmpl $0x1e, %eax
je 0xa810e
cmpl $0x1c, %eax
jne 0xa815a
movq 0xe8(%rbx), %r12
movq 0x10(%r14), %rax
movq 0x8(%rax,%rbp,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x99812
jmp 0xa815a
movq 0xe8(%rbx), %r12
movq 0x10(%r14), %rax
movq 0x8(%rax,%rbp,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x9987c
jmp 0xa815a
movq 0xe8(%rbx), %r12
movq 0x10(%r14), %rax
movq 0x8(%rax,%rbp,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x998e6
incq %rbp
movq 0x60(%r14), %rax
movq 0x68(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdx, %rcx
addq $0x38, %r13
cmpq %rbp, %rcx
ja 0xa80d4
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Add::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Add) {
    START();
    if (tokenList.size() == 0) {
        return SUB(0);
    }
    int tmp = code.GetTmpVar();
    vm.WriteCommandClone(tmp, SUB(0));
    for (int i = 0; i < tokenList.size(); i++) {
        if (tokenList[i].type == ADD) {
            vm.WriteCommandAdd(tmp, SUB(i + 1));
        } else if (tokenList[i].type == SUB) {
            vm.WriteCommandSub(tmp, SUB(i + 1));
        }
    }
    return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2c(%rdi), %eax
movl %eax, 0x760da(%rip)     # 0x11e288
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa81e7
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rcx
cmpq 0x60(%rdi), %rcx
je 0xa81ef
leaq 0x100(%rbx), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xa820b
cmpb $0x0, 0xc(%rcx)
jne 0xa81cf
movb $0x1, 0xc(%rcx)
movl 0x8(%rcx), %r15d
jmp 0xa821c
xorl %r15d, %r15d
jmp 0xa82d5
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl 0xe0(%rbx), %r15d
leal 0x1(%r15), %ecx
movl %ecx, 0xe0(%rbx)
movq 0xe8(%rbx), %r12
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x99588
movq 0x60(%r14), %rax
cmpq %rax, 0x68(%r14)
je 0xa82d5
xorl %r13d, %r13d
xorl %ebp, %ebp
movl (%rax,%r13), %eax
cmpl $0x1b, %eax
je 0xa8283
cmpl $0x1a, %eax
jne 0xa82a8
movq 0xe8(%rbx), %r12
movq 0x10(%r14), %rax
movq 0x8(%rax,%rbp,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x9973e
jmp 0xa82a8
movq 0xe8(%rbx), %r12
movq 0x10(%r14), %rax
movq 0x8(%rax,%rbp,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x997a8
incq %rbp
movq 0x60(%r14), %rax
movq 0x68(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdx, %rcx
addq $0x38, %r13
cmpq %rbp, %rcx
ja 0xa824e
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::LogicAnd::CompileAST(Gos::Compiler::VMCompiler&)
Compile(LogicAnd) {
    START();
    if (tokenList.size() == 0) {
        return SUB(0);
    }
    int tmp = code.GetTmpVar();
    vm.WriteCommandClone(tmp, SUB(0));
    for (int i = 0; i < tokenList.size(); i++) {
        vm.WriteCommandAnd(tmp, SUB(i + 1));
    }
    return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2c(%rdi), %eax
movl %eax, 0x75888(%rip)     # 0x11e288
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa8a39
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rcx
cmpq 0x60(%rdi), %rcx
je 0xa8a41
leaq 0x100(%rbx), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xa8a5d
cmpb $0x0, 0xc(%rcx)
jne 0xa8a21
movb $0x1, 0xc(%rcx)
movl 0x8(%rcx), %r15d
jmp 0xa8a6e
xorl %r15d, %r15d
jmp 0xa8ae1
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl 0xe0(%rbx), %r15d
leal 0x1(%r15), %ecx
movl %ecx, 0xe0(%rbx)
movq 0xe8(%rbx), %r12
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x99588
movq 0x68(%r14), %rax
cmpq 0x60(%r14), %rax
je 0xa8ae1
xorl %r13d, %r13d
movabsq $0x6db6db6db6db6db7, %rbp # imm = 0x6DB6DB6DB6DB6DB7
movq 0xe8(%rbx), %r12
movq 0x10(%r14), %rax
movq 0x8(%rax,%r13,8), %rdi
incq %r13
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x999ba
movq 0x68(%r14), %rax
subq 0x60(%r14), %rax
sarq $0x3, %rax
imulq %rbp, %rax
cmpq %r13, %rax
ja 0xa8aa4
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::LogicOr::CompileAST(Gos::Compiler::VMCompiler&)
Compile(LogicOr) {
    START();
    if (tokenList.size() == 0) {
        return SUB(0);
    }
    int tmp = code.GetTmpVar();
    vm.WriteCommandClone(tmp, SUB(0));
    for (int i = 0; i < tokenList.size(); i++) {
        vm.WriteCommandOr(tmp, SUB(i + 1));
    }
    return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2c(%rdi), %eax
movl %eax, 0x75780(%rip)     # 0x11e288
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa8b41
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rcx
cmpq 0x60(%rdi), %rcx
je 0xa8b49
leaq 0x100(%rbx), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xa8b65
cmpb $0x0, 0xc(%rcx)
jne 0xa8b29
movb $0x1, 0xc(%rcx)
movl 0x8(%rcx), %r15d
jmp 0xa8b76
xorl %r15d, %r15d
jmp 0xa8be9
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl 0xe0(%rbx), %r15d
leal 0x1(%r15), %ecx
movl %ecx, 0xe0(%rbx)
movq 0xe8(%rbx), %r12
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x99588
movq 0x68(%r14), %rax
cmpq 0x60(%r14), %rax
je 0xa8be9
xorl %r13d, %r13d
movabsq $0x6db6db6db6db6db7, %rbp # imm = 0x6DB6DB6DB6DB6DB7
movq 0xe8(%rbx), %r12
movq 0x10(%r14), %rax
movq 0x8(%rax,%r13,8), %rdi
incq %r13
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r12, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x99a24
movq 0x68(%r14), %rax
subq 0x60(%r14), %rax
sarq $0x3, %rax
imulq %rbp, %rax
cmpq %r13, %rax
ja 0xa8bac
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Cond::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Cond) {
    START();
    if (branch == 1) {
        int tmp = code.GetTmpVar();
        int val = SUB(0);
        auto ifJmp = vm.WriteCommandIf(val);
        vm.WriteCommandClone(tmp, SUB(2));
        auto outJmp = vm.WriteCommandJmp();
        ifJmp(vm.GetProgress());
        vm.WriteCommandClone(tmp, SUB(1));
        outJmp(vm.GetProgress());
        return tmp;
    }
    return SUB(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x2c(%rdi), %eax
movl %eax, 0x75678(%rip)     # 0x11e288
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa8c44
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x1, 0x8(%rdi)
jne 0xa8c4b
leaq 0x100(%r14), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xa8c64
cmpb $0x0, 0xc(%rcx)
jne 0xa8c2d
movb $0x1, 0xc(%rcx)
movl 0x8(%rcx), %ebx
jmp 0xa8c75
xorl %ebx, %ebx
jmp 0xa8d6a
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %r14, %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movl 0xe0(%r14), %ebx
leal 0x1(%rbx), %ecx
movl %ecx, 0xe0(%r14)
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
movq 0xe8(%r14), %rsi
leaq 0x28(%rsp), %rdi
movl %eax, %edx
callq 0x99b74
movq 0xe8(%r14), %r12
movq 0x10(%r15), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
movq %r12, %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x99588
movq 0xe8(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x99b0a
movq 0xe8(%r14), %rdi
callq 0x99f3a
movl %eax, 0x4(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0xa8d78
leaq 0x28(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq *0x18(%rdi)
movq 0xe8(%r14), %r12
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
movq %r12, %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x99588
movq 0xe8(%r14), %rdi
callq 0x99f3a
movl %eax, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xa8d78
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq *0x18(%rdi)
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xa8d51
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xa8d6a
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x11150
jmp 0xa8dc7
jmp 0xa8dc7
jmp 0xa8d83
movq %rax, %rbx
jmp 0xa8da4
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xa8da4
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xa8dbd
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
jmp 0xa8dc7
movq %rax, %rdi
callq 0x26e38
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Assign::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Assign) {
    START();
    int dest = SUB(0);
    int src = SUB(1);
    switch (token.type) {
        case ASSIGN:     vm.WriteCommandMov(dest, src); break;
        case ASSIGN_ADD: vm.WriteCommandAdd(dest, src); break;
        case ASSIGN_SUB: vm.WriteCommandSub(dest, src); break;
        case ASSIGN_MUL: vm.WriteCommandMul(dest, src); break;
        case ASSIGN_DIV: vm.WriteCommandDiv(dest, src); break;
        case ASSIGN_REM: vm.WriteCommandRem(dest, src); break;
        case ASSIGN_XOR: vm.WriteCommandXor(dest, src); break;
        case ASSIGN_AND: vm.WriteCommandAnd(dest, src); break;
        case ASSIGN_OR:  vm.WriteCommandOr(dest, src);  break;
        default: return dest;
    }
    return dest;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x2c(%rdi), %eax
movl %eax, 0x75488(%rip)     # 0x11e288
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xa8e58
movq %rsi, %r14
movq %rdi, %r15
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebx
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
movl 0x28(%r15), %ecx
addl $-0xf, %ecx
cmpl $0x8, %ecx
ja 0xa8e5a
leaq 0x26fa3(%rip), %rdx     # 0xcfde0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x994b4
jmp 0xa8e5a
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x9987c
jmp 0xa8e5a
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x997a8
jmp 0xa8e5a
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x99812
jmp 0xa8e5a
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x999ba
jmp 0xa8e5a
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x9973e
jmp 0xa8e5a
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x998e6
jmp 0xa8e5a
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x99950
jmp 0xa8e5a
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x99a24
jmp 0xa8e5a
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::StatBlock::CompileAST(Gos::Compiler::VMCompiler&)
Compile(StatBlock) {
    compilingLine = token.line;
    blockDepth++;
    for (auto* ast : nodes) {
        ast->CompileAST(code);
    }
    blockDepth--;
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x2c(%rdi), %eax
movl %eax, 0x73f1e(%rip)     # 0x11e288
movl 0x73fd0(%rip), %eax     # 0x11e340
leal 0x1(%rax), %ecx
movl %ecx, 0x73fc7(%rip)     # 0x11e340
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0xaa3a5
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0xaa389
movl 0x73f9d(%rip), %eax     # 0x11e340
decl %eax
movl %eax, 0x73f95(%rip)     # 0x11e340
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::SingleAttr::CompileAST(Gos::Compiler::VMCompiler&)
Compile(SingleAttr) {
    START();
    std::string attr = nodes[0]->token.str;
    std::vector<std::string> attrs;
    if (nodes.size() > 1) {
        for (int i = 0; i < nodes[1]->nodes.size(); i++) {
            attrs.push_back(nodes[1]->nodes[i]->token.str);
        }
    }
    vm.WriteCommandAttributes(attr, attrs);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl 0x2c(%rdi), %eax
movl %eax, 0x729c2(%rip)     # 0x11e288
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xab993
movq %rsi, %rbx
movq %rdi, %r14
movq (%rax), %rax
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x36954
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
cmpq $0x9, %rcx
jb 0xab960
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rax
cmpq %rax, 0x18(%rcx)
je 0xab960
xorl %r13d, %r13d
movq %rsp, %r15
movq (%rax,%r13,8), %rsi
addq $0x40, %rsi
movq %r15, %rdi
callq 0x9a724
incq %r13
movq 0x10(%r14), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0xab931
movq 0xe8(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x99dfe
movq %rsp, %rdi
callq 0x367d6
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xab993
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11360
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xab9a5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x367d6
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xab9c7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Attribute::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Attribute) {
    START();
    for (int i = 0; i < nodes.size(); i++) {
        SUB(i);
    }
    return 0;
}

// Assembly:
movl 0x2c(%rdi), %eax
movl %eax, 0x728af(%rip)     # 0x11e288
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xaba19
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
incq %r15
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0xab9f1
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosScript::SetScriptName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Gos::GosScript::SetScriptName(const std::string& name) {
    GosASTError::SetFileName(name);
    scriptName = name;
    int pos = name.length() - 1;
    while (name[pos] != '.' && pos > 0) {
        pos--;
    }
    if (pos == 0) {
        pos = name.length();
    }
    scriptNameClass = TypeID::getRaw(std::string_view(scriptName).substr(0, pos));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x9f73c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39678
movl 0x8(%r14), %ecx
movq (%r14), %rdx
movl %ecx, %eax
decl %eax
testl %eax, %eax
jle 0xae111
movslq %eax, %rsi
cmpb $0x2e, (%rdx,%rsi)
jne 0xae102
testl %eax, %eax
cmovnel %eax, %ecx
movabsq $-0x340d631b7bdddcdb, %rdx # imm = 0xCBF29CE484222325
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
movslq %ecx, %rcx
cmpq %rcx, %rsi
cmovbq %rsi, %rcx
testq %rcx, %rcx
je 0xae15b
xorl %esi, %esi
movabsq $0x100000001b3, %rdi    # imm = 0x100000001B3
movsbq (%rax,%rsi), %r8
xorq %rdx, %r8
imulq %rdi, %r8
incq %rsi
movq %r8, %rdx
cmpq %rsi, %rcx
jne 0xae142
jmp 0xae15e
movq %rdx, %r8
movq %r8, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movw $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosScript::GetClassInfo() const
const GosVM::GosClass& Gos::GosScript::GetClassInfo() const {
    auto& info = GosVM::GosClass::classInfo;
    if (info.find(scriptNameClass) == info.end()) {
        std::cerr << "Error: no such class defined in script " << scriptName << ": " << scriptNameClass.getName() << std::endl;
        return info[TypeID::get<void>()];
    }
    return info[scriptNameClass];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
leaq 0x6f3cb(%rip), %rdi     # 0x11d5a0
movq %rbx, %rsi
callq 0x9c832
testq %rax, %rax
je 0xae1fa
leaq 0x6f3b7(%rip), %rdi     # 0x11d5a0
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x9c8f2
movq 0x6edef(%rip), %r15     # 0x11cff0
leaq 0x21f87(%rip), %rsi     # 0xd018f
movl $0x27, %edx
movq %r15, %rdi
callq 0x113c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x113c0
movq %rax, %r14
leaq 0xf05b(%rip), %rsi      # 0xbd289
movl $0x2, %edx
movq %rax, %rdi
callq 0x113c0
movq %rbx, %rdi
callq 0x1f5e2
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x113c0
movq %rax, %rbx
movq (%rax), %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
movabsq $0x3173c900e37ae1df, %rax # imm = 0x3173C900E37AE1DF
movq %rsp, %rsi
movq %rax, (%rsi)
movq $0x4, 0x8(%rsi)
leaq 0xdabd(%rip), %rax      # 0xbbd57
movq %rax, 0x10(%rsi)
movw $0x0, 0x18(%rsi)
leaq 0x6f2f5(%rip), %rdi     # 0x11d5a0
callq 0xaf704
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosScript::Read(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Gos::GosScript::Read(std::istream& fin, std::string inputFileName) {
    GosTokenizer tokenizer(fin, inputFileName);
    SetScriptName(inputFileName);
    Compiler::VMCompiler compiler(vm);
    GosAST ast;
    ast.Build(tokenizer);
    ast.CompileAST(compiler);
    // ast.PrintAST();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %rdi
callq 0x9e2ba
movq %rbx, %rdi
movq %r14, %rsi
callq 0xae0dc
addq $0x40, %rbx
leaq 0xd0(%rsp), %rdi
movq %rbx, %rsi
callq 0xa70fe
leaq 0x6dcd6(%rip), %rax     # 0x11c058
addq $0x10, %rax
leaq 0x28(%rsp), %rdi
movq %rax, -0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, -0x18(%rdi)
movq $0x0, -0x8(%rdi)
callq 0x9e04c
movq %rsp, %rdi
leaq 0x60(%rsp), %rsi
callq 0x9fbfc
movq %rsp, %rdi
leaq 0xd0(%rsp), %rsi
callq 0x9fa2c
movq %rsp, %rdi
callq 0x9fcf4
leaq 0x210(%rsp), %rbx
movq %rbx, %rdi
callq 0xaf41a
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xae3f1
movq 0x208(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
leaq 0x1c0(%rsp), %rdi
callq 0xaf44a
leaq 0x168(%rsp), %rdi
callq 0xac664
leaq 0x130(%rsp), %rdi
callq 0xac6d8
leaq 0xf8(%rsp), %rdi
callq 0xac664
leaq 0xd8(%rsp), %rdi
callq 0xac5fa
movq 0xc0(%rsp), %rax
testq %rax, %rax
je 0xae451
leaq 0xb0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0x9f306
movq -0x28(%rbx), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0xae482
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x26e38
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xae4c3
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xae4c3
jmp 0xae4b3
movq %rax, %rbx
jmp 0xae4d0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9fcf4
leaq 0xd0(%rsp), %rdi
callq 0xaf11c
leaq 0x60(%rsp), %rdi
callq 0xaf17e
movq %rbx, %rdi
callq 0x11580