LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Parser.cpp
// Function: Parser::expect(TokenType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Token Parser::expect(TokenType type, string msg = "") {
    Token t = peek();
    if (t.type != type) {
        string output = msg;
        if (output.size()) {
            output += ": ";
        }
        output +=
            "Expected token " + to_string(type) + " but found " + to_string(t);
        error(output);
        return Token();
    } else {
        return consume();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
leaq -0x168(%rbp), %r13
movq %r13, %rdi
xorl %edx, %edx
callq 0x5b68
cmpl %ebx, (%r13)
jne 0x5d14
movq %r14, %rdi
movq %r12, %rsi
callq 0x5c86
leaq -0x160(%rbp), %rdi
callq 0x3110
movq %r14, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0x3290
cmpq $0x0, -0x40(%rbp)
je 0x5d37
leaq 0x4644(%rip), %rsi      # 0xa372
leaq -0x48(%rbp), %rdi
callq 0x3390
leaq -0x88(%rbp), %rdi
movl %ebx, %esi
callq 0x3f96
leaq 0x4645(%rip), %rsi      # 0xa391
leaq -0xa8(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x74dc
leaq 0x463b(%rip), %rdx      # 0xa3a1
leaq -0xc8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x7442
leaq -0x138(%rbp), %rdi
leaq -0x168(%rbp), %rsi
callq 0x7ca6
leaq -0x68(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x3e10
leaq -0xe8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x746b
leaq -0x48(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x33b0
leaq -0xe8(%rbp), %rdi
callq 0x3110
leaq -0x68(%rbp), %rdi
callq 0x3110
leaq -0x130(%rbp), %rdi
callq 0x3110
leaq -0xc8(%rbp), %rdi
callq 0x3110
leaq -0xa8(%rbp), %rdi
callq 0x3110
leaq -0x88(%rbp), %rdi
callq 0x3110
leaq -0x108(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3290
leaq -0x108(%rbp), %rsi
callq 0x5b16
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
jmp 0x5e8c
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x3110
jmp 0x5e44
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3110
jmp 0x5e52
movq %rax, %rbx
leaq -0x130(%rbp), %rdi
callq 0x3110
jmp 0x5e63
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x3110
jmp 0x5e74
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x3110
jmp 0x5e85
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3110
jmp 0x5e98
jmp 0x5e95
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3110
jmp 0x5ea8
jmp 0x5ea5
movq %rax, %rbx
leaq -0x160(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5b68
leaq -0xb0(%rbp), %r15
leaq -0x80(%rbp), %r12
leaq -0xb8(%rbp), %r13
leaq -0x88(%rbp), %r14
cmpl $0x111, -0x58(%rbp)     # imm = 0x111
jne 0x5f39
movq %r13, %rdi
movq %rbx, %rsi
callq 0x5c86
movq %r15, %rdi
callq 0x3110
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5b68
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x7cd2
movq %r12, %rdi
callq 0x3110
jmp 0x5efa
leaq -0x50(%rbp), %rdi
callq 0x3110
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5f56
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x3200
movl $0x2, (%rax)
leaq 0x8(%rax), %r15
andq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movq %rax, -0x30(%rbp)
movups %xmm0, 0x8(%rax)
leaq -0x58(%rbp), %r12
leaq -0x60(%rbp), %r13
movl 0x1c(%rbx), %eax
cmpl 0x18(%rbx), %eax
je 0x5ffa
movq %r13, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5b68
movl -0x60(%rbp), %r14d
movq %r12, %rdi
callq 0x3110
cmpl $0x112, %r14d           # imm = 0x112
je 0x5ffa
movq %rbx, %rdi
callq 0x600e
movq %rax, -0x60(%rbp)
testq %rax, %rax
je 0x5fb2
movq %r15, %rdi
movq %r13, %rsi
callq 0x7d00
jmp 0x5fb2
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x3200
movq %rax, %r14
movl $0x8, (%rax)
leaq 0x8(%rax), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
leaq -0x28(%rbp), %r12
movl 0x1c(%rbx), %eax
cmpl 0x18(%rbx), %eax
je 0x6917
movq %rbx, %rdi
movl $0x112, %esi            # imm = 0x112
callq 0x5c4e
testb %al, %al
jne 0x6917
movq %rbx, %rdi
movl $0x10d, %esi            # imm = 0x10D
callq 0x5c4e
testb %al, %al
jne 0x6917
movq %rbx, %rdi
callq 0x600e
movq %rax, -0x28(%rbp)
testq %rax, %rax
je 0x68cf
movq %r15, %rdi
movq %r12, %rsi
callq 0x7d00
jmp 0x68cf
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x3ba6(%rip), %rsi      # 0xa4e3
leaq -0x40(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x7692
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rcx
movq %rbx, %rsi
movl $0x102, %edx            # imm = 0x102
callq 0x5cb2
leaq -0x40(%rbp), %rdi
callq 0x3110
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7d24
movsd %xmm0, -0x20(%rbp)
pushq $0x10
popq %rdi
callq 0x3200
movq %rax, %r14
movl $0x4, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %rbx, %rdi
callq 0x3110
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x69ac
movq %rax, %r14
movq %rbx, %rdi
jmp 0x69bb
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x3110
jmp 0x69c5
movq %rax, %r14
movq %r14, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Parser.cpp
// Function: Parser::parseFunctionCall()
AstFunctionCall* Parser::parseFunctionCall() {
    Token t = expect(TOKEN_IDENT);
    AstFunctionCall* a = new AstFunctionCall(t.source);
    consumeWhiteSpace();

    expect(TOKEN_LPAREN);
    AstExpr* left = parseExpr();
    expect(TOKEN_RPAREN, "Unmatched parentheses");

    a->arg = left;
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %r14
leaq 0x3a2b(%rip), %rsi      # 0xa4e3
leaq -0xa8(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x7692
leaq -0xd8(%rbp), %rdi
leaq -0xa8(%rbp), %rcx
movq %r14, %rsi
movl $0x101, %edx            # imm = 0x101
callq 0x5cb2
leaq -0xa8(%rbp), %rdi
callq 0x3110
pushq $0x30
popq %rdi
callq 0x3200
movq %rax, %rbx
leaq -0xd0(%rbp), %r15
leaq -0x88(%rbp), %rdi
movq %r15, %rsi
callq 0x3290
leaq -0x88(%rbp), %rsi
movq %rbx, %rdi
callq 0x7d56
leaq -0x88(%rbp), %rdi
callq 0x3110
movq %r14, %rdi
callq 0x5ebc
leaq 0x39a9(%rip), %rsi      # 0xa4e3
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x7692
leaq -0x138(%rbp), %rdi
leaq -0x68(%rbp), %rcx
movq %r14, %rsi
movl $0x10a, %edx            # imm = 0x10A
callq 0x5cb2
leaq -0x130(%rbp), %rdi
callq 0x3110
leaq -0x68(%rbp), %rdi
callq 0x3110
movq %r14, %rdi
movl $0xffffd8f1, %esi       # imm = 0xFFFFD8F1
callq 0x666e
movq %rax, %r12
leaq 0x3865(%rip), %rsi      # 0xa3f0
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x7692
leaq -0x108(%rbp), %rdi
leaq -0x48(%rbp), %rcx
movq %r14, %rsi
movl $0x10b, %edx            # imm = 0x10B
callq 0x5cb2
leaq -0x100(%rbp), %rdi
callq 0x3110
leaq -0x48(%rbp), %rdi
callq 0x3110
movq %r12, 0x28(%rbx)
movq %r15, %rdi
callq 0x3110
movq %rbx, %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
jmp 0x6bf8
jmp 0x6c33
jmp 0x6c33
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x3110
jmp 0x6c36
jmp 0x6c33
movq %rax, %r14
leaq -0x88(%rbp), %rdi
callq 0x3110
jmp 0x6c15
movq %rax, %r14
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x3210
jmp 0x6c36
movq %rax, %r14
leaq -0xa8(%rbp), %rdi
jmp 0x6c3d
movq %rax, %r14
jmp 0x6c42
movq %rax, %r14
leaq -0xd0(%rbp), %rdi
callq 0x3110
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movl $0x102, %esi            # imm = 0x102
callq 0x5c4e
testb %al, %al
je 0x6c7c
movq %rbx, %rdi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x6928
movq %rbx, %rdi
movl $0x101, %esi            # imm = 0x101
callq 0x5c4e
testb %al, %al
je 0x6ccf
leaq -0x40(%rbp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5b94
movl (%r14), %r14d
leaq -0x38(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
cmpl $0x10a, %r14d           # imm = 0x10A
jne 0x6cbe
callq 0x6a9c
jmp 0x6cc3
callq 0x69ce
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x90(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5b68
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x3e10
leaq 0x3710(%rip), %rsi      # 0xa406
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x74dc
leaq -0x60(%rbp), %rsi
callq 0x5b16
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3110
jmp 0x6d1d
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3110
jmp 0x6d2b
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/main.cpp
// Function: run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void run(string input) {
    Lexer lexer(input);
    auto tokens = lexer.tokenize();

#ifdef DEBUG
    // Debug tokens
    for (auto token : tokens) cerr << to_string(token) << endl;
#endif

    Parser parser(tokens);

    AstStmts* ast = parser.parse();

#ifdef DEBUG
    // Debug AST
    cerr << to_string(ast) << endl;
    cerr << to_expr_string(ast) << endl;
#endif

    interp.exec(ast);
    // cout << setprecision(16) << value << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rsi
leaq -0x128(%rbp), %rbx
movq %rbx, %rdi
callq 0x3290
leaq -0xd8(%rbp), %rdi
movq %rbx, %rsi
callq 0x7d94
leaq -0x128(%rbp), %rdi
callq 0x3110
leaq -0x60(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x55d6
movq -0x60(%rbp), %r14
movq -0x58(%rbp), %r12
leaq -0xa8(%rbp), %r13
leaq -0x108(%rbp), %rbx
leaq -0x48(%rbp), %r15
cmpq %r12, %r14
je 0x6e0d
movq %r13, %rdi
movq %r14, %rsi
callq 0x7ca6
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7ca6
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3e10
movq 0x8219(%rip), %rdi      # 0xeff0
movq %r15, %rsi
callq 0x31e0
movq %rax, %rdi
callq 0x3120
movq %r15, %rdi
callq 0x3110
leaq -0x100(%rbp), %rdi
callq 0x3110
leaq -0xa0(%rbp), %rdi
callq 0x3110
addq $0x30, %r14
jmp 0x6daa
leaq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7dbc
leaq -0xa8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x7e16
leaq -0x78(%rbp), %rdi
callq 0x7c7a
leaq -0xa8(%rbp), %rdi
callq 0x5f74
movq %rax, %r14
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x44b1
movq 0x819b(%rip), %rdi      # 0xeff0
leaq -0x48(%rbp), %rsi
callq 0x31e0
movq %rax, %rdi
callq 0x3120
leaq -0x48(%rbp), %rdi
callq 0x3110
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x49fe
movq 0x816e(%rip), %rdi      # 0xeff0
leaq -0x48(%rbp), %rsi
callq 0x31e0
movq %rax, %rdi
callq 0x3120
leaq -0x48(%rbp), %rdi
callq 0x3110
leaq 0x8425(%rip), %rdi      # 0xf2c8
movq %r14, %rsi
callq 0x536a
leaq -0xa8(%rbp), %rdi
callq 0x7c7a
leaq -0x60(%rbp), %rdi
callq 0x7c7a
leaq -0xd8(%rbp), %rdi
callq 0x3110
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6f00
jmp 0x6f00
movq %rax, %r14
leaq -0x78(%rbp), %rdi
jmp 0x6f18
jmp 0x6f29
movq %rax, %r14
leaq -0xd8(%rbp), %rbx
jmp 0x6f62
movq %rax, %r14
jmp 0x6f62
jmp 0x6f05
movq %rax, %r14
jmp 0x6f11
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x3110
leaq -0xa8(%rbp), %rdi
callq 0x7c7a
jmp 0x6f52
movq %rax, %r14
jmp 0x6f46
movq %rax, %r14
jmp 0x6f3a
movq %rax, %r14
jmp 0x6f52
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x3110
leaq -0x100(%rbp), %rdi
callq 0x3110
leaq -0xa0(%rbp), %rdi
callq 0x3110
leaq -0xd8(%rbp), %rbx
leaq -0x60(%rbp), %rdi
callq 0x7c7a
movq %rbx, %rdi
callq 0x3110
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x34fd(%rip), %r14      # 0xa487
movq 0x803f(%rip), %r15      # 0xefd0
leaq -0x48(%rbp), %r12
leaq 0x34ee(%rip), %r13      # 0xa48a
leaq -0x68(%rbp), %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
andq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq 0x7fb8(%rip), %rdi      # 0xef70
movq %r14, %rsi
callq 0x31f0
movq %r15, %rdi
movq %r12, %rsi
callq 0x3270
movq %r12, %rdi
movq %r13, %rsi
callq 0x7bd5
testb %al, %al
jne 0x6fff
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x6d3f
movq %rbx, %rdi
callq 0x3110
movq %r12, %rdi
callq 0x3110
jmp 0x6fa0
xorl %edi, %edi
callq 0x3240
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3110
jmp 0x7017
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x220(%rbp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x3320
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x200(%rbp,%rax)
jne 0x709d
movq -0x138(%rbp,%rax), %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
movl %edx, %r8d
callq 0x99f4
leaq -0x220(%rbp), %rdi
callq 0x30a0
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x7f4c(%rip), %rdi      # 0xeff0
leaq 0x33e4(%rip), %rsi      # 0xa48f
callq 0x31f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x31e0
movq 0x7f2e(%rip), %rdi      # 0xeff0
leaq 0x33e9(%rip), %rsi      # 0xa4b2
callq 0x31f0
movq %rax, %rdi
callq 0x3120
pushq $0x1
popq %rdi
callq 0x3240
jmp 0x70e0
movq %rax, %rbx
leaq -0x220(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/main.cpp
// Function: main
int main(int argc, char** argv) {
    bool repl = argc == 1;

    if (repl) {
        runRepl();
    }

    string input;
    string firstArg = string(argv[1]);

    if (firstArg == "-f") {
        // Use a file as input.
        // E.g "./math -f examples/example-1.math"
        if (argc < 3) {
            cerr << "Runtime Error: Too few arguments\n";
            cerr << "-f flag missing filename" << endl;
            exit(1);
        }
        string filename = string(argv[2]);
        // Read file for input
        input = readFile(filename);
    } else {
        // Default to running from firstArg.
        // E.g "./math 10+10"
        input = string(firstArg);
    }

    run(input);
    exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
cmpl $0x1, %edi
jne 0x710f
callq 0x6f72
movq %rsi, %rbx
movl %edi, %r14d
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rsi), %rsi
leaq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x7692
leaq 0x337f(%rip), %rsi      # 0xa4bf
leaq -0xb0(%rbp), %rdi
callq 0x7bd5
testb %al, %al
je 0x7190
cmpl $0x2, %r14d
jg 0x71de
movq 0x7e8f(%rip), %rdi      # 0xeff0
leaq 0x335a(%rip), %rsi      # 0xa4c2
callq 0x31f0
movq 0x7e7c(%rip), %rdi      # 0xeff0
leaq 0x3369(%rip), %rsi      # 0xa4e4
callq 0x31f0
movq %rax, %rdi
callq 0x3120
pushq $0x1
popq %rdi
callq 0x3240
leaq -0x30(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x3290
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rbx
movq %rbx, %rsi
callq 0x3250
movq %rbx, %rdi
callq 0x3110
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3290
leaq -0x70(%rbp), %rdi
callq 0x6d3f
leaq -0x70(%rbp), %rdi
callq 0x3110
xorl %edi, %edi
callq 0x3240
movq 0x10(%rbx), %rsi
leaq -0x30(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
callq 0x7692
leaq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3290
leaq -0xd0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x7028
leaq -0x50(%rbp), %rdi
leaq -0xd0(%rbp), %rbx
movq %rbx, %rsi
callq 0x3250
movq %rbx, %rdi
callq 0x3110
leaq -0x90(%rbp), %rdi
callq 0x3110
leaq -0x30(%rbp), %rdi
jmp 0x71b3
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x3110
jmp 0x7259
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x7266
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x3110
jmp 0x7274
jmp 0x7271
jmp 0x7271
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x3110
jmp 0x7285
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edx, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
testl %edx, %edx
js 0x7b78
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
movq %rdi, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x29a7(%rip), %rdi      # 0xa52a
leaq 0x29b5(%rip), %rsi      # 0xa53f
leaq 0x29be(%rip), %rcx      # 0xa54f
pushq $0x24
popq %rdx
callq 0x3170
nop
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/examples/handlers.cpp
// Function: LoginHandler::callback(Request*)
Response *LoginHandler::callback(Request *req) {
  string username = req->getBodyParam("username");
  string password = req->getBodyParam("password");
  if (username == "root")
    throw Server::Exception("Remote root access has been disabled.");
  cout << "username: " << username << ",\tpassword: " << password << endl;
  Response *res = Response::redirect("/rand");
  res->setSessionId("SID");
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rbx
leaq 0xb0d2(%rip), %rsi      # 0x111fe
leaq -0xe0(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x41a0
leaq -0x60(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
movq %rbx, %rsi
callq 0x8d88
leaq -0xe0(%rbp), %rdi
callq 0x4638
leaq 0xb0a5(%rip), %rsi      # 0x11207
leaq -0xc0(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x41a0
leaq -0x40(%rbp), %rdi
leaq -0xc0(%rbp), %rdx
movq %rbx, %rsi
callq 0x8d88
leaq -0xc0(%rbp), %rdi
callq 0x4638
leaq 0xb078(%rip), %rsi      # 0x11210
leaq -0x60(%rbp), %rdi
callq 0x6703
testb %al, %al
jne 0x6269
movq 0x11e18(%rip), %rdi     # 0x17fc8
leaq 0xb084(%rip), %rsi      # 0x1123b
callq 0x4360
leaq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x4300
leaq 0xb077(%rip), %rsi      # 0x11246
movq %rax, %rdi
callq 0x4360
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4200
leaq 0xaf0d(%rip), %rsi      # 0x110ff
leaq -0xa0(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x41a0
leaq -0xa0(%rbp), %rdi
callq 0x7e3a
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x4638
leaq 0xb02f(%rip), %rsi      # 0x11253
leaq -0x80(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x41a0
leaq -0x80(%rbp), %rsi
movq %rbx, %rdi
callq 0x7d8a
leaq -0x80(%rbp), %rdi
callq 0x4638
leaq -0x40(%rbp), %rdi
callq 0x4638
leaq -0x60(%rbp), %rdi
callq 0x4638
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x4210
movq %rax, %r14
leaq 0xaf9a(%rip), %rsi      # 0x11215
leaq -0x100(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x41a0
movb $0x1, %r15b
leaq -0x100(%rbp), %rsi
movq %r14, %rdi
callq 0xe304
xorl %r15d, %r15d
leaq 0x11831(%rip), %rsi     # 0x17ad8
leaq 0x466(%rip), %rdx       # 0x6714
movq %r14, %rdi
callq 0x4560
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0x4638
testb %r15b, %r15b
jne 0x62cf
jmp 0x631c
movq %rax, %rbx
movq %r14, %rdi
callq 0x42a0
jmp 0x631c
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
jmp 0x62ee
jmp 0x6319
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x4638
jmp 0x631c
jmp 0x6319
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
jmp 0x6320
movq %rax, %rbx
jmp 0x6325
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
jmp 0x6329
movq %rax, %rbx
jmp 0x632e
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4638
leaq -0x60(%rbp), %rdi
callq 0x4638
movq %rbx, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/examples/handlers.cpp
// Function: UploadHandler::callback(Request*)
Response *UploadHandler::callback(Request *req) {
  string name = req->getBodyParam("file_name");
  string file = req->getBodyParam("file");
  cout << name << " (" << file.size() << "B):\n" << file << endl;
  Response *res = Response::redirect("/");
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
leaq 0xaf0b(%rip), %rsi      # 0x11257
leaq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x41a0
leaq -0xb0(%rbp), %rdi
leaq -0x90(%rbp), %rdx
movq %rbx, %rsi
callq 0x8d88
leaq -0x90(%rbp), %rdi
callq 0x4638
leaq 0xaedc(%rip), %rsi      # 0x11261
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x41a0
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rdx
movq %rbx, %rsi
callq 0x8d88
leaq -0x70(%rbp), %rdi
callq 0x4638
movq 0x11c16(%rip), %rdi     # 0x17fc8
leaq -0xb0(%rbp), %rsi
callq 0x4300
leaq 0xaea1(%rip), %rsi      # 0x11266
movq %rax, %rdi
callq 0x4360
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x4270
leaq 0xae89(%rip), %rsi      # 0x11269
movq %rax, %rdi
callq 0x4360
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4200
leaq 0xac18(%rip), %rsi      # 0x1101b
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x41a0
leaq -0x50(%rbp), %rdi
callq 0x7e3a
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4638
leaq -0x30(%rbp), %rdi
callq 0x4638
leaq -0xb0(%rbp), %rdi
callq 0x4638
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4638
jmp 0x6479
jmp 0x6476
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x647d
movq %rax, %rbx
jmp 0x6482
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x6489
movq %rax, %rbx
jmp 0x648e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4638
leaq -0xb0(%rbp), %rdi
callq 0x4638
movq %rbx, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/examples/handlers.cpp
// Function: ColorHandler::handle[abi:cxx11](Request*)
map<string, string> ColorHandler::handle(Request *req) {
  map<string, string> context;
  string newName = "I am " + req->getQueryParam("name");
  context["name"] = newName;
  context["color"] = req->getQueryParam("color");
  return context;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0xad3b(%rip), %rsi      # 0x1125c
leaq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x41a0
leaq -0x38(%rbp), %rdi
leaq -0x98(%rbp), %rdx
movq %r14, %rsi
callq 0x8d5e
leaq 0xad23(%rip), %rsi      # 0x1126e
leaq -0xb8(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x673e
leaq -0x38(%rbp), %rdi
callq 0x4638
leaq -0x98(%rbp), %rdi
callq 0x4638
leaq 0xace5(%rip), %rsi      # 0x1125c
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x41a0
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x676c
leaq -0xb8(%rbp), %rsi
movq %rax, %rdi
callq 0x4240
leaq -0x38(%rbp), %rdi
callq 0x4638
leaq 0xacc5(%rip), %rsi      # 0x11274
leaq -0x78(%rbp), %rdi
leaq -0x12(%rbp), %rdx
callq 0x41a0
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rdx
movq %r14, %rsi
callq 0x8d5e
leaq 0xaca1(%rip), %rsi      # 0x11274
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x41a0
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x676c
leaq -0x38(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x4400
leaq -0x58(%rbp), %rdi
callq 0x4638
movq %r14, %rdi
callq 0x4638
leaq -0x78(%rbp), %rdi
callq 0x4638
leaq -0xb8(%rbp), %rdi
callq 0x4638
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x4638
jmp 0x6641
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4638
jmp 0x664f
movq %rax, %r14
leaq -0x78(%rbp), %rdi
jmp 0x6682
jmp 0x6657
movq %rax, %r14
jmp 0x6687
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4638
jmp 0x666d
movq %rax, %r14
leaq -0x98(%rbp), %rdi
jmp 0x668e
movq %rax, %r14
jmp 0x6693
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4638
leaq -0xb8(%rbp), %rdi
callq 0x4638
movq %rbx, %rdi
callq 0x6938
movq %r14, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq -0x1c(%rbp), %rsi
movl $0xc8, (%rsi)
callq 0x7ee2
leaq 0xa56b(%rip), %rsi      # 0x11389
movq %rax, %rdi
callq 0x45e0
leaq -0x18(%rbp), %rsi
movl $0x12f, (%rsi)          # imm = 0x12F
movq %rbx, %rdi
callq 0x7ee2
leaq 0xa54d(%rip), %rsi      # 0x1138c
movq %rax, %rdi
callq 0x45e0
leaq -0x14(%rbp), %rsi
movl $0x194, (%rsi)          # imm = 0x194
movq %rbx, %rdi
callq 0x7ee2
leaq 0xa536(%rip), %rsi      # 0x11396
movq %rax, %rdi
callq 0x45e0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x6e78
jmp 0x6e78
movq %rax, %r14
movq %rbx, %rdi
callq 0x8284
movq %r14, %rdi
callq 0x4580
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x30(%rdi), %rax
andl $0x0, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movq %rax, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
leaq 0x60(%rdi), %rax
andl $0x0, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
movq %rax, 0x70(%rdi)
movq %rax, 0x78(%rdi)
andq $0x0, 0x80(%rdi)
leaq 0x90(%rdi), %rax
andl $0x0, 0x90(%rdi)
andq $0x0, 0x98(%rdi)
movq %rax, 0xa0(%rdi)
movq %rax, 0xa8(%rdi)
andq $0x0, 0xb0(%rdi)
leaq 0x8812(%rip), %rsi      # 0x11541
movq %r14, %rdi
callq 0x6703
testb %al, %al
je 0x8d3f
andl $0x0, 0x20(%rbx)
leaq 0x87ff(%rip), %rsi      # 0x11545
movq %r14, %rdi
callq 0x6703
testb %al, %al
je 0x8d59
movl $0x1, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/utils/request.cpp
// Function: Request::getBody[abi:cxx11]()
string Request::getBody() {
  string bs = "";
  for (auto it = body.begin(); !body.empty() && it != body.end(); it++)
    bs += it->first + "=" + it->second + "&";
  return bs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
leaq 0x861e(%rip), %rsi      # 0x11595
leaq -0x98(%rbp), %r15
movq %rdi, -0x30(%rbp)
movq %r15, %rdx
callq 0x41a0
movq 0xa0(%rbx), %r12
movq %rbx, %r14
leaq 0x90(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq -0x58(%rbp), %r13
leaq -0x78(%rbp), %rbx
cmpq $0x0, 0xb0(%r14)
je 0x901e
cmpq -0x38(%rbp), %r12
je 0x901e
leaq 0x20(%r12), %rsi
movq %r13, %rdi
leaq 0x848d(%rip), %rdx      # 0x11453
callq 0x8107
leaq 0x40(%r12), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8026
movq %r15, %rdi
movq %rbx, %rsi
leaq 0x8562(%rip), %rdx      # 0x1154a
callq 0x7ffd
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x45f0
movq %r15, %rdi
callq 0x4638
movq %rbx, %rdi
callq 0x4638
movq %r13, %rdi
callq 0x4638
movq %r12, %rdi
callq 0x4280
movq %rax, %r12
jmp 0x8fa7
movq -0x30(%rbp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x4638
jmp 0x9045
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x4638
jmp 0x9058
movq %rax, %rbx
jmp 0x9061
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4638
movq -0x30(%rbp), %rdi
callq 0x4638
movq %rbx, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/utils/request.cpp
// Function: Request::getSessionId[abi:cxx11]()
string Request::getSessionId() {
  string cookie = getHeader("cookie");
  if (cookie == "")
    return "";
  vector<string> v = split(cookie, ";");
  for (string kv : v) {
    vector<string> k = split(kv, "=");
    if (k[0] == "sessionId")
      return k[1];
  }
  return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, %rbx
movq %rdi, -0x38(%rbp)
leaq 0x83af(%rip), %rsi      # 0x11443
leaq -0x108(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x41a0
leaq -0xa8(%rbp), %rdi
leaq -0x108(%rbp), %rdx
movq %rbx, %rsi
callq 0x8db6
leaq -0x108(%rbp), %rdi
callq 0x4638
leaq 0x84c8(%rip), %rsi      # 0x11595
leaq -0xa8(%rbp), %rdi
callq 0x6703
testb %al, %al
je 0x90f6
leaq 0x84b1(%rip), %rsi      # 0x11595
leaq -0x70(%rbp), %rdx
movq -0x38(%rbp), %rdi
callq 0x41a0
jmp 0x9232
leaq -0xe8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x4470
leaq 0x877b(%rip), %rsi      # 0x1188b
leaq -0xc8(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x41a0
leaq -0x88(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
pushq $0x1
popq %rcx
callq 0xb0c9
leaq -0xc8(%rbp), %rdi
callq 0x4638
leaq -0xe8(%rbp), %rdi
callq 0x4638
movq -0x88(%rbp), %r14
movq -0x80(%rbp), %r13
leaq -0x70(%rbp), %r15
leaq -0x148(%rbp), %r12
leaq -0x128(%rbp), %rbx
cmpq %r13, %r14
je 0x91ed
movq %r15, %rdi
movq %r14, %rsi
callq 0x4470
movq %r12, %rdi
movq %r15, %rsi
callq 0x4470
movq %rbx, %rdi
leaq 0x82bc(%rip), %rsi      # 0x11453
leaq -0x29(%rbp), %rdx
callq 0x41a0
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
pushq $0x1
popq %rcx
callq 0xb0c9
movq %rbx, %rdi
callq 0x4638
movq %r12, %rdi
callq 0x4638
movq -0x50(%rbp), %rdi
leaq 0x837f(%rip), %rsi      # 0x1154c
callq 0x6703
testb %al, %al
jne 0x9203
leaq -0x50(%rbp), %rdi
callq 0xa7ae
movq %r15, %rdi
callq 0x4638
addq $0x20, %r14
jmp 0x9172
leaq 0x83a1(%rip), %rsi      # 0x11595
leaq -0x70(%rbp), %rdx
movq -0x38(%rbp), %rdi
callq 0x41a0
jmp 0x9226
movq -0x50(%rbp), %rsi
addq $0x20, %rsi
movq -0x38(%rbp), %rdi
callq 0x4470
leaq -0x50(%rbp), %rdi
callq 0xa7ae
leaq -0x70(%rbp), %rdi
callq 0x4638
leaq -0x88(%rbp), %rdi
callq 0xa7ae
leaq -0xa8(%rbp), %rdi
callq 0x4638
movq -0x38(%rbp), %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xa7ae
jmp 0x92c8
jmp 0x92b4
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x4638
jmp 0x9278
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x4638
jmp 0x92dd
jmp 0x9288
movq %rax, %rbx
jmp 0x92dd
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
jmp 0x92e4
movq %rax, %rbx
jmp 0x92e9
movq %rax, %rbx
jmp 0x92c8
movq %rax, %rbx
leaq -0x128(%rbp), %rdi
callq 0x4638
jmp 0x92bc
movq %rax, %rbx
jmp 0x92d1
movq %rax, %rbx
leaq -0x148(%rbp), %rdi
callq 0x4638
leaq -0x70(%rbp), %rdi
callq 0x4638
leaq -0x88(%rbp), %rdi
callq 0xa7ae
leaq -0xa8(%rbp), %rdi
callq 0x4638
movq %rbx, %rdi
callq 0x4580
nop
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/utils/request.cpp
// Function: Request::getHeaders[abi:cxx11]()
cimap Request::getHeaders() {
  vector<string> res;
  for (map<string, string>::iterator i = headers.begin();
       !headers.empty() && i != headers.end(); i++) {
    res.push_back(i->first);
    res.push_back(i->second);
  }
  return headers;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r12
andq $0x0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x28(%rsi), %rax
movq %rax, -0x30(%rbp)
movq 0x40(%rsi), %r13
leaq 0x30(%rsi), %r15
cmpq $0x0, 0x50(%r14)
je 0xa138
cmpq %r15, %r13
je 0xa138
leaq 0x20(%r13), %rsi
movq %r12, %rdi
callq 0xa7da
leaq 0x40(%r13), %rsi
movq %r12, %rdi
callq 0xa7da
movq %r13, %rdi
callq 0x4280
movq %rax, %r13
jmp 0xa107
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
callq 0xa836
leaq -0x50(%rbp), %rdi
callq 0xa7ae
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa161
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xa7ae
movq %rbx, %rdi
callq 0x4580
nop
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/utils/request.cpp
// Function: Request::getQueryString[abi:cxx11]()
string Request::getQueryString() {
  if (query.empty())
    return "";
  string res = "?";
  for (map<string, string>::iterator i = query.begin();
       !query.empty() && i != query.end(); i++) {
    res += i->first;
    res += "=";
    res += i->second;
    res += "&";
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x80(%rsi)
je 0xa204
movq %rsi, %r14
leaq 0x740b(%rip), %rsi      # 0x115a6
leaq -0x29(%rbp), %rdx
movq %rbx, %rdi
callq 0x41a0
movq 0x70(%r14), %r13
leaq 0x60(%r14), %r15
leaq 0x7394(%rip), %r12      # 0x1154a
cmpq $0x0, 0x80(%r14)
je 0xa217
cmpq %r15, %r13
je 0xa217
leaq 0x20(%r13), %rsi
movq %rbx, %rdi
callq 0x45f0
movq %rbx, %rdi
leaq 0x7278(%rip), %rsi      # 0x11453
callq 0x45d0
leaq 0x40(%r13), %rsi
movq %rbx, %rdi
callq 0x45f0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x45d0
movq %r13, %rdi
callq 0x4280
movq %rax, %r13
jmp 0xa1b6
leaq 0x738a(%rip), %rsi      # 0x11595
leaq -0x2a(%rbp), %rdx
movq %rbx, %rdi
callq 0x41a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4638
movq %r14, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/utils/request.cpp
// Function: Request::getHeadersString[abi:cxx11]()
string Request::getHeadersString() {
  string headerString = "";
  for (auto it = headers.begin(); !headers.empty() && it != headers.end(); it++)
    headerString += it->first + "=" + it->second + "&";
  return headerString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
leaq 0x733e(%rip), %rsi      # 0x11595
leaq -0x98(%rbp), %r15
movq %rdi, -0x30(%rbp)
movq %r15, %rdx
callq 0x41a0
movq 0x40(%rbx), %r12
movq %rbx, %r14
leaq 0x30(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq -0x58(%rbp), %r13
leaq -0x78(%rbp), %rbx
cmpq $0x0, 0x50(%r14)
je 0xa2f5
cmpq -0x38(%rbp), %r12
je 0xa2f5
leaq 0x20(%r12), %rsi
movq %r13, %rdi
leaq 0x71b6(%rip), %rdx      # 0x11453
callq 0x8107
leaq 0x40(%r12), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8026
movq %r15, %rdi
movq %rbx, %rsi
leaq 0x728b(%rip), %rdx      # 0x1154a
callq 0x7ffd
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x45f0
movq %r15, %rdi
callq 0x4638
movq %rbx, %rdi
callq 0x4638
movq %r13, %rdi
callq 0x4638
movq %r12, %rdi
callq 0x4280
movq %rax, %r12
jmp 0xa281
movq -0x30(%rbp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x4638
jmp 0xa31c
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x4638
jmp 0xa32f
movq %rax, %rbx
jmp 0xa338
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4638
movq -0x30(%rbp), %rdi
callq 0x4638
movq %rbx, %rdi
callq 0x4580
nop
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/utils/request.cpp
// Function: Request::serializeToFile(Request*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Request::serializeToFile(Request *req, string filePath) {
  string reqString = to_string(req->getMethod());
  reqString += "\n";
  reqString += req->getPath();
  reqString += "\n";
  reqString += req->getHeadersString();
  reqString += "\n";
  reqString += req->getBody();
  reqString += "\n";
  reqString += req->getQueryString();
  writeToFile(reqString, filePath);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x20(%rdi), %esi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x66a3
leaq 0x7185(%rip), %rsi      # 0x11660
movq %r15, %rdi
callq 0x45d0
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x4470
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x45f0
leaq -0x38(%rbp), %rdi
callq 0x4638
leaq 0x7154(%rip), %rsi      # 0x11660
leaq -0x58(%rbp), %rdi
callq 0x45d0
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0xa23c
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x45f0
leaq -0x38(%rbp), %rdi
callq 0x4638
leaq 0x7122(%rip), %rsi      # 0x11660
leaq -0x58(%rbp), %rdi
callq 0x45d0
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x8f5c
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x45f0
leaq -0x38(%rbp), %rdi
callq 0x4638
leaq 0x70f0(%rip), %rsi      # 0x11660
leaq -0x58(%rbp), %rdi
callq 0x45d0
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0xa176
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x45f0
leaq -0x38(%rbp), %rdi
callq 0x4638
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0xb5fc
leaq -0x58(%rbp), %rdi
callq 0x4638
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa5c7
jmp 0xa5d7
jmp 0xa5c7
jmp 0xa5d7
jmp 0xa5c7
jmp 0xa5d7
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4638
jmp 0xa5da
jmp 0xa5d7
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4638
movq %rbx, %rdi
callq 0x4580
nop
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/utils/request.cpp
// Function: Request::deserializeFromFile(Request*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Request::deserializeFromFile(Request *req, string filePath) {
  vector<string> fields = tokenize(readFile(filePath), '\n');
  switch (fields.size()) {
  case 5:
    req->setQuery(fields[4]);
  case 4:
    req->setBody(fields[3]);
  case 3:
    req->setHeaders(fields[2]);
  case 2:
    req->setPath(fields[1]);
  case 1:
    req->setMethod(stoi(fields[0]) == GET ? GET : POST);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
leaq -0xe8(%rbp), %r14
movq %r14, %rdi
callq 0x4470
leaq -0xc8(%rbp), %rdi
movq %r14, %rsi
callq 0xb0ae
leaq -0x28(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
pushq $0xa
popq %rdx
callq 0xb428
leaq -0xc8(%rbp), %rdi
callq 0x4638
leaq -0xe8(%rbp), %rdi
callq 0x4638
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
subq %rsi, %rax
sarq $0x5, %rax
decq %rax
cmpq $0x4, %rax
ja 0xa733
leaq 0x6ec3(%rip), %rcx      # 0x1152c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
subq $-0x80, %rsi
leaq -0xa8(%rbp), %rdi
callq 0x4470
leaq -0xa8(%rbp), %rsi
movq %rbx, %rdi
callq 0xa3b2
leaq -0xa8(%rbp), %rdi
callq 0x4638
movq -0x28(%rbp), %rsi
addq $0x60, %rsi
leaq -0x88(%rbp), %rdi
callq 0x4470
leaq -0x88(%rbp), %rsi
movq %rbx, %rdi
callq 0xa448
leaq -0x88(%rbp), %rdi
callq 0x4638
movq -0x28(%rbp), %rsi
addq $0x40, %rsi
leaq -0x68(%rbp), %rdi
callq 0x4470
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0xa34a
leaq -0x68(%rbp), %rdi
callq 0x4638
movq -0x28(%rbp), %rsi
addq $0x20, %rsi
leaq -0x48(%rbp), %rdi
callq 0x4470
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x4240
leaq -0x48(%rbp), %rdi
callq 0x4638
movq -0x28(%rbp), %rsi
pushq $0xa
popq %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0xa815
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movl %ecx, 0x20(%rbx)
leaq -0x28(%rbp), %rdi
callq 0xa7ae
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
jmp 0xa770
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
jmp 0xa770
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0xa770
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4638
jmp 0xa79c
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x4638
jmp 0xa78b
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x4638
jmp 0xa7a5
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa7ae
movq %rbx, %rdi
callq 0x4580
nop
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/utils/utilities.cpp
// Function: readFile[abi:cxx11](char const*)
string readFile(const char *filename) {
  ifstream infile;
  infile.open(filename, infile.binary);
  if (!infile.is_open()) return string();

  infile.seekg(0, infile.end);
  size_t length = infile.tellg();
  infile.seekg(0, infile.beg);

  if (length > BUFFER_SIZE)
    length = BUFFER_SIZE;
  char* buffer = new char[length + 1];

  infile.read(buffer, length);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x220(%rbp), %r15
movq %r15, %rdi
callq 0x43c0
pushq $0x4
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4260
leaq -0x1a8(%rbp), %rdi
callq 0x40e0
testb %al, %al
je 0xb062
leaq -0x220(%rbp), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x4460
leaq -0x220(%rbp), %rdi
callq 0x4570
movq %rax, %r14
leaq -0x220(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4460
movl $0x3f4000, %r15d        # imm = 0x3F4000
cmpq %r15, %r14
cmovbq %r14, %r15
leaq 0x1(%r15), %rdi
callq 0x4030
movq %rax, %r14
leaq -0x220(%rbp), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x4410
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdx
addq %r15, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb90a
movq %r14, %rdi
callq 0x4420
jmp 0xb072
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x220(%rbp), %rdi
callq 0x4110
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb097
jmp 0xb097
jmp 0xb097
jmp 0xb097
movq %rax, %rbx
leaq -0x220(%rbp), %rdi
callq 0x4110
movq %rbx, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/utils/utilities.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
vector<string> split(string s, string delimiter, bool trim) {
  vector<string> tokens;
  if (trim)
    s.erase(remove(s.begin(), s.end(), ' '), s.end());
  size_t pos = 0;
  string token;
  while ((pos = s.find(delimiter)) != string::npos) {
    token = s.substr(0, pos);
    tokens.push_back(token);
    s.erase(0, pos + delimiter.length());
  }
  tokens.push_back(s);
  return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
andq $0x0, 0x10(%rdi)
testl %ecx, %ecx
je 0xb11b
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
leaq -0x50(%rbp), %rdx
movb $0x20, (%rdx)
callq 0xb9a8
movq (%r14), %rdx
addq 0x8(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x40c0
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x70(%rbp), %r12
leaq -0x50(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4620
cmpq $-0x1, %rax
je 0xb18b
movq %rax, %rbx
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4390
movq %r13, %rdi
movq %r12, %rsi
callq 0x4400
movq %r12, %rdi
callq 0x4638
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0xa7da
addq 0x8(%r15), %rbx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x40d0
jmp 0xb133
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa7da
leaq -0x50(%rbp), %rdi
callq 0x4638
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb1b7
movq %rax, %rbx
jmp 0xb1cc
jmp 0xb1c0
jmp 0xb1c0
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4638
movq -0x30(%rbp), %rdi
callq 0xa7ae
movq %rbx, %rdi
callq 0x4580
// File: /workspace/github_cpp_makefile_star2_O2/UTAP[P]APHTTP/utils/utilities.cpp
// Function: urlEncode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string urlEncode(string const &str) {
  char encode_buf[4];
  string result;
  encode_buf[0] = '%';
  result.reserve(str.size());

  // character selection for this algorithm is based on the following url:
  // http://www.blooberry.com/indexdot/html/topics/urlencoding.htm

  for (size_t pos = 0; pos < str.size(); ++pos) {
    switch (str[pos]) {
    default:
      if (str[pos] >= 32 && str[pos] < 127) {
        // character does not need to be escaped
        result += str[pos];
        break;
      }
      // else pass through to next case
    case '$':
    case '&':
    case '+':
    case ',':
    case '/':
    case ':':
    case ';':
    case '=':
    case '?':
    case '@':
    case '"':
    case '<':
    case '>':
    case '#':
    case '%':
    case '{':
    case '}':
    case '|':
    case '\\':
    case '^':
    case '~':
    case '[':
    case ']':
    case '`':
      // the character needs to be encoded
      sprintf(encode_buf + 1, "%02X", str[pos]);
      result += encode_buf;
      break;
    }
  };
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movb $0x25, -0x2c(%rbp)
movq 0x8(%rsi), %rsi
callq 0x44f0
leaq 0x633f(%rip), %r12      # 0x115c7
leaq -0x2c(%rbp), %r13
xorl %r15d, %r15d
cmpq 0x8(%r14), %r15
jae 0xb2f3
movq (%r14), %rax
movzbl (%rax,%r15), %eax
movsbl %al, %edx
leal -0x22(%rax), %ecx
cmpl $0x3e, %ecx
ja 0xb2d6
movabsq $0x5e0000007f00261f, %rsi # imm = 0x5E0000007F00261F
btq %rcx, %rsi
jae 0xb2d6
leaq -0x2b(%rbp), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4090
movq %rbx, %rdi
movq %r13, %rsi
callq 0x45d0
incq %r15
jmp 0xb28f
movl %eax, %ecx
addl $-0x7b, %ecx
cmpl $0x4, %ecx
jb 0xb2b8
addl $-0x7f, %eax
cmpb $-0x5f, %al
jb 0xb2b8
movq %rbx, %rdi
movl %edx, %esi
callq 0x42e0
jmp 0xb2d1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb307
movq %rax, %r14
movq %rbx, %rdi
callq 0x4638
movq %r14, %rdi
callq 0x4580