LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/apps/mshview/mshview.cpp
// Function: GLUTMainLoop()
void GLUTMainLoop(void)
{
  // Set world origin
  if (initial_world_origin != R3unknown_point) {
    world_origin = initial_world_origin;
  }
  else if (meshes.NEntries() > 0) {
    world_origin = meshes[0]->BBox().Centroid();
  }

  // Run main loop -- never returns 
  glutMainLoop();
}

// Assembly:
subq $0x18, %rsp
leaq 0x1d1265(%rip), %rdi    # 0x1fac00
leaq 0x1d4f76(%rip), %rsi    # 0x1fe918
callq 0xcbca0
cmpl $0x0, %eax
je 0x299c1
leaq 0x1d1275(%rip), %rdi    # 0x1fac28
leaq 0x1d1246(%rip), %rsi    # 0x1fac00
callq 0xcc120
jmp 0x29a05
leaq 0x1d1250(%rip), %rdi    # 0x1fac18
callq 0x2a760
cmpl $0x0, %eax
jle 0x29a03
leaq 0x1d123f(%rip), %rdi    # 0x1fac18
xorl %esi, %esi
callq 0x2a780
movq (%rax), %rdi
callq 0x2aa70
movq %rax, %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x68(%rax)
leaq 0x1d122d(%rip), %rdi    # 0x1fac28
movq %rsp, %rsi
callq 0xcc120
jmp 0x29a05
callq 0x17e210
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/apps/mshview/mshview.cpp
// Function: ReadMeshes(gaps::RNArray<char*> const&)
int
ReadMeshes(const RNArray<char *>& mesh_names)
{
  // Read each mesh
  for (int i = 0; i < mesh_names.NEntries(); i++) {
    char *mesh_name = mesh_names[i];

    // Allocate mesh
    R3Mesh *mesh = new R3Mesh();
    assert(mesh);

    // Read mesh from file
    if (!mesh->ReadFile(mesh_name)) {
      delete mesh;
      return 0;
    }

    // Add mesh to list
    meshes.Insert(mesh);

    // Print statistics
    if (print_verbose) {
      printf("Read mesh from %s ...\n", mesh_name);
      printf("  # Faces = %d\n", mesh->NFaces());
      printf("  # Edges = %d\n", mesh->NEdges());
      printf("  # Vertices = %d\n", mesh->NVertices());
      fflush(stdout);
    }
  }

  // Return number of meshes
  return meshes.NEntries();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2a760
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x29b76
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x2af20
movq %rax, 0x28(%rsp)
movl $0x138, %edi            # imm = 0x138
callq 0x229d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x7cf70
jmp 0x29a70
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *0x180(%rax)
cmpl $0x0, %eax
jne 0x29ada
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x29aab
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, 0x44(%rsp)
jmp 0x29b86
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x138, %esi            # imm = 0x138
callq 0x229f0
jmp 0x29b8f
movq 0x20(%rsp), %rsi
leaq 0x1d1132(%rip), %rdi    # 0x1fac18
callq 0x2af40
cmpl $0x0, 0x1d18a6(%rip)    # 0x1fb398
je 0x29b64
movq 0x28(%rsp), %rsi
leaq 0x163794(%rip), %rdi    # 0x18d294
movb $0x0, %al
callq 0x22090
movq 0x20(%rsp), %rdi
callq 0x2a7c0
movl %eax, %esi
leaq 0x163791(%rip), %rdi    # 0x18d2ab
movb $0x0, %al
callq 0x22090
movq 0x20(%rsp), %rdi
callq 0x2a9c0
movl %eax, %esi
leaq 0x163787(%rip), %rdi    # 0x18d2bb
movb $0x0, %al
callq 0x22090
movq 0x20(%rsp), %rdi
callq 0x2ab00
movl %eax, %esi
leaq 0x16377d(%rip), %rdi    # 0x18d2cb
movb $0x0, %al
callq 0x22090
movq 0x1ca434(%rip), %rax    # 0x1f3f90
movq (%rax), %rdi
callq 0x22be0
jmp 0x29b66
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x29a21
leaq 0x1d109b(%rip), %rdi    # 0x1fac18
callq 0x2a760
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x23260
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/mshview/mshview.cpp
// Function: main
int main(int argc, char **argv)
{
  // Initialize packages
  if (!R3InitGraphics()) exit(-1);

  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Initialize GLUT
  GLUTInit(&argc, argv);

  // Read mesh
  if (!ReadMeshes(mesh_names)) exit(-1);

  // Create viewer
  viewer = CreateBirdsEyeViewer(meshes[0]);
  if (!viewer) exit(-1);

  // Run GLUT interface
  GLUTMainLoop();

  // Return success 
  return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
callq 0x2b3f0
cmpl $0x0, %eax
jne 0x2a4b9
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c40
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x29ba0
cmpl $0x0, %eax
jne 0x2a4d6
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c40
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x297c0
leaq 0x1d06a4(%rip), %rdi    # 0x1fab90
callq 0x29a10
cmpl $0x0, %eax
jne 0x2a500
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c40
leaq 0x1d0711(%rip), %rdi    # 0x1fac18
xorl %esi, %esi
callq 0x2a780
movq (%rax), %rdi
callq 0x2a540
movq %rax, 0x1d0deb(%rip)    # 0x1fb308
cmpq $0x0, 0x1d0de3(%rip)    # 0x1fb308
jne 0x2a531
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c40
callq 0x29990
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/mshview/mshview.cpp
// Function: CreateBirdsEyeViewer(gaps::R3Mesh*)
static R3Viewer *
CreateBirdsEyeViewer(R3Mesh *mesh)
{
    // Setup camera view looking down the Z axis
    R3Box bbox = mesh->BBox();
    assert(!bbox.IsEmpty());
    RNLength r = bbox.DiagonalRadius();
    assert((r > 0.0) && RNIsFinite(r));
    if (!initial_camera) initial_camera_origin = bbox.Centroid() - initial_camera_towards * (2.5 * r);
    R3Camera camera(initial_camera_origin, initial_camera_towards, initial_camera_up, 0.4, 0.4, 0.01 * r, 100.0 * r);
    R2Viewport viewport(0, 0, GLUTwindow_width, GLUTwindow_height);
    return new R3Viewer(camera, viewport);
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x150(%rsp)
movq 0x150(%rsp), %rdi
callq 0x2aa70
movq %rax, %rsi
leaq 0x118(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb64e0
movq 0x8(%rsp), %rdi
callq 0x2ad20
movsd %xmm0, 0x10(%rsp)
jmp 0x2a583
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x110(%rsp)
cmpl $0x0, 0x1d0e03(%rip)    # 0x1fb39c
jne 0x2a631
leaq 0xd0(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0xb7e80
jmp 0x2a5b6
movsd 0x110(%rsp), %xmm0
movsd 0x162ab1(%rip), %xmm1   # 0x18d078
mulsd %xmm1, %xmm0
leaq 0x1d05fe(%rip), %rsi    # 0x1fabd0
leaq 0xb8(%rsp), %rdi
callq 0xcdac0
jmp 0x2a5e1
leaq 0xe8(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0xb8(%rsp), %rdx
callq 0xcc9f0
jmp 0x2a600
leaq 0x1d05b1(%rip), %rdi    # 0x1fabb8
leaq 0xe8(%rsp), %rsi
callq 0xcc120
jmp 0x2a616
jmp 0x2a631
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
jmp 0x2a6fe
movsd 0x110(%rsp), %xmm3
movsd 0x1629fe(%rip), %xmm0   # 0x18d040
movaps %xmm3, %xmm2
mulsd %xmm0, %xmm2
movsd 0x162a2f(%rip), %xmm0   # 0x18d080
mulsd %xmm0, %xmm3
leaq 0x1d055c(%rip), %rsi    # 0x1fabb8
leaq 0x1d056d(%rip), %rdx    # 0x1fabd0
leaq 0x1d057e(%rip), %rcx    # 0x1fabe8
leaq 0x28(%rsp), %rdi
movsd 0x1629f1(%rip), %xmm1   # 0x18d068
movaps %xmm1, %xmm0
callq 0x2ed50
jmp 0x2a681
movl 0x1ca431(%rip), %ecx    # 0x1f4ab8
movl 0x1ca42e(%rip), %r8d    # 0x1f4abc
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x303c0
jmp 0x2a69e
movl $0xa8, %edi
callq 0x229d0
movq %rax, (%rsp)
jmp 0x2a6ae
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x2b550
jmp 0x2a6c3
leaq 0x118(%rsp), %rdi
callq 0x2b360
movq (%rsp), %rax
addq $0x158, %rsp            # imm = 0x158
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
movl $0xa8, %esi
callq 0x229f0
leaq 0x118(%rsp), %rdi
callq 0x2b360
movq 0x108(%rsp), %rdi
callq 0x23260
nopl (%rax,%rax)
// File: philpoore[P]Math/./src/Token.hpp
// Function: Token::isBinOp()
bool Token::isBinOp() {
    switch (type) {
        case TOKEN_ADD:
        case TOKEN_SUB:
        case TOKEN_MUL:
        case TOKEN_DIV:
        case TOKEN_MOD:
        case TOKEN_EXP:
            return true;
        default:
            return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0xfffffefc, %eax       # imm = 0xFFFFFEFC
subl $0x5, %eax
ja 0x5850
jmp 0x584a
movb $0x1, -0x1(%rbp)
jmp 0x5854
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: philpoore[P]Math/./src/Ast.hpp
// Function: to_string[abi:cxx11](AstExpr*)
string to_string(AstExpr* ast) {
    switch (ast->type) {
        case AST_TYPE_EXPR:
            return "AstExpr";
        case AST_TYPE_STMTS:
            return to_string((AstStmts*)ast);
        case AST_TYPE_STMT:
            return to_string((AstStmt*)ast);
        case AST_TYPE_ASSIGN:
            return to_string((AstAssign*)ast);
        case AST_TYPE_NUMBER:
            return to_string((AstNumber*)ast);
        case AST_TYPE_IDENT:
            return to_string((AstIdent*)ast);
        case AST_TYPE_BIN_OP:
            return to_string((AstBinaryOp*)ast);
        case AST_TYPE_FUNCTION_CALL:
            return to_string((AstFunctionCall*)ast);
        case AST_TYPE_BLOCK:
            return to_string((AstBlock*)ast);
        case AST_TYPE_IF:
            return to_string((AstIf*)ast);
    }
    return "AstExpr";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x9, %rax
ja 0x5d44
movq -0x30(%rbp), %rax
leaq 0x103aa(%rip), %rcx     # 0x16004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4500
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x10604(%rip), %rsi     # 0x16283
callq 0xbcf0
jmp 0x5c86
leaq -0x11(%rbp), %rdi
callq 0x4340
jmp 0x5d89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x4340
jmp 0x5d93
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5fa0
jmp 0x5d89
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5ee0
jmp 0x5d89
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64e0
jmp 0x5d89
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5860
jmp 0x5d89
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5920
jmp 0x5d89
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x59a0
jmp 0x5d89
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5da0
jmp 0x5d89
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6100
jmp 0x5d89
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6260
jmp 0x5d89
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4500
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x10523(%rip), %rsi     # 0x16283
callq 0xbcf0
jmp 0x5d67
leaq -0x25(%rbp), %rdi
callq 0x4340
jmp 0x5d89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x4340
jmp 0x5d93
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x44f0
nopl (%rax)
// File: philpoore[P]Math/./src/Ast.hpp
// Function: to_string[abi:cxx11](AstStmts*)
string to_string(AstStmts* ast) {
    int size = ast->stmts.size();
    string output = "AstStmts([";
    for (int i = 0; i < size; i++) {
        auto stmt = ast->stmts[i];
        output += to_string(stmt);
        if (i < size - 1) {
            output += ", ";
        }
    }
    output += "])";
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xbcd0
movl %eax, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
leaq -0x16(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4500
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x1023f(%rip), %rsi     # 0x1622a
callq 0xbcf0
jmp 0x5ff2
leaq -0x16(%rbp), %rdi
callq 0x4340
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x60ba
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x28(%rbp), %rsi
callq 0xbda0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x5ee0
jmp 0x6035
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x43d0
jmp 0x6044
leaq -0x50(%rbp), %rdi
callq 0x4200
movl -0x28(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x60aa
movq -0x60(%rbp), %rdi
leaq 0x101d0(%rip), %rsi     # 0x16235
callq 0x42d0
jmp 0x606c
jmp 0x60aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x16(%rbp), %rdi
callq 0x4340
jmp 0x60f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x60e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4200
jmp 0x60e9
jmp 0x60ac
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6002
movq -0x60(%rbp), %rdi
leaq 0x10173(%rip), %rsi     # 0x16238
callq 0x42d0
jmp 0x60cc
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x60df
movq -0x60(%rbp), %rdi
callq 0x4200
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x4200
movq -0x20(%rbp), %rdi
callq 0x44f0
nopl (%rax,%rax)
// File: philpoore[P]Math/./src/Ast.hpp
// Function: to_string[abi:cxx11](AstBlock*)
string to_string(AstBlock* ast) {
    int size = ast->stmts.size();
    string output = "AstBlock([";
    for (int i = 0; i < size; i++) {
        auto stmt = ast->stmts[i];
        output += to_string(stmt);
        if (i < size - 1) {
            output += ", ";
        }
    }
    output += "])";
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xbcd0
movl %eax, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
leaq -0x16(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4500
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x100f0(%rip), %rsi     # 0x1623b
callq 0xbcf0
jmp 0x6152
leaq -0x16(%rbp), %rdi
callq 0x4340
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x621a
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x28(%rbp), %rsi
callq 0xbda0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x5ee0
jmp 0x6195
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x43d0
jmp 0x61a4
leaq -0x50(%rbp), %rdi
callq 0x4200
movl -0x28(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x620a
movq -0x60(%rbp), %rdi
leaq 0x10070(%rip), %rsi     # 0x16235
callq 0x42d0
jmp 0x61cc
jmp 0x620a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x16(%rbp), %rdi
callq 0x4340
jmp 0x6252
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x6249
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4200
jmp 0x6249
jmp 0x620c
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6162
movq -0x60(%rbp), %rdi
leaq 0x10013(%rip), %rsi     # 0x16238
callq 0x42d0
jmp 0x622c
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x623f
movq -0x60(%rbp), %rdi
callq 0x4200
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x4200
movq -0x20(%rbp), %rdi
callq 0x44f0
nopl (%rax,%rax)
// File: philpoore[P]Math/./src/Ast.hpp
// Function: to_expr_string[abi:cxx11](AstExpr*)
string to_expr_string(AstExpr* ast) {
    switch (ast->type) {
        case AST_TYPE_EXPR:
            return "AstExpr";
        case AST_TYPE_STMT:
            return to_expr_string((AstStmt*)ast);
        case AST_TYPE_STMTS:
            return to_expr_string((AstStmts*)ast);
        case AST_TYPE_ASSIGN:
            return to_expr_string((AstAssign*)ast);
        case AST_TYPE_NUMBER:
            return to_expr_string((AstNumber*)ast);
        case AST_TYPE_IDENT:
            return to_expr_string((AstIdent*)ast);
        case AST_TYPE_BIN_OP:
            return to_expr_string((AstBinaryOp*)ast);
        case AST_TYPE_FUNCTION_CALL:
            return to_expr_string((AstFunctionCall*)ast);
        case AST_TYPE_BLOCK:
            return to_expr_string((AstBlock*)ast);
        case AST_TYPE_IF:
            return to_expr_string((AstIf*)ast);
    }
    return "AstExpr";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x9, %rax
ja 0x6744
movq -0x30(%rbp), %rax
leaq 0xf9d2(%rip), %rcx      # 0x1602c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4500
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0xfc04(%rip), %rsi      # 0x16283
callq 0xbcf0
jmp 0x6686
leaq -0x11(%rbp), %rdi
callq 0x4340
jmp 0x6789
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x4340
jmp 0x6793
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x67a0
jmp 0x6789
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6820
jmp 0x6789
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6970
jmp 0x6789
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6a20
jmp 0x6789
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6a50
jmp 0x6789
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6a80
jmp 0x6789
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6c60
jmp 0x6789
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6d60
jmp 0x6789
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6f20
jmp 0x6789
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4500
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0xfb23(%rip), %rsi      # 0x16283
callq 0xbcf0
jmp 0x6767
leaq -0x25(%rbp), %rdi
callq 0x4340
jmp 0x6789
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x4340
jmp 0x6793
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x44f0
nopl (%rax)
// File: philpoore[P]Math/./src/Ast.hpp
// Function: to_expr_string[abi:cxx11](AstStmts*)
string to_expr_string(AstStmts* ast) {
    string output;
    for (auto stmt : ast->stmts) {
        output += to_expr_string(stmt) + "\n";
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x43f0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbdc0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbdf0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbe20
testb $0x1, %al
jne 0x6889
jmp 0x6932
leaq -0x28(%rbp), %rdi
callq 0xbe60
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x67a0
jmp 0x68a8
leaq 0xfc43(%rip), %rdx      # 0x164f2
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xb790
jmp 0x68be
movq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x43d0
jmp 0x68d0
leaq -0x58(%rbp), %rdi
callq 0x4200
leaq -0x78(%rbp), %rdi
callq 0x4200
leaq -0x28(%rbp), %rdi
callq 0xbe80
jmp 0x6873
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x6958
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x6927
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4200
leaq -0x78(%rbp), %rdi
callq 0x4200
jmp 0x6958
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x6948
movq -0x98(%rbp), %rdi
callq 0x4200
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x4200
movq -0x80(%rbp), %rdi
callq 0x44f0
nopl (%rax)
// File: philpoore[P]Math/./src/Ast.hpp
// Function: to_expr_string[abi:cxx11](AstBlock*)
string to_expr_string(AstBlock* ast) {
    string output = "{\n";
    for (auto stmt : ast->stmts) {
        output += to_expr_string(stmt) + "\n";
    }
    output += "\n}";
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4500
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0xf4de(%rip), %rsi      # 0x1628b
callq 0xbcf0
jmp 0x6db4
leaq -0x12(%rbp), %rdi
callq 0x4340
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xbdc0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xbdf0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xbe20
testb $0x1, %al
jne 0x6df9
jmp 0x6ec2
leaq -0x38(%rbp), %rdi
callq 0xbe60
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x67a0
jmp 0x6e1b
leaq 0xf6d0(%rip), %rdx      # 0x164f2
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xb790
jmp 0x6e34
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x43d0
jmp 0x6e46
leaq -0x68(%rbp), %rdi
callq 0x4200
leaq -0x88(%rbp), %rdi
callq 0x4200
leaq -0x38(%rbp), %rdi
callq 0xbe80
jmp 0x6de3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4340
jmp 0x6f09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x6efd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x6eb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4200
leaq -0x88(%rbp), %rdi
callq 0x4200
jmp 0x6efd
movq -0x98(%rbp), %rdi
leaq 0xf3be(%rip), %rsi      # 0x1628e
callq 0x42d0
jmp 0x6ed7
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x6eed
movq -0x98(%rbp), %rdi
callq 0x4200
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x4200
movq -0x20(%rbp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
// File: philpoore[P]Math/./src/Ast.hpp
// Function: precedence(AstBinOpType)
int precedence(AstBinOpType type) {
    switch (type) {
        case AST_BIN_OP_TYPE_ADD:
        case AST_BIN_OP_TYPE_SUB:
            return 1;

        case AST_BIN_OP_TYPE_MUL:
        case AST_BIN_OP_TYPE_DIV:
        case AST_BIN_OP_TYPE_MOD:
            return 2;

        case AST_BIN_OP_TYPE_EXP:
            return 3;

        default:
            return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0xa, %eax
subl $0x2, %eax
jb 0x742e
jmp 0x7417
movl -0xc(%rbp), %eax
addl $-0xc, %eax
subl $0x3, %eax
jb 0x7437
jmp 0x7424
movl -0xc(%rbp), %eax
subl $0xf, %eax
je 0x7440
jmp 0x7449
movl $0x1, -0x4(%rbp)
jmp 0x7450
movl $0x2, -0x4(%rbp)
jmp 0x7450
movl $0x3, -0x4(%rbp)
jmp 0x7450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: philpoore[P]Math/./src/Ast.hpp
// Function: Token_to_bin_op(TokenType)
AstBinOpType Token_to_bin_op(TokenType type) {
    switch (type) {
        case TOKEN_ADD:
            return AST_BIN_OP_TYPE_ADD;
        case TOKEN_SUB:
            return AST_BIN_OP_TYPE_SUB;
        case TOKEN_MUL:
            return AST_BIN_OP_TYPE_MUL;
        case TOKEN_DIV:
            return AST_BIN_OP_TYPE_DIV;
        case TOKEN_MOD:
            return AST_BIN_OP_TYPE_MOD;
        case TOKEN_EXP:
            return AST_BIN_OP_TYPE_EXP;
        default:
            return AST_BIN_OP_TYPE_UNKNOWN;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $0xfffffefc, %eax       # imm = 0xFFFFFEFC
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x5, %eax
ja 0x74c4
movq -0x10(%rbp), %rax
leaq 0xec13(%rip), %rcx      # 0x16098
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xa, -0x4(%rbp)
jmp 0x74cb
movl $0xb, -0x4(%rbp)
jmp 0x74cb
movl $0xc, -0x4(%rbp)
jmp 0x74cb
movl $0xd, -0x4(%rbp)
jmp 0x74cb
movl $0xe, -0x4(%rbp)
jmp 0x74cb
movl $0xf, -0x4(%rbp)
jmp 0x74cb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: philpoore[P]Math/./src/Interp.cpp
// Function: Interp::evalBinOp(AstBinaryOp*)
double Interp::evalBinOp(AstBinaryOp* bin_op) {
    double left_value = eval(bin_op->left);
    double right_value = eval(bin_op->right);

    switch (bin_op->op_type) {
        case AST_BIN_OP_TYPE_ADD:
            return left_value + right_value;
        case AST_BIN_OP_TYPE_SUB:
            return left_value - right_value;
        case AST_BIN_OP_TYPE_MUL:
            return left_value * right_value;
        case AST_BIN_OP_TYPE_DIV:
            return left_value / right_value;
        case AST_BIN_OP_TYPE_MOD:
            return fmodl(left_value, right_value);
        case AST_BIN_OP_TYPE_EXP:
            return pow(left_value, right_value);
        default:
            error("Unknown binary expression type: ");  // +
                                                        // bin_op->op_type);
            return 0.0f;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x76b0
movq -0x78(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x76b0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
addl $-0xa, %eax
movl %eax, %ecx
movq %rcx, -0x70(%rbp)
subl $0x5, %eax
ja 0x761b
movq -0x70(%rbp), %rax
leaq 0xeb29(%rip), %rcx      # 0x160b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7697
movsd -0x20(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7697
movsd -0x20(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7697
movsd -0x20(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7697
fldl -0x20(%rbp)
fldl -0x28(%rbp)
movq %rsp, %rax
fstpt 0x10(%rax)
fstpt (%rax)
callq 0x4070
fstpl -0x68(%rbp)
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7697
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x44e0
movsd %xmm0, -0x8(%rbp)
jmp 0x7697
leaq -0x49(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4500
movq -0x80(%rbp), %rdx
leaq 0xed00(%rip), %rsi      # 0x16333
leaq -0x48(%rbp), %rdi
callq 0xbcf0
jmp 0x763e
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x74d0
jmp 0x764d
leaq -0x48(%rbp), %rdi
callq 0x4200
leaq -0x49(%rbp), %rdi
callq 0x4340
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7697
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x768c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4200
leaq -0x49(%rbp), %rdi
callq 0x4340
jmp 0x76a5
movsd -0x8(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x44f0
nop
// File: philpoore[P]Math/./src/Interp.cpp
// Function: Interp::eval(AstExpr*)
double Interp::eval(AstExpr* expr) {
    switch (expr->type) {
        case AST_TYPE_NUMBER:
            return ((AstNumber*)expr)->value;
        case AST_TYPE_IDENT:
            return evalIdent((AstIdent*)expr);
        case AST_TYPE_BIN_OP:
            return evalBinOp((AstBinaryOp*)expr);
        case AST_TYPE_FUNCTION_CALL:
            return evalFunctionCall((AstFunctionCall*)expr);
        default:
            error(string("Unknown expression type: ") + to_string(expr->type));
            return 0.0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x98(%rbp)
subl $0x3, %eax
ja 0x775d
movq -0x98(%rbp), %rax
leaq 0xe9d5(%rip), %rcx      # 0x160c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7852
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7870
movsd %xmm0, -0x8(%rbp)
jmp 0x7852
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7520
movsd %xmm0, -0x8(%rbp)
jmp 0x7852
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7910
movsd %xmm0, -0x8(%rbp)
jmp 0x7852
leaq -0x59(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4500
movq -0xa8(%rbp), %rdx
leaq 0xebd9(%rip), %rsi      # 0x16354
leaq -0x58(%rbp), %rdi
callq 0xbcf0
jmp 0x7786
movq -0x18(%rbp), %rax
movl (%rax), %esi
leaq -0x90(%rbp), %rdi
callq 0xb900
jmp 0x779a
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0xb7e0
jmp 0x77b0
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x74d0
jmp 0x77c2
leaq -0x38(%rbp), %rdi
callq 0x4200
leaq -0x90(%rbp), %rdi
callq 0x4200
leaq -0x58(%rbp), %rdi
callq 0x4200
leaq -0x59(%rbp), %rdi
callq 0x4340
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7852
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x7847
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x783e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x7832
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4200
leaq -0x90(%rbp), %rdi
callq 0x4200
leaq -0x58(%rbp), %rdi
callq 0x4200
leaq -0x59(%rbp), %rdi
callq 0x4340
jmp 0x7860
movsd -0x8(%rbp), %xmm0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x44f0
nopl (%rax)
// File: philpoore[P]Math/./src/Interp.cpp
// Function: Interp::evalIdent(AstIdent*)
double Interp::evalIdent(AstIdent* ast) {
    if (variables.count(ast->name)) {
        return variables.at(ast->name);
    } else if (globals.count(ast->name)) {
        return globals.at(ast->name);
    } else {
        return 0.0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0xc530
cmpq $0x0, %rax
je 0x78b7
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0xc590
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x78f8
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq 0x18a7a(%rip), %rdi     # 0x20340
callq 0xc530
cmpq $0x0, %rax
je 0x78f0
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq 0x18a60(%rip), %rdi     # 0x20340
callq 0xc630
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x78f8
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: philpoore[P]Math/./src/Interp.cpp
// Function: Interp::evalFunctionCall(AstFunctionCall*)
double Interp::evalFunctionCall(AstFunctionCall* ast) {
    if (!functions.count(ast->name)) {
        // @TODO: unknown function name
        return 0.0;
    }

    auto func = functions.at(ast->name);

    return func(eval(ast->arg));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq 0x18a39(%rip), %rdi     # 0x20370
callq 0xc6d0
cmpq $0x0, %rax
jne 0x794c
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x79c5
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq 0x18a15(%rip), %rdi     # 0x20370
callq 0xc730
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0xc7d0
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x76b0
movsd %xmm0, -0x58(%rbp)
jmp 0x7984
movsd -0x58(%rbp), %xmm0
leaq -0x38(%rbp), %rdi
callq 0xc880
movsd %xmm0, -0x60(%rbp)
jmp 0x7999
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc8c0
jmp 0x79c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc8c0
jmp 0x79d0
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x44f0
nopl (%rax)
// File: philpoore[P]Math/./src/Parser.cpp
// Function: Parser::nextNonWhitespaceOffset(int)
int Parser::nextNonWhitespaceOffset(int d = 1) {
    Token t = peek(d);
    while (t.type == TOKEN_WHITESPACE) {
        d++;
        t = peek(d);
    }
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x88(%rbp)
movl -0xc(%rbp), %edx
leaq -0x40(%rbp), %rdi
callq 0x88d0
cmpl $0x111, -0x40(%rbp)     # imm = 0x111
jne 0x89ee
movq -0x88(%rbp), %rsi
movl -0xc(%rbp), %eax
incl %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
leaq -0x70(%rbp), %rdi
callq 0x88d0
jmp 0x89bf
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xce50
leaq -0x70(%rbp), %rdi
callq 0xcb70
jmp 0x8999
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcb70
jmp 0x8a0f
movl -0xc(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcb70
movl -0x8c(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x44f0
nopl (%rax,%rax)
// File: philpoore[P]Math/./src/Parser.cpp
// Function: Parser::consumeWhiteSpace()
void Parser::consumeWhiteSpace() {
    Token t = peek();
    while (t.type == TOKEN_WHITESPACE) {
        consume();
        t = peek();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x88d0
cmpl $0x111, -0x38(%rbp)     # imm = 0x111
jne 0x8e55
movq -0xb0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x8a60
jmp 0x8e00
leaq -0x68(%rbp), %rdi
callq 0xcb70
movq -0xb0(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
xorl %edx, %edx
callq 0x88d0
jmp 0x8e20
leaq -0x38(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xce50
leaq -0xa8(%rbp), %rdi
callq 0xcb70
jmp 0x8de5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcb70
jmp 0x8e67
leaq -0x38(%rbp), %rdi
callq 0xcb70
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x44f0
// File: philpoore[P]Math/./src/Parser.cpp
// Function: Parser::parseStatements()
AstStmts* Parser::parseStatements() {
    AstStmts* ast = new AstStmts();
    while (!isEnd() && peek().type != TOKEN_EOF) {
        AstStmt* stmt = parseStatement();
        if (stmt != nullptr) {
            ast->stmts.push_back(stmt);
        }
    }
    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x20, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0xced0
jmp 0x8ec2
movq -0x68(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x70(%rbp), %rdi
callq 0x88b0
movb %al, %cl
movb $0x0, -0x51(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x71(%rbp)
jne 0x8f03
movq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdi
xorl %edx, %edx
callq 0x88d0
movb $0x1, -0x51(%rbp)
cmpl $0x112, -0x50(%rbp)     # imm = 0x112
setne %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
movb %al, -0x72(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x8f11
jmp 0x8f1a
leaq -0x50(%rbp), %rdi
callq 0xcb70
movb -0x72(%rbp), %al
testb $0x1, %al
jne 0x8f23
jmp 0x8f6b
movq -0x70(%rbp), %rdi
callq 0x8f90
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x8f66
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq -0x60(%rbp), %rsi
callq 0xcf00
jmp 0x8f66
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x20, %esi
callq 0x4300
jmp 0x8f78
jmp 0x8eca
movq -0x10(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
// File: philpoore[P]Math/./src/Parser.cpp
// Function: Parser::parseBlock()
AstBlock* Parser::parseBlock() {
    AstBlock* ast = new AstBlock();
    while (!isEnd() && !peekIs(TOKEN_EOF) && !peekIs(TOKEN_RCURLY)) {
        AstStmt* stmt = parseStatement();
        if (stmt != nullptr) {
            ast->stmts.push_back(stmt);
        }
    }
    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x20, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0xcff0
jmp 0xa04f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rdi
callq 0x88b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0xa099
movq -0x38(%rbp), %rdi
movl $0x112, %esi            # imm = 0x112
callq 0x8a20
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0xa099
movq -0x38(%rbp), %rdi
movl $0x10d, %esi            # imm = 0x10D
callq 0x8a20
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xa0a2
jmp 0xa0ea
movq -0x38(%rbp), %rdi
callq 0x8f90
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa0e5
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
callq 0xcf00
jmp 0xa0e5
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x20, %esi
callq 0x4300
jmp 0xa0f4
jmp 0xa057
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x44f0
nopl (%rax)
// File: philpoore[P]Math/./src/Parser.cpp
// Function: Parser::parseNumber()
AstNumber* Parser::parseNumber() {
    Token t = expect(TOKEN_NUMBER_LITERAL);
    double value = std::stod(t.source);

    AstNumber* a = new AstNumber(value);
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4500
movq -0x88(%rbp), %rdx
leaq 0xc3bb(%rip), %rsi      # 0x164f3
leaq -0x58(%rbp), %rdi
callq 0xbcf0
jmp 0xa143
movq -0x90(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x102, %edx            # imm = 0x102
leaq -0x58(%rbp), %rcx
callq 0x8ab0
jmp 0xa15e
leaq -0x58(%rbp), %rdi
callq 0x4200
leaq -0x59(%rbp), %rdi
callq 0x4340
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd020
movsd %xmm0, -0x98(%rbp)
jmp 0xa187
movsd -0x98(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movl $0x10, %edi
callq 0x42f0
movq %rax, -0xa0(%rbp)
jmp 0xa1a7
movq -0xa0(%rbp), %rdi
movsd -0x78(%rbp), %xmm0
callq 0xd060
jmp 0xa1ba
movq -0xa0(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcb70
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xa20c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4200
leaq -0x59(%rbp), %rdi
callq 0x4340
jmp 0xa24b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xa242
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x10, %esi
callq 0x4300
leaq -0x38(%rbp), %rdi
callq 0xcb70
movq -0x68(%rbp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
// File: philpoore[P]Math/./src/Parser.cpp
// Function: Parser::parseSubExpr()
AstExpr* Parser::parseSubExpr() {
    if (peekIs(TOKEN_NUMBER_LITERAL)) {
        return (AstExpr*)parseNumber();
    } else if (peekIs(TOKEN_IDENT)) {
        ////////////
        // Parse Function Call
        if (peekNonWhitespace(1).type == TOKEN_LPAREN) {
            return (AstExpr*)parseFunctionCall();
        }
        ////////////

        return (AstExpr*)parseIdent();
    } else {
        error("Unexpected character, expecting digit or ident found :" +
              to_string(peek()));
        return nullptr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x102, %esi            # imm = 0x102
callq 0x8a20
testb $0x1, %al
jne 0xa73a
jmp 0xa74f
movq -0xc8(%rbp), %rdi
callq 0xa100
movq %rax, -0x8(%rbp)
jmp 0xa89c
movq -0xc8(%rbp), %rdi
movl $0x101, %esi            # imm = 0x101
callq 0x8a20
testb $0x1, %al
jne 0xa766
jmp 0xa7c4
movq -0xc8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x1, %edx
callq 0x8920
movl -0x40(%rbp), %eax
movl %eax, -0xcc(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcb70
movl -0xcc(%rbp), %eax
cmpl $0x10a, %eax            # imm = 0x10A
jne 0xa7af
movq -0xc8(%rbp), %rdi
callq 0xa3f0
movq %rax, -0x8(%rbp)
jmp 0xa89c
movq -0xc8(%rbp), %rdi
callq 0xa260
movq %rax, -0x8(%rbp)
jmp 0xa89c
movq -0xc8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
xorl %edx, %edx
callq 0x88d0
movq -0xd8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x5540
jmp 0xa7f2
leaq 0xbc1d(%rip), %rsi      # 0x16416
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0xb8b0
jmp 0xa808
movq -0xc8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8840
jmp 0xa81a
leaq -0x60(%rbp), %rdi
callq 0x4200
leaq -0x80(%rbp), %rdi
callq 0x4200
leaq -0xb0(%rbp), %rdi
callq 0xcb70
movq $0x0, -0x8(%rbp)
jmp 0xa89c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xa88e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xa885
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4200
leaq -0x80(%rbp), %rdi
callq 0x4200
leaq -0xb0(%rbp), %rdi
callq 0xcb70
jmp 0xa8a9
movq -0x8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
// File: philpoore[P]Math/main.cpp
// Function: runRepl()
void runRepl() {
    while (true) {
        string input;
        cout << "> ";
        cin >> input;

        if (input == "quit") {
            exit(0);
        }

        run(input);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x20(%rbp), %rdi
callq 0x43f0
movq 0x15308(%rip), %rdi     # 0x1ff70
leaq 0xb828(%rip), %rsi      # 0x16497
callq 0x42e0
jmp 0xac76
movq 0x15353(%rip), %rdi     # 0x1ffd0
leaq -0x20(%rbp), %rsi
callq 0x43c0
jmp 0xac88
leaq 0xb80b(%rip), %rsi      # 0x1649a
leaq -0x20(%rbp), %rdi
callq 0xcb90
movb %al, -0x51(%rbp)
jmp 0xac9d
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xaca6
jmp 0xacbb
xorl %edi, %edi
callq 0x4390
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xad01
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4160
jmp 0xacca
leaq -0x50(%rbp), %rdi
callq 0xa8c0
jmp 0xacd5
leaq -0x50(%rbp), %rdi
callq 0x4200
leaq -0x20(%rbp), %rdi
callq 0x4200
jmp 0xac58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4200
leaq -0x20(%rbp), %rdi
callq 0x4200
movq -0x28(%rbp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
// File: philpoore[P]Math/main.cpp
// Function: readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string readFile(string filename) {
    ifstream is(filename);
    if (!is) {
        cerr << "Runtime Error: Coudln't open file " << filename;
        cerr << " for reading" << endl;
        exit(1);
    }
    return string((std::istreambuf_iterator<char>(is)),
                  std::istreambuf_iterator<char>());
    ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rsi, -0x268(%rbp)
movq %rdi, -0x260(%rbp)
movq %rdi, %rax
movq %rax, -0x258(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x4480
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x4190
movb %al, -0x24a(%rbp)
jmp 0xad7c
movb -0x24a(%rbp), %al
testb $0x1, %al
jne 0xad8b
jmp 0xae0e
movq 0x1525e(%rip), %rdi     # 0x1fff0
leaq 0xb706(%rip), %rsi      # 0x1649f
callq 0x42e0
movq %rax, -0x270(%rbp)
jmp 0xada7
movq -0x268(%rbp), %rsi
movq -0x270(%rbp), %rdi
callq 0x42b0
jmp 0xadbc
movq 0x1522d(%rip), %rdi     # 0x1fff0
leaq 0xb6f8(%rip), %rsi      # 0x164c2
callq 0x42e0
movq %rax, -0x278(%rbp)
jmp 0xadd8
movq -0x278(%rbp), %rdi
movq 0x1511a(%rip), %rsi     # 0x1ff00
callq 0x4320
jmp 0xaded
movl $0x1, %edi
callq 0x4390
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0xaeb6
leaq -0x238(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0xd420
leaq -0x248(%rbp), %rdi
callq 0xd480
leaq -0x249(%rbp), %rdi
movq %rdi, -0x280(%rbp)
callq 0x4500
movq -0x260(%rbp), %rdi
movq -0x280(%rbp), %r9
movq -0x238(%rbp), %rsi
movl -0x230(%rbp), %edx
movq -0x248(%rbp), %rcx
movl -0x240(%rbp), %r8d
callq 0xd4b0
jmp 0xae70
leaq -0x249(%rbp), %rdi
callq 0x4340
leaq -0x218(%rbp), %rdi
callq 0x40d0
movq -0x258(%rbp), %rax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x249(%rbp), %rdi
callq 0x4340
leaq -0x218(%rbp), %rdi
callq 0x40d0
movq -0x220(%rbp), %rdi
callq 0x44f0
nop
// File: philpoore[P]Math/./src/Lexer.hpp
// Function: Lexer::createToken(TokenType)
Token createToken(TokenType t) {
        Token token = {t};
        assert((int)token.type >= 0);
        token.loc = loc;
        return token;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x15(%rbp)
movl -0x14(%rbp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
callq 0x43f0
movq -0x20(%rbp), %rdi
movl $0x0, 0x28(%rdi)
movl $0x0, 0x2c(%rdi)
cmpl $0x0, (%rdi)
jl 0xca81
jmp 0xcaa0
leaq 0x9ab2(%rip), %rdi      # 0x1653a
leaq 0x9ac0(%rip), %rsi      # 0x1654f
movl $0x24, %edx
leaq 0x9ac4(%rip), %rcx      # 0x1655f
callq 0x4220
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x28(%rax)
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xcac3
movq -0x20(%rbp), %rdi
callq 0xcb70
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: UTAP[P]APHTTP/utils/response.cpp
// Function: getHttpPhrases[abi:cxx11]()
map<int, string> getHttpPhrases() {
  map<int, string> httpPhrase;
  httpPhrase[200] = "OK";
  httpPhrase[303] = "See Other";
  httpPhrase[404] = "Not Found";
  return httpPhrase;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0xcff0
movq -0x38(%rbp), %rdi
movl $0xc8, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xd010
movq %rax, -0x30(%rbp)
jmp 0xb3aa
movq -0x30(%rbp), %rdi
leaq 0x15fd4(%rip), %rsi     # 0x21389
callq 0x4540
jmp 0xb3bc
movq -0x38(%rbp), %rdi
movl $0x12f, -0x20(%rbp)     # imm = 0x12F
leaq -0x20(%rbp), %rsi
callq 0xd010
movq %rax, -0x48(%rbp)
jmp 0xb3d6
movq -0x48(%rbp), %rdi
leaq 0x15fab(%rip), %rsi     # 0x2138c
callq 0x4540
jmp 0xb3e8
movq -0x38(%rbp), %rdi
movl $0x194, -0x24(%rbp)     # imm = 0x194
leaq -0x24(%rbp), %rsi
callq 0xd010
movq %rax, -0x50(%rbp)
jmp 0xb402
movq -0x50(%rbp), %rdi
leaq 0x15f89(%rip), %rsi     # 0x21396
callq 0x4540
jmp 0xb414
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0xb440
jmp 0xb437
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xd0f0
jmp 0xb44a
movq -0x38(%rbp), %rdi
callq 0xd0f0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: UTAP[P]APHTTP/utils/request.cpp
// Function: Request::Request(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Request::Request(string _method) {
  if (_method == "GET")
    method = GET;
  if (_method == "POST")
    method = POST;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x4560
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x48(%rbp)
callq 0xd110
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x40(%rbp)
callq 0xd110
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x30(%rbp)
callq 0xd110
movq -0x28(%rbp), %rdi
leaq 0x11058(%rip), %rsi     # 0x21541
callq 0x99e0
movb %al, -0x1d(%rbp)
jmp 0x104f3
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x104fc
jmp 0x1053b
movq -0x50(%rbp), %rax
movl $0x0, 0x20(%rax)
jmp 0x1053b
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xd2f0
movq -0x40(%rbp), %rdi
callq 0xd2f0
movq -0x48(%rbp), %rdi
callq 0xd2f0
movq -0x38(%rbp), %rdi
callq 0x4768
jmp 0x1056a
movq -0x28(%rbp), %rdi
leaq 0x10fff(%rip), %rsi     # 0x21545
callq 0x99e0
movb %al, -0x51(%rbp)
jmp 0x10550
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x10559
jmp 0x10564
movq -0x50(%rbp), %rax
movl $0x1, 0x20(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)