LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::join()
char Parser::join() {
    char lhs, rhs;
    lhs = equality(); // join -> equality restJoin
    
    // restJoin -> && equality restJoin
    while (look.tag == AND) {
        move();
        rhs = equality();
        lhs = byteCoder->evalBool(AND, lhs, rhs);
    }
    // restJoin -> e
    return lhs;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4b66
movl %eax, %ebp
cmpw $0x130, 0x18(%rbx)      # imm = 0x130
jne 0x4b5c
movq %rbx, %rdi
callq 0x4574
movq %rbx, %rdi
callq 0x4b66
movq 0x10(%rbx), %rdi
movsbl %bpl, %edx
movsbl %al, %ecx
movl $0x130, %esi            # imm = 0x130
callq 0x2b70
jmp 0x4b2b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::equality()
char Parser::equality() {
    short oper;
    char lhs, rhs;
    lhs = rel(); // equality -> rel restEquality
    
    // restEquality -> == rel restEquality | != rel restEquality
    while (look.tag == EQ || look.tag == NE) {
        oper = look.tag;
        move();
        rhs = rel();
        lhs = byteCoder->evalBool(oper, lhs, rhs);
    }
    // restEquality -> e
    return lhs;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4bb4
movl %eax, %ebp
movzwl 0x18(%rbx), %r14d
movl %r14d, %eax
andl $-0x2, %eax
cmpl $0x12e, %eax            # imm = 0x12E
jne 0x4bac
movq %rbx, %rdi
callq 0x4574
movq %rbx, %rdi
callq 0x4bb4
movq 0x10(%rbx), %rdi
movswl %r14w, %esi
movsbl %bpl, %edx
movsbl %al, %ecx
callq 0x2b70
jmp 0x4b72
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::rel()
char Parser::rel() {
    short oper;
    char lhs, rhs;
    lhs = expr(); // rel -> expr restRel
    
    // restRel -> < expr restRel | > expr restRel | <= expr restRel | >= expr restRel
    while (look.tag == '<' || look.tag == '>' || look.tag == LE || look.tag == GE) {
        oper = look.tag;
        move();
        rhs = expr();
        lhs = byteCoder->evalBool(oper, lhs, rhs);
    }
    // restRel -> e
    return lhs;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4c0e
movl %eax, %ebp
movzwl 0x18(%rbx), %r14d
movzwl %r14w, %eax
leal -0x12c(%rax), %ecx
cmpl $0x2, %ecx
jb 0x4be0
cmpl $0x3e, %eax
je 0x4be0
cmpl $0x3c, %eax
jne 0x4c06
movq %rbx, %rdi
callq 0x4574
movq %rbx, %rdi
callq 0x4c0e
movq 0x10(%rbx), %rdi
movswl %r14w, %esi
movsbl %bpl, %edx
movsbl %al, %ecx
callq 0x2b70
jmp 0x4bc0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::expr()
char Parser::expr() {
    char oper, lhs, rhs;
    lhs = term(); // expr -> term restExpr
    
    // restExpr -> + term restExpr | - term restExpr
    while (look.tag == '+' || look.tag == '-') {
        oper = look.tag;
        move(); 
        rhs = term();
        lhs = byteCoder->evalArith(oper, lhs, rhs);
    }
    // restExpr -> e
    return lhs;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4c5a
movl %eax, %ebp
movzwl 0x18(%rbx), %r14d
cmpl $0x2d, %r14d
je 0x4c2d
cmpl $0x2b, %r14d
jne 0x4c53
movq %rbx, %rdi
callq 0x4574
movq %rbx, %rdi
callq 0x4c5a
movq 0x10(%rbx), %rdi
movsbl %r14b, %esi
movsbl %bpl, %edx
movsbl %al, %ecx
callq 0x2a5c
jmp 0x4c1a
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::term()
char Parser::term() {
    char oper, lhs, rhs;
    lhs = unary(); // term -> unary restTerm
    
    // restTerm -> * unary restTerm | / unary restTerm
    while (look.tag == '*' || look.tag == '/') {
        oper = look.tag;
        move(); 
        rhs = unary();
        lhs = byteCoder->evalArith(oper, lhs, rhs);
    }
    // restTerm -> e
    return lhs;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4ca6
movl %eax, %ebp
movzwl 0x18(%rbx), %r14d
cmpl $0x2f, %r14d
je 0x4c79
cmpl $0x2a, %r14d
jne 0x4c9f
movq %rbx, %rdi
callq 0x4574
movq %rbx, %rdi
callq 0x4ca6
movq 0x10(%rbx), %rdi
movsbl %r14b, %esi
movsbl %bpl, %edx
movsbl %al, %ecx
callq 0x2a5c
jmp 0x4c66
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::unary()
char Parser::unary() {
    char rhs;
    
    // unary -> - unary
    if (look.tag == '-') {
        move(); 
        rhs = unary();
        return byteCoder->evalUnary(rhs);
    }
    // unary -> factor
    return factor();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpw $0x2d, 0x18(%rdi)
jne 0x4cce
movq %rbx, %rdi
callq 0x4574
movq %rbx, %rdi
callq 0x4ca6
movq 0x10(%rbx), %rdi
movsbl %al, %esi
popq %rbx
jmp 0x2994
movq %rbx, %rdi
popq %rbx
jmp 0x4cd8
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/ZoneMgr.cpp
// Function: ZoneMgr::ZoneMgr()
ZoneMgr::ZoneMgr() {
    inUse       = 0;
    saved       = 0;
    boolCount   = 0;
    intCount    = 0;
    stringCount = 0;
    
    zones.push_back(zone);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x28(%rdi), %rcx
movl %eax, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq %rax, (%rdi)
movups %xmm0, 0x48(%rdi)
movl %eax, 0x58(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5562
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x5658
movq %rbx, %rdi
callq 0x558e
movq %r15, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/ZoneMgr.cpp
// Function: ZoneMgr::getVarType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char ZoneMgr::getVarType(std::string id) {
    for (int i = inUse; i != 0; i--) {
        varTable::iterator iter = zones[i].find(id);
        if (iter != zones[i].end()) {
            return iter->second.type; // a variable's type
        }
    }
    throw Error("'" + id + "' wasn't declared in this scope");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movslq (%rdi), %r12
testq %r12, %r12
sete %r15b
je 0x52e0
movq %rdi, %rbx
movq %r12, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %r13
movq 0x8(%rbx), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0x5b44
movq 0x8(%rbx), %rcx
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rax, %rcx
je 0x52cc
movb 0x40(%rax), %bpl
cmpq %rax, %rcx
jne 0x52e0
addq $-0x30, %r13
decq %r12
sete %r15b
jne 0x52a9
jmp 0x52e0
testb $0x1, %r15b
jne 0x52f7
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x1f95(%rip), %rsi      # 0x72a0
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x55cf
leaq 0x1fa4(%rip), %rsi      # 0x72c3
leaq 0x28(%rsp), %rdi
callq 0x2270
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x534a
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x5357
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x36dc
xorl %ebp, %ebp
leaq 0x5a29(%rip), %rsi      # 0xadb0
leaq -0x23f0(%rip), %rdx     # 0x2f9e
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x53b8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x53b8
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53db
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x53db
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x53e8
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/ZoneMgr.cpp
// Function: ZoneMgr::getVarIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int ZoneMgr::getVarIndex(std::string id) {
    for (int i = inUse; i != 0; i--) {
        varTable::iterator iter = zones[i].find(id);
        if (iter != zones[i].end()) {
            return iter->second.index; // a variable's index
        }
    }
    throw Error("'" + id + "' wasn't declared in this scope");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movslq (%rdi), %r12
testq %r12, %r12
sete %r15b
je 0x5451
movq %rdi, %rbx
movq %r12, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %r13
movq 0x8(%rbx), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0x5b44
movq 0x8(%rbx), %rcx
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rax, %rcx
je 0x543d
movl 0x44(%rax), %ebp
cmpq %rax, %rcx
jne 0x5451
addq $-0x30, %r13
decq %r12
sete %r15b
jne 0x541b
jmp 0x5451
testb $0x1, %r15b
jne 0x5468
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x1e24(%rip), %rsi      # 0x72a0
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x55cf
leaq 0x1e33(%rip), %rsi      # 0x72c3
leaq 0x28(%rsp), %rdi
callq 0x2270
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x54bb
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x54c8
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x36dc
xorl %ebp, %ebp
leaq 0x58b8(%rip), %rsi      # 0xadb0
leaq -0x2561(%rip), %rdx     # 0x2f9e
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5529
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x5529
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x554c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x554c
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5559
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/guitld[P]Graph-Algorithms/source/main.cpp
// Function: main
int main(){

     Graph grp;
     string filename;
     getline(cin, filename);

     grp.fromPajek(filename);

     grp.printMap();


     return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq -0x60(%rbp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x7a9a(%rip), %rdi      # 0x9fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %edx
movq 0x7a7f(%rip), %rdi      # 0x9fe0
leaq -0x38(%rbp), %rsi
callq 0x2280
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x2702
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2a50
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x25ab
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0x90(%rbp), %rdi
callq 0x28f6
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x25cc
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0x90(%rbp), %rdi
callq 0x262c
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2602
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2160
jmp 0x2602
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2617
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0x90(%rbp), %rdi
callq 0x262c
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/guitld[P]Graph-Algorithms/source/Graph.cpp
// Function: Graph::printMap()
void Graph::printMap(){     
     for (auto elem : adj_lists){
          cout << elem.first << ": ";
          for (auto const &i : elem.second)
               cout << i.first << "(" << i.second << ")" << ", ";
          cout << endl;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x2a15
leaq -0x48(%rbp), %rbx
movq 0x76b1(%rip), %r14      # 0x9fd0
leaq 0x470d(%rip), %r15      # 0x7033
movl 0x8(%rcx), %eax
movl %eax, -0x50(%rbp)
movq %rcx, -0x30(%rbp)
leaq 0x10(%rcx), %rsi
movq %rbx, %rdi
callq 0x4cc4
movl -0x50(%rbp), %esi
movq %r14, %rdi
callq 0x2250
movl $0x2, %edx
movq %rax, %rdi
leaq 0x46d8(%rip), %rsi      # 0x702e
callq 0x2180
movq -0x48(%rbp), %r13
cmpq %rbx, %r13
je 0x29c0
movl 0x10(%r13), %esi
movq %r14, %rdi
callq 0x2250
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x46af(%rip), %rsi      # 0x7031
callq 0x2180
movl 0x14(%r13), %esi
movq %r12, %rdi
callq 0x2250
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x4711(%rip), %rsi      # 0x70b6
callq 0x2180
movl $0x2, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2180
movq (%r13), %r13
jmp 0x295f
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x2a05
movq (%rdi), %r12
movl $0x18, %esi
callq 0x2160
movq %r12, %rdi
cmpq %rbx, %r12
jne 0x29f0
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x2926
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a26
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x2a47
movq (%rdi), %r15
movl $0x18, %esi
callq 0x2160
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x2a32
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/guitld[P]Graph-Algorithms/source/Graph.cpp
// Function: Graph::is_cyclic_util(std::vector<bool, std::allocator<bool>>, int)
bool Graph::is_cyclic_util(vector<bool> visited, int node){

     // If the node is marked as visited, cycle detected
     if (visited[node - 1])
          return true;

     // Marking current node
     visited[node - 1] = true;

     // Looping through neighbors of current vertex
     for (auto &neighbor : this->adj_lists[node]){
          if (is_cyclic_util(visited, neighbor.first))
               return true;
     }

     return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, -0x38(%rbp)
movl %edx, -0x2c(%rbp)
movslq %edx, %rcx
leaq -0x1(%rcx), %rdx
leaq 0x3e(%rcx), %rax
testq %rdx, %rdx
cmovnsq %rdx, %rax
sarq $0x6, %rax
shlq $0x3, %rax
movq %rsi, -0x40(%rbp)
addq (%rsi), %rax
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
leaq 0x3f(%rsi), %rdi
andq %rdx, %rdi
xorl %edx, %edx
cmpq %rsi, %rdi
setbe %dl
decb %cl
movl $0x1, %esi
shlq %cl, %rsi
movq -0x8(%rax,%rdx,8), %rdi
movzbl %cl, %ecx
movb $0x1, %r15b
btq %rcx, %rdi
jb 0x4438
leaq -0x8(,%rdx,8), %rcx
orq %rsi, %rdi
movq %rdi, (%rax,%rcx)
leaq -0x2c(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x4ed4
movq %rax, %r13
xorl %ebx, %ebx
movq %rax, %r12
movq (%r12), %r12
cmpq %r13, %r12
setne %r15b
je 0x4438
leaq -0x68(%rbp), %r14
movq %r14, %rdi
movq -0x40(%rbp), %rsi
callq 0x4a70
movl 0x10(%r12), %edx
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x4346
movl %eax, %r14d
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x4433
movq -0x48(%rbp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, -0x68(%rbp)
movl %ebx, -0x60(%rbp)
movq %rbx, -0x58(%rbp)
movl %ebx, -0x50(%rbp)
movq %rbx, -0x48(%rbp)
testb %r14b, %r14b
je 0x43db
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rsi
testq %rsi, %rsi
je 0x445f
leaq -0x68(%rbp), %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/guitld[P]Graph-Algorithms/source/Graph.cpp
// Function: Graph::is_cyclic()
bool Graph::is_cyclic(){

     // Bool vector to mark nodes as visited
     vector<bool> visited (this->size(), false);

     // Looping through the nodes and use the recursive function to find a cycle or not
     for (auto &node : this->adj_lists){

          visited[node.first - 1] = true;

          for (auto &neighbor : node.second){
               if (is_cyclic_util(visited, neighbor.first))
                    return true;
          }
          visited[node.first - 1] = false;
     }
     return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movslq 0x18(%rdi), %rsi
leaq -0x2b(%rbp), %rdx
movb $0x0, (%rdx)
leaq -0x58(%rbp), %rdi
leaq -0x2a(%rbp), %rcx
callq 0x4b0e
movq %rbx, -0x68(%rbp)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
setne %bl
je 0x45c8
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq 0x3f(%r15), %r14
leaq -0x98(%rbp), %r13
movb %bl, -0x29(%rbp)
movslq 0x8(%rdi), %rax
leaq -0x1(%rax), %rcx
addq $0x3e, %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq -0x58(%rbp), %rax
movq %rcx, %rdx
andq %r14, %rdx
xorl %esi, %esi
cmpq %r15, %rdx
setbe %sil
movl $0x1, %edx
shlq %cl, %rdx
orq %rdx, -0x8(%rax,%rsi,8)
movq %rdi, -0x60(%rbp)
leaq 0x10(%rdi), %r12
movq %r12, -0x70(%rbp)
movq (%r12), %r12
cmpq -0x70(%rbp), %r12
je 0x4573
movq %r13, %rdi
leaq -0x58(%rbp), %rsi
callq 0x4a70
movl 0x10(%r12), %edx
movq -0x68(%rbp), %rdi
movq %r13, %rbx
movq %r13, %rsi
callq 0x4346
movl %eax, %r13d
movq -0x98(%rbp), %rdi
testq %rdi, %rdi
je 0x4569
movq -0x78(%rbp), %rsi
subq %rdi, %rsi
callq 0x2160
xorl %eax, %eax
movq %rax, -0x98(%rbp)
movl %eax, -0x90(%rbp)
movq %rax, -0x88(%rbp)
movl %eax, -0x80(%rbp)
movq %rax, -0x78(%rbp)
testb %r13b, %r13b
movq %rbx, %r13
je 0x4507
jmp 0x45c5
movq -0x60(%rbp), %rdi
movslq 0x8(%rdi), %rax
leaq -0x1(%rax), %rcx
addq $0x3e, %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq -0x58(%rbp), %rax
movq %rcx, %rdx
andq %r14, %rdx
xorl %esi, %esi
cmpq %r15, %rdx
setbe %sil
movq $-0x2, %rdx
rolq %cl, %rdx
andq %rdx, -0x8(%rax,%rsi,8)
movq (%rdi), %rdi
testq %rdi, %rdi
setne %bl
jne 0x44bd
jmp 0x45c8
movb -0x29(%rbp), %bl
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x45f1
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2160
xorl %eax, %eax
movq %rax, -0x58(%rbp)
movl %eax, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movl %eax, -0x40(%rbp)
movq %rax, -0x38(%rbp)
andb $0x1, %bl
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4625
movq %rax, %rbx
movq -0x98(%rbp), %rsi
testq %rsi, %rsi
je 0x4625
leaq -0x98(%rbp), %rdi
callq 0x22d8
leaq -0x58(%rbp), %rdi
callq 0x2310
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/eryxcc[P]lois/tests/../include/lois.h
// Function: lois::EIteratorOf<lois::term>::operator++()
void EIteratorOf<T>::operator ++ () { 
  disconnectIterator();
  // if(index >= 0) 
  index++;
  connectIterator();
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1fa8c
incl 0x8(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x1ef88
nop
// File: /workspace/github_cpp_makefile_star2_O1/eryxcc[P]lois/tests/../include/lois.h
// Function: lois::lsetof<lois::term>::lsetof(lois::lsetof<lois::term>&&)
lsetof<T>(lsetof<T> &&x) : ain(currentcontext) {
    if(x.ain == currentcontext) {
      swap(elts, x.elts);
      }
    else {
      (*this) |= x;
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x392f3(%rip), %rax     # 0x642c0
movq (%rax), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0x2aff5
movq 0x38fe1(%rip), %rdx     # 0x63fc8
cmpb $0x0, (%rdx)
je 0x2aff1
incl 0x8(%rcx)
jmp 0x2aff5
lock
incl 0x8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq (%rsi), %rcx
cmpq (%rax), %rcx
je 0x2b01a
leaq 0x10(%rbx), %r15
movq %rbx, %rdi
callq 0x2245a
jmp 0x2b042
movups 0x10(%rbx), %xmm0
movq 0x20(%rbx), %rax
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rbx)
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rbx)
movq 0x20(%rsi), %rcx
movq %rcx, 0x20(%rbx)
movups %xmm0, 0x10(%rsi)
movq %rax, 0x20(%rsi)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x14f28
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2b061
callq 0x14c44
movq %r14, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/eryxcc[P]lois/src/../include/lois.h
// Function: bool lois::ArbCondition::enable<std::vector<std::shared_ptr<lois::Variable>, std::allocator<std::shared_ptr<lois::Variable>>>>(std::vector<std::shared_ptr<lois::Variable>, std::allocator<std::shared_ptr<lois::Variable>>>, lois::rbool)
bool enable(T vars, rbool psi) {
    disable();
    currentcontext = ourcontext = std::make_shared<Context> (currentcontext, psi);
    for(auto v: vars) currentcontext->var.push_back(v);
    int res = solver->solveEnv();
    if(res == 1) throw unsolvable_exception();
    return res == 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x36722
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x172a9(%rip), %rbx     # 0x642c0
leaq 0x10(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rsi
movq %rbx, %rcx
movq %r12, %r8
callq 0x36d36
movaps (%r13), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r13)
movq 0x10(%r15), %rdi
movups %xmm0, 0x8(%r15)
leaq 0x10(%r15), %r12
testq %rdi, %rdi
je 0x4d053
callq 0x14c44
movq 0x8(%r15), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x15478
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4d075
callq 0x14c44
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x4d0da
leaq 0x10(%rsp), %r14
movq 0x16f3b(%rip), %r13     # 0x63fc8
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x4d0b3
cmpb $0x0, (%r13)
je 0x4d0af
incl 0x8(%rax)
jmp 0x4d0b3
lock
incl 0x8(%rax)
movq (%rbx), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0x17d8c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4d0d1
callq 0x14c44
addq $0x10, %r15
cmpq %r12, %r15
jne 0x4d08d
leaq 0x172d7(%rip), %rax     # 0x643b8
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x1, %eax
je 0x4d103
cmpl $0x2, %eax
sete %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x8140
leaq 0x15714(%rip), %rcx     # 0x62828
movq %rcx, (%rax)
leaq 0x156ba(%rip), %rsi     # 0x627d8
movq 0x16ebb(%rip), %rdx     # 0x63fe0
movq %rax, %rdi
callq 0x83f0
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4d13f
callq 0x14c44
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSL.h
// Function: PSL::PSLVM::loadScript(PSL::variable::string const&)
error loadScript(const string &filename)
	{
		if (!loadCompiledCode(filename))
			return NONE;
		variable::Tokenizer *t = variable::Tokenizer::New(filename);
		if (!t)
			return FOPEN_ERROR;

		bool e = parse(t);
		delete t;

		if (e)
			return PARSE_ERROR;
		return NONE;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2679c
testl %eax, %eax
je 0xc74a
movq %r14, %rdi
xorl %esi, %esi
callq 0x1b134
testq %rax, %rax
je 0xc74e
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2683a
movl %eax, %ebx
movq %r14, %rdi
callq 0x18b04
movl $0x70, %esi
movq %r14, %rdi
callq 0xc1d0
movzbl %bl, %eax
addl %eax, %eax
jmp 0xc753
xorl %eax, %eax
jmp 0xc753
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator+=(char)
string &operator+=(char c)
	{
		if (!buf)
		{
			buf = new SharedBuffer(SPARE);
			buf->buffer()[0] = c;
			buf->setlen(1);
		}
		else
		{
			size_t o = buf->length();
			only_and_extend(o + 1);
			buf->buffer()[o] = c;
			buf->setlen(o + 1);
		}
		return *this;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xc817
movq 0x18(%rax), %r15
leaq 0x1(%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1112c
movq (%rbx), %rax
movq 0x8(%rax), %rax
movb %bpl, (%rax,%r15)
movq (%rbx), %rax
movq %r14, 0x18(%rax)
jmp 0xc851
callq 0x1055a
movq %rax, %r14
movl $0x1, (%rax)
movl $0xc, %edi
callq 0xc040
movq %rax, 0x8(%r14)
movq $0xb, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq %r14, (%rbx)
movb %bpl, (%rax)
movq $0x1, 0x18(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xfbe0
movq %rbx, %rdi
callq 0xc290
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator+=(char const*)
string &operator+=(const char *s)
	{
		if (empty_s(s))	return *this;
		if (!buf)
		{
			buf = new SharedBuffer(s);
		}
		else
		{
			size_t l = std::strlen(s);
			size_t c = buf->length();
			only_and_extend(c + l);
			buf->fcopy(s, l, c);
		}
		return *this;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xc91b
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0xc91b
movq (%rbx), %r12
testq %r12, %r12
je 0xc8d7
movq %r14, %rdi
callq 0xc0c0
movq %rax, %r15
movq 0x18(%r12), %r12
leaq (%r12,%rax), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1112c
movq (%rbx), %rbp
addq 0x8(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xc150
movq %r13, 0x18(%rbp)
jmp 0xc91b
callq 0x1055a
movq %rax, %r15
movq %r14, %rdi
callq 0xc0c0
movq %rax, %r12
movl $0x1, (%r15)
leaq 0x1(%rax), %rdi
callq 0xc040
movq %rax, 0x8(%r15)
movq %r12, 0x10(%r15)
movq %r12, 0x18(%r15)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xc150
movq %r12, 0x18(%r15)
movq %r15, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xfbe0
movq %rbx, %rdi
callq 0xc290
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSL.h
// Function: PSL::PSLVM::run(PSL::variable const&)
rsv run(const variable &arg = 0)
	{
		if (!env.Runable())
			return rsv();
		#ifdef PSL_DEBUG
		if (!init)
		#endif
		env.push(arg);
		env.Run();
		return env.pop();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x20(%rsi)
je 0xc9f1
movq %rsi, %r14
movq (%rdx), %rax
incl 0x8(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x8(%r14), %rdi
callq 0xfc38
movq (%rsp), %rdi
callq 0xfc04
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0xc9e4
movq 0x18(%rdx), %rdi
addq $0x20, %rdx
movq %r14, %rsi
callq 0x1315e
testb %al, %al
jne 0xc9c7
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf800
jmp 0xc9f9
movq %rbx, %rdi
callq 0xd926
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xca1a
movq %rax, %rbx
movq (%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSL.h
// Function: PSL::PSLVM::writeCompiledCode(PSL::variable::string const&)
error writeCompiledCode(const string &filename)
	{
		using namespace std;
		FILE *fp = fopen(filename, "wb");
		if (!fp)
			return FOPEN_ERROR;
		writeCompiledCode(fp);
		fclose(fp);
		return NONE;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0xcab3
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x8(%rax), %rdi
jmp 0xcaba
leaq 0x1bc38(%rip), %rdi     # 0x286f2
leaq 0x1bfd1(%rip), %rsi     # 0x28a92
callq 0xc200
testq %rax, %rax
je 0xcae5
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x27d5c
movq %r14, %rdi
callq 0xc1b0
xorl %eax, %eax
jmp 0xcaea
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/memory.h
// Function: PSL::variable::MemoryPool<64ul, 256>::pool::add()
DATA *add()
		{
			pool *n = new pool;
			if (next)
				n->next = next;
			next = n;
			return next->ptr;
		}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x4008, %edi           # imm = 0x4008
callq 0xc1c0
movq $0x0, 0x4000(%rax)
movq %rax, %rcx
addq $0x40, %rcx
xorl %edx, %edx
leaq (%rcx,%rdx), %rsi
movq %rsi, (%rax,%rdx)
leaq 0x40(%rdx), %rsi
movq %rsi, %rdx
cmpq $0x4000, %rsi           # imm = 0x4000
jne 0xe0a4
movq $0x0, 0x3fc0(%rax)
movq 0x4000(%rbx), %rcx
testq %rcx, %rcx
je 0xe0da
movq %rcx, 0x4000(%rax)
movq %rax, 0x4000(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::Variable::vObject::exist(PSL::variable::string const&) const
size_t count(const string &s) const
	{
		if (!reserve)	return 0;
		if (search(s) < 0)
			return 0;
		return 1;
	}

// Assembly:
cmpq $0x0, 0x28(%rdi)
je 0xebb9
pushq %rax
addq $0x20, %rdi
callq 0x13534
testl %eax, %eax
setns %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Environment::pop()
rsv pop()
	{
		#ifdef PSL_CHECKSTACK_POP
		if (stack.empty())
		{
			warning(2);
			return rsv();
		}
		#endif
	#ifdef PSL_USE_STL_STACK
		rsv v = stack.top();
		stack.pop();
		return v;
	#else
		return stack.pop();
	#endif
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x18(%rsi)
je 0xf827
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfa32
jmp 0xf862
leaq 0x18ec4(%rip), %rsi     # 0x286f2
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xc75c
movq %r14, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0xf8da
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf85a
callq 0xfbc0
movq %rbx, %rdi
callq 0xd926
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf881
callq 0xfbc0
movq %rbx, %rdi
callq 0xc290
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Environment::warning(int, PSL::variable::string const&)
void warning(const int n, const string &s = "")
	{
		if (WARNING & (1 << n))
		{
			PSL_PRINTF(("%s : ", scope->getCurrentLabel().c_str()));
			switch (n)
			{
			case 0:PSL_PRINTF(("runtime warning : %s stack remained when deleting env\n", s.c_str()));break;
			case 1:PSL_PRINTF(("runtime warning : undeclared identidier %s\n", s.c_str()));break;
			case 2:PSL_PRINTF(("runtime error : pop empty stack\n"));break;
			case 3:PSL_PRINTF(("runtime warning : declared identidier %s already exist, over write\n", s.c_str()));break;
			case 4:PSL_PRINTF(("runtime warning : undefined member name %s\n", s.c_str()));break;
			}
		}
	}

// Assembly:
movl $0x15, %eax
btl %esi, %eax
jae 0xfa31
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq 0x20(%rdi), %rax
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xfa9e
movq (%r14), %rax
testq %rax, %rax
je 0xf928
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x8(%rax), %rsi
jmp 0xf92f
leaq 0x18dc3(%rip), %rsi     # 0x286f2
leaq 0x18af7(%rip), %rdi     # 0x2842d
xorl %eax, %eax
callq 0xc050
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf94c
callq 0xfbc0
cmpl $0x4, %ebp
ja 0xfa29
movl %ebp, %eax
leaq 0x186f2(%rip), %rcx     # 0x28050
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rax
testq %rax, %rax
je 0xfa04
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x8(%rax), %rsi
jmp 0xfa0b
movq (%rbx), %rax
testq %rax, %rax
je 0xf9e4
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x8(%rax), %rsi
jmp 0xf9eb
leaq 0x1910f(%rip), %rdi     # 0x28ab8
callq 0xc240
jmp 0xfa29
movq (%rbx), %rax
testq %rax, %rax
je 0xf9f4
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x8(%rax), %rsi
jmp 0xf9fb
movq (%rbx), %rax
testq %rax, %rax
je 0xfa14
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x8(%rax), %rsi
jmp 0xfa1b
leaq 0x18d07(%rip), %rsi     # 0x286f2
leaq 0x18ae8(%rip), %rdi     # 0x284da
jmp 0xfa22
leaq 0x18cf7(%rip), %rsi     # 0x286f2
leaq 0x18a94(%rip), %rdi     # 0x28496
jmp 0xfa22
leaq 0x18ce7(%rip), %rsi     # 0x286f2
leaq 0x18a21(%rip), %rdi     # 0x28433
jmp 0xfa22
leaq 0x18cd7(%rip), %rsi     # 0x286f2
leaq 0x18a48(%rip), %rdi     # 0x2846a
xorl %eax, %eax
callq 0xc050
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::rstack::pop()
rsv pop()
	{
		rsv v = x[--len];
		#ifdef PSL_USE_VARIABLE_MEMORY_MANAGER
		x[len] = StaticObject::rsvnull();
		#else
		PSL_CONST_STATIC rsv null;
		x[len] = null;
		#endif
		return v;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x10(%rsi), %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, 0x10(%rsi)
movq -0x8(%rax,%rcx,8), %rax
incl 0x8(%rax)
movq %rax, (%rdi)
callq 0xde8e
movq %rax, %r15
movq (%r14), %r12
movq 0x10(%r14), %r14
movq (%r12,%r14,8), %rdi
callq 0xfc04
movq (%r15), %rax
incl 0x8(%rax)
movq %rax, (%r12,%r14,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xca6a
movq %r14, %rdi
callq 0xc290
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::vector<PSL::variable::rsv>::reserve(unsigned long)
void reserve(size_t t)
	{
		if (t > res)
		{
			res = (res*2 > t) ? res*2: t;
			T *n = new T[res];
			for (size_t i = 0; i < len; ++i)
				n[i] = x[i];
			delete[] x;
			x = n;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r12
cmpq %rsi, %r12
jae 0xfd83
movq %rdi, %rbx
addq %r12, %r12
cmpq %rsi, %r12
cmovbeq %rsi, %r12
movq %r12, 0x8(%rdi)
movq %r12, %rax
shrq $0x3d, %rax
leaq (,%r12,8), %r14
movq %r14, %rcx
addq $0x8, %rcx
movq $-0x1, %rdx
cmovaeq %rcx, %rdx
xorl %ebp, %ebp
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rdx, %rdi
movq %rdi, (%rsp)
callq 0xc040
movq %rax, %r15
movq %r12, (%rax)
leaq 0x8(%rax), %r13
negq %r14
movq %r13, %r12
movq %r12, %rdi
callq 0xd926
addq $-0x8, %rbp
addq $0x8, %r12
cmpq %rbp, %r14
jne 0xfd03
cmpq $0x0, 0x10(%rbx)
je 0xfd44
xorl %r14d, %r14d
movq (%rbx), %r15
movq (%r13,%r14,8), %rdi
callq 0xfc04
movq (%r15,%r14,8), %rax
incl 0x8(%rax)
movq %rax, (%r13,%r14,8)
incq %r14
cmpq 0x10(%rbx), %r14
jb 0xfd22
movq (%rbx), %r14
testq %r14, %r14
je 0xfd80
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0xfd70
leaq (,%r15,8), %r12
movq (%r14,%r12), %rdi
callq 0xfc04
addq $-0x8, %r12
jne 0xfd61
leaq 0x8(,%r15,8), %rsi
movq %r14, %rdi
callq 0xc2d0
movq %r13, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0xde83
movq %rax, %rbx
testq %rbp, %rbp
je 0xfdb4
negq %rbp
leaq (%r15,%rbp), %rdi
callq 0xca6a
addq $-0x8, %rbp
jne 0xfda5
movq %r15, %rdi
movq (%rsp), %rsi
callq 0xc2d0
movq %rbx, %rdi
callq 0xc290
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/variable.h
// Function: PSL::variable::Variable::Variable(PSL::variable::Type)
Variable(Type t){rc = 1;switch (t){
			case NIL:		x = new vBase();break;
			case INT:		x = new vInt(0);break;
			case HEX:		x = new vHex(0);break;
			case FLOAT:		x = new vFloat(0);break;
			case STRING:	x = new vString("");break;
			case POINTER:	x = new vPointer();break;
			case RARRAY:	x = new vRArray();break;
			case THREAD:	x = new vThread();break;
			default:		x = new vObject();break;
		}}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, 0x8(%rdi)
cmpl $0xf, %esi
ja 0xfe37
movl %esi, %eax
leaq 0x1824a(%rip), %rcx     # 0x28064
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0xf762
leaq 0x2b6e9(%rip), %rcx     # 0x3b518
movq %rcx, (%rax)
jmp 0xfeea
callq 0xe046
leaq 0x2b4ed(%rip), %rcx     # 0x3b330
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movq $0x0, 0x38(%rax)
jmp 0xfeea
callq 0x10058
leaq 0x2bfca(%rip), %rcx     # 0x3be38
jmp 0xfedf
callq 0x10058
leaq 0x2b85c(%rip), %rcx     # 0x3b6d8
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
jmp 0xfeea
callq 0x1055a
movq %rax, %r14
leaq 0x2c179(%rip), %rax     # 0x3c010
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
movl $0x2, %esi
callq 0x11d98
jmp 0xff3f
callq 0x128c4
leaq 0x2c32f(%rip), %rcx     # 0x3c1e8
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
jmp 0xfeea
callq 0x10058
leaq 0x2b9df(%rip), %rcx     # 0x3b8b0
jmp 0xfedf
callq 0x10058
leaq 0x2bba9(%rip), %rcx     # 0x3ba88
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x10058
movq %rax, %r14
leaq 0x187ee(%rip), %rsi     # 0x286f2
movq %rsp, %rdi
callq 0xc75c
leaq 0x2bd4d(%rip), %rax     # 0x3bc60
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xff37
incl (%rdi)
movq %rdi, 0x8(%r14)
movq %r14, (%rbx)
callq 0xfbc0
jmp 0xfeed
movq $0x0, 0x8(%r14)
movq %r14, (%rbx)
jmp 0xfeed
movq %rax, %rbx
movq %r14, %rdi
callq 0xffd0
jmp 0xff5c
movq %rax, %rbx
movq %r14, %rdi
callq 0x10018
movq %rbx, %rdi
callq 0xc290
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::sethex(unsigned long, unsigned long)
void sethex(unsigned long i, size_t c = 0)
	{
		char *b = buf->buffer();
		#define C(n) if (i >= n){char a = (char)((i/n)&0xF);b[c++] = (char)(a<10 ? a+ZERO : a-10+'A');}
		C(0x10000000)
		C(0x1000000)
		C(0x100000)
		C(0x10000)
		C(0x1000)
		C(0x100)
		C(0x10)
		#undef C
		{char a = (char)(i&0xF);b[c++] = (char)(a<10 ? a+ZERO : a-10+'A');}
		buf->setlen(c);
	}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rax), %rax
cmpq $0x10000000, %rsi       # imm = 0x10000000
jb 0x108f4
movl %esi, %ecx
shrl $0x1c, %ecx
leal 0x37(%rcx), %r8d
orb $0x30, %cl
cmpl $0xa0000000, %esi       # imm = 0xA0000000
movzbl %cl, %ecx
movzbl %r8b, %r8d
cmovbl %ecx, %r8d
movb %r8b, (%rax,%rdx)
incq %rdx
cmpq $0x1000000, %rsi        # imm = 0x1000000
jb 0x10923
movl %esi, %ecx
shrl $0x18, %ecx
andl $0xf, %ecx
leal 0x37(%rcx), %r8d
leal 0x30(%rcx), %r9d
cmpl $0xa, %ecx
movzbl %r9b, %ecx
movzbl %r8b, %r8d
cmovbl %ecx, %r8d
movb %r8b, (%rax,%rdx)
incq %rdx
cmpq $0x100000, %rsi         # imm = 0x100000
jb 0x10952
movl %esi, %ecx
shrl $0x14, %ecx
andl $0xf, %ecx
leal 0x37(%rcx), %r8d
leal 0x30(%rcx), %r9d
cmpl $0xa, %ecx
movzbl %r9b, %ecx
movzbl %r8b, %r8d
cmovbl %ecx, %r8d
movb %r8b, (%rax,%rdx)
incq %rdx
cmpq $0x10000, %rsi          # imm = 0x10000
jb 0x10981
movl %esi, %ecx
shrl $0x10, %ecx
andl $0xf, %ecx
leal 0x37(%rcx), %r8d
leal 0x30(%rcx), %r9d
cmpl $0xa, %ecx
movzbl %r9b, %ecx
movzbl %r8b, %r8d
cmovbl %ecx, %r8d
movb %r8b, (%rax,%rdx)
incq %rdx
cmpq $0x1000, %rsi           # imm = 0x1000
jb 0x109b0
movl %esi, %ecx
shrl $0xc, %ecx
andl $0xf, %ecx
leal 0x37(%rcx), %r8d
leal 0x30(%rcx), %r9d
cmpl $0xa, %ecx
movzbl %r9b, %ecx
movzbl %r8b, %r8d
cmovbl %ecx, %r8d
movb %r8b, (%rax,%rdx)
incq %rdx
cmpq $0x100, %rsi            # imm = 0x100
jb 0x109df
movl %esi, %ecx
shrl $0x8, %ecx
andl $0xf, %ecx
leal 0x37(%rcx), %r8d
leal 0x30(%rcx), %r9d
cmpl $0xa, %ecx
movzbl %r9b, %ecx
movzbl %r8b, %r8d
cmovbl %ecx, %r8d
movb %r8b, (%rax,%rdx)
incq %rdx
cmpq $0x10, %rsi
jb 0x10a0b
movl %esi, %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
leal 0x37(%rcx), %r8d
leal 0x30(%rcx), %r9d
cmpl $0xa, %ecx
movzbl %r9b, %ecx
movzbl %r8b, %r8d
cmovbl %ecx, %r8d
movb %r8b, (%rax,%rdx)
incq %rdx
andl $0xf, %esi
leal 0x37(%rsi), %ecx
leal 0x30(%rsi), %r8d
cmpl $0xa, %esi
movzbl %r8b, %esi
movzbl %cl, %ecx
cmovbl %esi, %ecx
movb %cl, (%rax,%rdx)
incq %rdx
movq (%rdi), %rax
movq %rdx, 0x18(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator+=(PSL::variable::string const&)
string &operator+=(const string &s)
	{
		if (s.buf)
		{
			if (!buf)
			{
				buf = s.buf->inc();
			}
			else
			{
				size_t c = buf->length();
				only_and_extend(c + s.buf->length());
				buf->fcopy(s.buf->buffer(), s.buf->length(), c);
			}
		}
		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x1111c
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x11117
movq %rsi, %r14
movq 0x18(%rcx), %r15
movq 0x18(%rax), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x1112c
movq (%rbx), %r12
movq (%r14), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rax), %r14
movq 0x8(%r12), %rdi
addq %r15, %rdi
movq %r14, %rdx
callq 0xc150
addq %r15, %r14
movq %r14, 0x18(%r12)
jmp 0x1111c
incl (%rax)
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::only_and_extend(unsigned long)
void only_and_extend(size_t t)
	{
		if (buf->shared() || (buf->maxlength() < t))
		{
			SharedBuffer *o = buf;
			buf = buf->clone(t+SPARE);
			o->finalize();
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
cmpl $0x1, (%rbx)
jne 0x11141
cmpq %rsi, 0x10(%rbx)
jae 0x1115f
addq $0xb, %rsi
movq %rbx, %rdi
callq 0x11168
movq %rax, (%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfbc0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator*=(unsigned long)
string &operator*=(size_t i)	/* i���̕����� */
	{
		if (buf)
		{
			size_t c = buf->length();
			only_and_extend(c*i);
			for (size_t x = 0; x < i; ++x)
				buf->fcopy(buf->buffer(), c, c*x);
		}
		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x11225
movq %rsi, %r14
movq 0x18(%rax), %r15
movq %r15, %rsi
imulq %r14, %rsi
movq %rbx, %rdi
callq 0x1112c
testq %r14, %r14
je 0x11225
xorl %r12d, %r12d
movq (%rbx), %r13
movq 0x8(%r13), %rsi
leaq (%rsi,%r12), %rdi
movq %r15, %rdx
callq 0xc150
addq %r15, %r12
movq %r12, 0x18(%r13)
decq %r14
jne 0x11206
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator%=(unsigned long)
string &operator%=(size_t i)	/* �擪i������������ */
	{
		if (buf)
		{
			size_t c = buf->length();
			if (buf->shared())
			{
				if (i < c)
				{
					SharedBuffer *n = new SharedBuffer(c);
					n->fcopy(buf->buffer()+i, c-i);
					buf->finalize();
					buf = n;
				}
				else
				{
					buf->finalize();
					buf = NULL;
				}
			}
			else
			{
				if (i < c)
					buf->fmove(buf->buffer()+i, c-i);
				else
					buf->setlen(0);
			}
		}
		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x112eb
movq %rsi, %r14
movq 0x18(%r12), %r15
cmpl $0x1, (%r12)
jne 0x11278
subq %r14, %r15
jbe 0x112d1
movq 0x8(%r12), %rdi
addq %rdi, %r14
movq %r14, %rsi
movq %r15, %rdx
callq 0xc260
movq %r15, 0x18(%r12)
jmp 0x112eb
movq %r15, %r13
subq %r14, %r13
jbe 0x112dc
callq 0x1055a
movq %rax, %r12
movl $0x1, (%rax)
leaq 0x1(%r15), %rdi
callq 0xc040
movq %rax, 0x8(%r12)
movq %r15, 0x10(%r12)
movq $0x0, 0x18(%r12)
movq (%rbx), %r15
addq 0x8(%r15), %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xc150
movq %r13, 0x18(%r12)
movq %r15, %rdi
callq 0xfbc0
movq %r12, (%rbx)
jmp 0x112eb
movq $0x0, 0x18(%r12)
jmp 0x112eb
movq %r12, %rdi
callq 0xfbc0
movq $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0xfbe0
movq %rbx, %rdi
callq 0xc290
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator==(PSL::variable::string const&) const
bool operator==(const string &s) const
	{
		if (buf == s.buf)					return true;
		if (!buf || !s.buf)					return false;
		size_t l = buf->length();
		if (l != s.buf->length())			return false;
		return !std::memcmp(buf->buffer(), s.buf->buffer(), l);
	}

// Assembly:
movq (%rdi), %rax
movq (%rsi), %rcx
cmpq %rcx, %rax
je 0x1134e
testq %rax, %rax
sete %dl
testq %rcx, %rcx
sete %sil
orb %dl, %sil
jne 0x1134b
movq 0x18(%rax), %rdx
cmpq 0x18(%rcx), %rdx
jne 0x1134b
pushq %rax
movq 0x8(%rax), %rdi
movq 0x8(%rcx), %rsi
callq 0xc1e0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator<=(PSL::variable::string const&) const
bool operator<=(const string &s) const
	{
		if (buf == s.buf)	return true;
		if (!buf)			return true;
		if (!s.buf)			return false;
		size_t max = min_s(buf->length(), s.buf->length());
		for (size_t t = 0; t < max; ++t)
		{
			if (buf->at(t) < s.buf->at(t))	return true;
			if (buf->at(t) > s.buf->at(t))	return false;
		}
		if (buf->length() <= s.buf->length())	return true;
		return false;
	}

// Assembly:
movq (%rdi), %r8
movq (%rsi), %rsi
cmpq %rsi, %r8
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
movb $0x1, %al
jne 0x113dd
testq %rsi, %rsi
je 0x113c5
pushq %rbx
movq 0x18(%r8), %rax
movq 0x18(%rsi), %rcx
cmpq %rcx, %rax
movq %rcx, %rdi
cmovbq %rax, %rdi
testq %rdi, %rdi
setne %dl
je 0x113c9
movq 0x8(%r8), %r8
movq 0x8(%rsi), %r9
movb (%r8), %r11b
movb (%r9), %bl
movb $0x1, %sil
cmpb %bl, %r11b
jl 0x113c9
movl $0x1, %r10d
cmpb %bl, %r11b
jg 0x113e0
cmpq %rdi, %r10
setb %dl
je 0x113c9
movb (%r8,%r10), %r11b
movb (%r9,%r10), %bl
incq %r10
cmpb %bl, %r11b
jge 0x113a6
jmp 0x113c9
xorl %eax, %eax
jmp 0x113dd
xorl %edi, %edi
cmpq %rcx, %rax
setbe %dil
movzbl %sil, %eax
testb $0x1, %dl
cmovel %edi, %eax
popq %rbx
andb $0x1, %al
retq
xorl %esi, %esi
jmp 0x113c9
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::reverse()
string &reverse()	/* ���]������ */
	{
		if (buf)
		{
			size_t m = buf->length();
			only_and_extend(m);
			size_t e = m/2;
			char *b = buf->buffer();
			for (size_t t = 0; t < e; ++t)
			{
				char temp = b[t];
				b[t] = b[m-t-1];
				b[m-t-1] = temp;
			}
		}
		return *this;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x114c4
movq 0x18(%rax), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1112c
cmpq $0x2, %r14
jb 0x114c4
movq %r14, %rax
shrq %rax
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
negq %rax
leaq (%r14,%rcx), %rdx
decq %rdx
xorl %esi, %esi
movb (%rcx), %dil
movb (%rdx,%rsi), %r8b
movb %r8b, (%rcx)
movb %dil, (%rdx,%rsi)
decq %rsi
incq %rcx
cmpq %rsi, %rax
jne 0x114ab
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator int() const
operator int() const
	{
		if (!buf)	return 0;
		char *b = buf->buffer();
		size_t l = buf->length();
		bool minus = false;
		size_t c = 0;
		int r = 0;
		for (; c < l; ++c)
		{
			if (b[c] != SPACE && b[c] != TAB)
				break;
		}
		if (b[c] == MINUS)
		{
			minus = true;
			++c;
		}
		for (; c < l; ++c)
		{
			if (!(b[c] >= ZERO && b[c] <= ZERO+9))
				break;
			r *= 10;
			r += b[c] - ZERO;
		}
		if (minus)
			r = -r;
		return r;
	}

// Assembly:
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x11549
movq 0x8(%rcx), %rax
movq 0x18(%rcx), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
testq %rdx, %rdx
je 0x11504
movzbl (%rax,%r8), %esi
cmpl $0x20, %esi
je 0x114f9
cmpl $0x9, %esi
jne 0x11504
incq %r8
cmpq %r8, %rdx
jne 0x114ea
movq %rdx, %r8
movb (%rax,%r8), %sil
xorl %edi, %edi
cmpb $0x2d, %sil
sete %dil
addq %r8, %rdi
cmpq %rdx, %rdi
jae 0x1153d
xorl %ecx, %ecx
movb (%rax,%rdi), %r8b
addb $-0x30, %r8b
cmpb $0x9, %r8b
ja 0x1153d
leal (%rcx,%rcx,4), %ecx
movzbl %r8b, %r8d
leal (%r8,%rcx,2), %ecx
incq %rdi
cmpq %rdx, %rdi
jb 0x1151c
movl %ecx, %eax
negl %eax
cmpb $0x2d, %sil
cmovnel %ecx, %eax
retq
xorl %eax, %eax
retq