LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x9770
movb %al, -0xb(%rbp)
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %ecx
movb $0x1, %al
cmpl $0x3c, %ecx
movb %al, -0x19(%rbp)
je 0x9718
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %ecx
movb $0x1, %al
cmpl $0x3e, %ecx
movb %al, -0x19(%rbp)
je 0x9718
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %ecx
movb $0x1, %al
cmpl $0x12c, %ecx            # imm = 0x12C
movb %al, -0x19(%rbp)
je 0x9718
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %eax
cmpl $0x12d, %eax            # imm = 0x12D
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x9721
jmp 0x9766
movq -0x18(%rbp), %rdi
movw 0x18(%rdi), %ax
movw %ax, -0xa(%rbp)
callq 0x8e50
movq -0x18(%rbp), %rdi
callq 0x9770
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, -0xc(%rbp)
movq 0x10(%rax), %rdi
movw -0xa(%rbp), %cx
movb -0xb(%rbp), %al
movswl %cx, %esi
movsbl %al, %edx
movsbl -0xc(%rbp), %ecx
callq 0x2fc0
movb %al, -0xb(%rbp)
jmp 0x96cc
movb -0xb(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x9810
movb %al, -0xa(%rbp)
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %ecx
movb $0x1, %al
cmpl $0x2b, %ecx
movb %al, -0x19(%rbp)
je 0x97af
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x97b8
jmp 0x97f8
movq -0x18(%rbp), %rdi
movw 0x18(%rdi), %ax
movb %al, -0x9(%rbp)
callq 0x8e50
movq -0x18(%rbp), %rdi
callq 0x9810
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, -0xb(%rbp)
movq 0x10(%rax), %rdi
movb -0x9(%rbp), %cl
movb -0xa(%rbp), %al
movsbl %cl, %esi
movsbl %al, %edx
movsbl -0xb(%rbp), %ecx
callq 0x2de0
movb %al, -0xa(%rbp)
jmp 0x978c
movb -0xa(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x98b0
movb %al, -0xa(%rbp)
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %ecx
movb $0x1, %al
cmpl $0x2a, %ecx
movb %al, -0x19(%rbp)
je 0x984f
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x9858
jmp 0x9898
movq -0x18(%rbp), %rdi
movw 0x18(%rdi), %ax
movb %al, -0x9(%rbp)
callq 0x8e50
movq -0x18(%rbp), %rdi
callq 0x98b0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, -0xb(%rbp)
movq 0x10(%rax), %rdi
movb -0x9(%rbp), %cl
movb -0xa(%rbp), %al
movsbl %cl, %esi
movsbl %al, %edx
movsbl -0xb(%rbp), %ecx
callq 0x2de0
movb %al, -0xa(%rbp)
jmp 0x982c
movb -0xa(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movswl 0x18(%rax), %eax
cmpl $0x2d, %eax
jne 0x98fa
movq -0x20(%rbp), %rdi
callq 0x8e50
movq -0x20(%rbp), %rdi
callq 0x98b0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movq 0x10(%rax), %rdi
movsbl -0x11(%rbp), %esi
callq 0x2ce0
movb %al, -0x1(%rbp)
jmp 0x9906
movq -0x20(%rbp), %rdi
callq 0x9910
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
movq %rdi, -0x28(%rbp)
callq 0xa4f0
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x20(%rbp)
callq 0xa510
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x50(%rax)
movl $0x0, 0x54(%rax)
movl $0x0, 0x58(%rax)
callq 0xa530
jmp 0x9e77
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa5a0
movq -0x28(%rbp), %rdi
callq 0xa5c0
movq -0x10(%rbp), %rdi
callq 0x2390
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xa293
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0xa620
movq -0x88(%rbp), %rsi
movq %rax, %rdi
callq 0xa640
movq -0x80(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0xa620
movq %rax, %rdi
callq 0xa6a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa8b0
testb $0x1, %al
jne 0xa271
jmp 0xa286
leaq -0x20(%rbp), %rdi
callq 0xa8e0
movb 0x20(%rax), %al
addq $0x90, %rsp
popq %rbp
retq
jmp 0xa288
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa217
movb $0x1, -0x75(%rbp)
movl $0x20, %edi
callq 0x2120
movq -0x88(%rbp), %rdx
movq %rax, -0x90(%rbp)
leaq 0x3f6c(%rip), %rsi      # 0xe222
leaq -0x68(%rbp), %rdi
callq 0xa7a0
jmp 0xa2c1
leaq 0x3f7d(%rip), %rdx      # 0xe245
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6db0
jmp 0xa2d7
movq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6400
jmp 0xa2e9
movq -0x90(%rbp), %rdi
movb $0x0, -0x75(%rbp)
leaq 0xaab5(%rip), %rsi      # 0x14db0
leaq -0x69d2(%rip), %rdx     # 0x3930
callq 0x2370
jmp 0xa362
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xa343
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xa33a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2160
leaq -0x68(%rbp), %rdi
callq 0x2160
testb $0x1, -0x75(%rbp)
jne 0xa34b
jmp 0xa357
movq -0x90(%rbp), %rdi
callq 0x21b0
jmp 0xa359
movq -0x70(%rbp), %rdi
callq 0x2390
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xa413
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0xa620
movq -0x88(%rbp), %rsi
movq %rax, %rdi
callq 0xa640
movq -0x80(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0xa620
movq %rax, %rdi
callq 0xa6a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa8b0
testb $0x1, %al
jne 0xa3f1
jmp 0xa406
leaq -0x20(%rbp), %rdi
callq 0xa8e0
movl 0x24(%rax), %eax
addq $0x90, %rsp
popq %rbp
retq
jmp 0xa408
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa397
movb $0x1, -0x75(%rbp)
movl $0x20, %edi
callq 0x2120
movq -0x88(%rbp), %rdx
movq %rax, -0x90(%rbp)
leaq 0x3dec(%rip), %rsi      # 0xe222
leaq -0x68(%rbp), %rdi
callq 0xa7a0
jmp 0xa441
leaq 0x3dfd(%rip), %rdx      # 0xe245
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6db0
jmp 0xa457
movq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6400
jmp 0xa469
movq -0x90(%rbp), %rdi
movb $0x0, -0x75(%rbp)
leaq 0xa935(%rip), %rsi      # 0x14db0
leaq -0x6b52(%rip), %rdx     # 0x3930
callq 0x2370
jmp 0xa4e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xa4c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xa4ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2160
leaq -0x68(%rbp), %rdi
callq 0x2160
testb $0x1, -0x75(%rbp)
jne 0xa4cb
jmp 0xa4d7
movq -0x90(%rbp), %rdi
callq 0x21b0
jmp 0xa4d9
movq -0x70(%rbp), %rdi
callq 0x2390
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2550
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2230
movq -0x98(%rbp), %rsi
movq 0x1ab47(%rip), %rdi     # 0x1cfe0
callq 0x2050
jmp 0x24a0
leaq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x20c0
jmp 0x24b2
leaq -0x40(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x3280
jmp 0x24c4
leaq -0x90(%rbp), %rdi
callq 0x2120
leaq -0x40(%rbp), %rdi
callq 0x30d0
jmp 0x24db
movl $0x0, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2120
leaq -0x40(%rbp), %rdi
callq 0x2570
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2526
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2120
leaq -0x60(%rbp), %rdi
callq 0x2120
leaq -0x40(%rbp), %rdi
callq 0x2570
movq -0x68(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5970
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x59a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x59d0
testb $0x1, %al
jne 0x3117
jmp 0x326d
leaq -0x18(%rbp), %rdi
callq 0x5a00
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x5a30
movl -0x40(%rbp), %esi
movq 0x19e92(%rip), %rdi     # 0x1cfc8
callq 0x22b0
movq %rax, -0x78(%rbp)
jmp 0x3141
movq -0x78(%rbp), %rdi
leaq 0xfecc(%rip), %rsi      # 0x13018
callq 0x2190
jmp 0x3153
leaq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5a70
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5aa0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5ad0
testb $0x1, %al
jne 0x318f
jmp 0x3241
leaq -0x60(%rbp), %rdi
callq 0x5b00
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movl (%rax), %esi
movq 0x19e1f(%rip), %rdi     # 0x1cfc8
callq 0x22b0
movq %rax, -0x80(%rbp)
jmp 0x31b4
movq -0x80(%rbp), %rdi
leaq 0xfe5c(%rip), %rsi      # 0x1301b
callq 0x2190
movq %rax, -0x88(%rbp)
jmp 0x31cd
movq -0x88(%rbp), %rdi
movq -0x70(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x22b0
movq %rax, -0x90(%rbp)
jmp 0x31e9
movq -0x90(%rbp), %rdi
leaq 0xfea9(%rip), %rsi      # 0x130a0
callq 0x2190
movq %rax, -0x98(%rbp)
jmp 0x3205
movq -0x98(%rbp), %rdi
leaq 0xfe0a(%rip), %rsi      # 0x1301d
callq 0x2190
jmp 0x321a
jmp 0x321c
leaq -0x60(%rbp), %rdi
callq 0x5b20
jmp 0x3179
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2a40
jmp 0x3276
movq 0x19d80(%rip), %rdi     # 0x1cfc8
movq 0x19d69(%rip), %rsi     # 0x1cfb8
callq 0x21d0
jmp 0x3256
leaq -0x40(%rbp), %rdi
callq 0x2a40
leaq -0x18(%rbp), %rdi
callq 0x5b40
jmp 0x3101
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22c0
nop
// File: 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
subq $0xc0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, %rax
movq -0xb0(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x6460
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x64c0
testb $0x1, %al
jne 0x4d1e
jmp 0x4d27
movb $0x1, -0x1(%rbp)
jmp 0x4e30
movq -0xa8(%rbp), %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x6460
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x64f0
movq -0xa0(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x5890
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x5a70
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x5aa0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5ad0
testb $0x1, %al
jne 0x4d96
jmp 0x4e2c
leaq -0x50(%rbp), %rdi
callq 0x5b00
movq -0xa8(%rbp), %rsi
movq %rax, -0x60(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x6540
movq -0xa0(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0x60(%rbp), %rax
movl (%rax), %edx
callq 0x4cc0
movb %al, -0xb1(%rbp)
jmp 0x4dde
leaq -0x88(%rbp), %rdi
callq 0x66d0
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x4df6
jmp 0x4e1c
movb $0x1, -0x1(%rbp)
jmp 0x4e30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x66d0
jmp 0x4e3e
jmp 0x4e1e
leaq -0x50(%rbp), %rdi
callq 0x5b20
jmp 0x4d80
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x22c0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x837a1(%rip), %rsi     # 0xc2340
callq 0x12e80
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x28(%rbp)
callq 0x2c680
movq -0x10(%rbp), %rdi
leaq 0x83780(%rip), %rsi     # 0xc2340
callq 0x3ec30
testb $0x1, %al
jne 0x3ebcb
jmp 0x3ebe2
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x39be0
jmp 0x3ec13
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x31f30
jmp 0x3ebf1
jmp 0x3ec13
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x15250
movq -0x30(%rbp), %rdi
callq 0x12eb0
jmp 0x3ec19
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x84c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x68(%rbp)
movq %rdx, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x507f0
movq -0x78(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq 0x3d135(%rip), %rsi     # 0xc2340
callq 0x50ef0
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1eeb0
movq %rax, %rsi
leaq 0x3d115(%rip), %rdi     # 0xc2340
callq 0x15fd0
leaq -0x28(%rbp), %rdi
callq 0x12eb0
movq -0x68(%rbp), %rsi
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x15ec0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x15ef0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x15f20
testb $0x1, %al
jne 0x8526e
jmp 0x852d0
leaq -0x38(%rbp), %rdi
callq 0x15f60
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x15f80
leaq 0x3d0b2(%rip), %rdi     # 0xc2340
callq 0x15ea0
movq -0x80(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
callq 0x1a7c0
jmp 0x852a5
leaq -0x50(%rbp), %rdi
callq 0x120c0
leaq -0x38(%rbp), %rdi
callq 0x15fb0
jmp 0x8525b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x120c0
jmp 0x85346
leaq 0x3d161(%rip), %rdi     # 0xc2438
callq 0x1ef30
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, -0x60(%rbp)
cmpl $0x1, -0x60(%rbp)
jne 0x85334
movl $0x8, %edi
callq 0x8160
movq %rax, %rdi
movq %rdi, -0x88(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x8180
movq -0x88(%rbp), %rdi
callq 0x50f70
movq -0x88(%rbp), %rdi
leaq 0x3b4a8(%rip), %rsi     # 0xc07d0
leaq -0x3437f(%rip), %rdx    # 0x50fb0
callq 0x84a0
cmpl $0x2, -0x60(%rbp)
sete %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x84c0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3a180
cmpl $0x0, %eax
jne 0xc82f
movl $0x0, -0x4(%rbp)
jmp 0xc89d
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x26ae0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc850
movl $0x1, -0x4(%rbp)
jmp 0xc89d
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a230
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xc887
movq -0x38(%rbp), %rdi
callq 0x22fb0
movq -0x38(%rbp), %rdi
movl $0x70, %esi
callq 0xc1e0
testb $0x1, -0x21(%rbp)
je 0xc896
movl $0x2, -0x4(%rbp)
jmp 0xc89d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
jne 0xca0b
movl $0x20, %edi
callq 0x13750
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl $0xb, %esi
callq 0x13770
jmp 0xc9c0
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movb -0x9(%rbp), %cl
movb %cl, -0x39(%rbp)
movq (%rax), %rdi
callq 0x13b70
movb -0x39(%rbp), %dl
movq %rax, %rcx
movq -0x30(%rbp), %rax
movb %dl, (%rcx)
movq (%rax), %rdi
movl $0x1, %esi
callq 0x13b90
jmp 0xca61
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x12250
jmp 0xca6b
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0x152e0
movq -0x30(%rbp), %rax
movb -0x9(%rbp), %cl
movb %cl, -0x3a(%rbp)
movq (%rax), %rdi
callq 0x13b70
movb -0x3a(%rbp), %sil
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdx
movb %sil, (%rcx,%rdx)
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0x13b90
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x26840
testb $0x1, %al
jne 0xcaa7
jmp 0xcab4
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcb52
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xcb01
movl $0x20, %edi
callq 0x13750
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
callq 0x26870
jmp 0xcadd
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xcb4a
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x12250
jmp 0xcb5c
movq -0x18(%rbp), %rdi
callq 0xc0c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x152c0
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
addq -0x30(%rbp), %rsi
callq 0x152e0
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x15350
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x19fe0
testb $0x1, %al
jne 0xcc6b
movq -0x48(%rbp), %rdi
callq 0xdf50
jmp 0xccc3
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x11b10
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x11aa0
jmp 0xcc8b
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x38(%rbp), %rdi
callq 0x1a2b0
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11950
jmp 0xccc3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcd90
jmp 0xcccd
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x23050
movq %rax, %rdi
leaq 0x31f4d(%rip), %rsi     # 0x3ede8
callq 0xc200
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xceb4
movl $0x1, -0x4(%rbp)
jmp 0xced1
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3cf60
movq -0x20(%rbp), %rdi
callq 0xc1c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Silica[P]PSL/./PSL/memory.h
// Function: PSL::variable::VMemoryPool::nextptr()
void *nextptr()
	{
		if (!current)
			current = p.add();
		DATA *c = current;
		current = c->next;
		return c;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
jne 0xe0e1
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0xefb0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/memory.h
// Function: PSL::variable::MemoryPool<24ul, 256>::pool::pool()
pool()	{next = NULL;
			for (DATA *p = ptr; p != ptr+poolsize;)
			{
				DATA *c = p;
				c->next = ++p;
			}
			ptr[poolsize-1].next = NULL;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, 0x1800(%rax)
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x1800, %rcx           # imm = 0x1800
cmpq %rcx, %rax
je 0xe800
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
movq %rcx, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xe7cf
movq -0x20(%rbp), %rax
movq $0x0, 0x17e8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/memory.h
// Function: PSL::variable::VMemoryPool::pool::pool()
pool()	{next = NULL;
			for (int i = 0; i < poolsize; ++i)
			{
				ptr[i].x = 0;
				ptr[i].next = ptr+i+1;
			}
			ptr[poolsize-1].next = NULL;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, 0x1000(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0xeb9f
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movl $0x0, (%rcx)
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
movq %rax, %rcx
addq %rdx, %rcx
addq $0x10, %rcx
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xeb52
movq -0x18(%rbp), %rax
movq $0x0, 0xff8(%rax)
popq %rbp
retq
// File: Silica[P]PSL/./PSL/memory.h
// Function: PSL::variable::VMemoryPool::pool::add()
DATA *add()
		{
			pool *n = new pool;
			if (next)
				n->next = next;
			next = n;
			return next->ptr;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1008, %edi           # imm = 0x1008
callq 0xc1d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0xeb30
jmp 0xefdf
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, 0x1000(%rax)
je 0xf029
movq -0x30(%rbp), %rax
movq 0x1000(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1000(%rax)
jmp 0xf029
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x1008, %esi           # imm = 0x1008
callq 0xc1e0
jmp 0xf045
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x1000(%rax)
movq 0x1000(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xc280
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
callq 0x11b50
testb $0x1, %al
jne 0x11982
jmp 0x119d5
leaq 0x2d05a(%rip), %rsi     # 0x3e9e3
leaq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xc8b0
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rdx
movl $0x2, %esi
callq 0x11b70
jmp 0x119aa
leaq -0x18(%rbp), %rdi
callq 0xc950
movq -0x40(%rbp), %rdi
callq 0xdf50
jmp 0x119e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc950
jmp 0x119f0
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0x11cc0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xc280
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
andq $0x15, %rax
cmpq $0x0, %rax
je 0x11ca5
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x11d70
movq -0x48(%rbp), %rdi
callq 0xce20
movq %rax, -0x40(%rbp)
jmp 0x11bc9
movq -0x40(%rbp), %rsi
leaq 0x2cb14(%rip), %rdi     # 0x3e6e8
xorl %eax, %eax
callq 0xc050
jmp 0x11bdd
leaq -0x20(%rbp), %rdi
callq 0xc950
movl -0xc(%rbp), %eax
movq %rax, -0x50(%rbp)
subq $0x4, %rax
ja 0x11ca3
movq -0x50(%rbp), %rax
leaq 0x2c43e(%rip), %rcx     # 0x3e040
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc950
jmp 0x11cab
movq -0x18(%rbp), %rdi
callq 0xce20
movq %rax, %rsi
leaq 0x2cab6(%rip), %rdi     # 0x3e6ee
movb $0x0, %al
callq 0xc050
jmp 0x11ca3
movq -0x18(%rbp), %rdi
callq 0xce20
movq %rax, %rsi
leaq 0x2cad1(%rip), %rdi     # 0x3e725
movb $0x0, %al
callq 0xc050
jmp 0x11ca3
leaq 0x2caed(%rip), %rdi     # 0x3e751
movb $0x0, %al
callq 0xc050
jmp 0x11ca3
movq -0x18(%rbp), %rdi
callq 0xce20
movq %rax, %rsi
leaq 0x2caf2(%rip), %rdi     # 0x3e772
movb $0x0, %al
callq 0xc050
jmp 0x11ca3
movq -0x18(%rbp), %rdi
callq 0xce20
movq %rax, %rsi
leaq 0x2cb1a(%rip), %rdi     # 0x3e7b6
movb $0x0, %al
callq 0xc050
jmp 0x11ca5
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
movq (%rdx), %rax
movq 0x10(%rdx), %rcx
movq %rcx, %rsi
decq %rsi
movq %rsi, 0x10(%rdx)
leaq -0x8(%rax,%rcx,8), %rsi
callq 0xd070
callq 0x12300
movq %rax, -0x30(%rbp)
jmp 0x11d0d
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rcx
movq (%rcx), %rax
movq 0x10(%rcx), %rcx
leaq (%rax,%rcx,8), %rdi
callq 0x12310
jmp 0x11d27
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x11d53
jmp 0x11d4a
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xcd90
jmp 0x11d5d
movq -0x48(%rbp), %rdi
callq 0xcd90
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
// File: Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Code::getCurrentLabel(unsigned long)
string getCurrentLabel(size_t line)
	{
		string s;
		size_t c = 0;
		for (table::iterator it = label.begin(); it != label.end(); ++it)
		{
			size_t i = static_cast<size_t>(it->second.get()->toInt());
			if (i <= line && i >= c)
			{
				s = it->first;
				c = i;
			}
		}
		return s;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x11f50
movq -0x78(%rbp), %rdi
movq $0x0, -0x28(%rbp)
addq $0x18, %rdi
callq 0x11f70
movl %edx, -0x6c(%rbp)
movq %rax, -0x68(%rbp)
jmp 0x11e04
movl -0x6c(%rbp), %eax
movq -0x68(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movl %eax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x78(%rbp), %rdi
addq $0x18, %rdi
callq 0x12030
movl %eax, -0x8c(%rbp)
jmp 0x11e35
movl -0x8c(%rbp), %esi
leaq -0x38(%rbp), %rdi
callq 0x12010
movb %al, -0x8d(%rbp)
jmp 0x11e4c
movb -0x8d(%rbp), %al
testb $0x1, %al
jne 0x11e5b
jmp 0x11f17
leaq -0x38(%rbp), %rdi
callq 0x12040
movq %rax, -0x98(%rbp)
jmp 0x11e6d
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x12060
movq %rax, -0xa0(%rbp)
jmp 0x11e86
movq -0xa0(%rbp), %rdi
callq 0x12080
movl %eax, -0xa4(%rbp)
jmp 0x11e9a
movl -0xa4(%rbp), %eax
cltq
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x11f05
movq -0x60(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x11f05
leaq -0x38(%rbp), %rdi
callq 0x12040
movq %rax, -0xb0(%rbp)
jmp 0x11ecc
movq -0xb0(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x120b0
jmp 0x11ee1
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x11f05
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xc950
jmp 0x11f3a
jmp 0x11f07
leaq -0x38(%rbp), %rdi
callq 0x12120
jmp 0x11f12
jmp 0x11e20
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x11f2d
movq -0x88(%rbp), %rdi
callq 0xc950
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::begin()
iterator begin()	{
		if (!len)
			return iterator(this, -1);
		else
		{
			for (size_t i = 0; i < reserve; ++i)
				if (d[i])
					return iterator(this, static_cast<int>(i));
		}
		return iterator(this, -1);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
jne 0x11f9e
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x12180
jmp 0x12000
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x11fec
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x11fdc
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq -0x10(%rbp), %rdi
callq 0x12180
jmp 0x12000
jmp 0x11fde
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x11fa6
jmp 0x11fee
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x12180
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator=(PSL::variable::string const&)
string &operator=(const string &s)
	{
		SharedBuffer *b = s.buf ? s.buf->inc() : NULL;
		if (buf)	buf->finalize();
		buf = b;
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x120e4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x121b0
movq %rax, -0x28(%rbp)
jmp 0x120ec
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x120ec
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0x1210a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x121d0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::iterator::operator++()
void operator++()
		{
			int max = static_cast<int>(ta->reserve * 2);
			while (++n < max)
				if (ta->d[n])
					return;
			n = -1;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq 0x8(%rax), %rax
shlq %rax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x8(%rcx)
cmpl -0xc(%rbp), %eax
jge 0x12169
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x12167
jmp 0x12174
jmp 0x1213d
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jbe 0x1271f
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
cmpq -0x10(%rbp), %rax
jbe 0x1252b
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x40(%rbp)
jmp 0x12533
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x60(%rbp)
callq 0xc040
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x48(%rbp)
cmpq $0x0, %rax
je 0x125cf
movq -0x48(%rbp), %rax
movq -0x58(%rbp), %rdx
shlq $0x3, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xdf50
jmp 0x125ba
movq -0x70(%rbp), %rcx
movq -0x78(%rbp), %rax
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, -0x68(%rbp)
jne 0x125ab
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x1267a
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x12310
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x125df
movq -0x48(%rbp), %rcx
movq %rax, %rsi
movq -0x78(%rbp), %rax
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
cmpq %rax, %rcx
movq %rax, -0x80(%rbp)
je 0x12668
movq -0x80(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0x88(%rbp)
callq 0xcd90
movq -0x48(%rbp), %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x80(%rbp)
jne 0x12640
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0xc2c0
jmp 0x12728
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x12714
movq -0x90(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0xa8(%rbp)
movq -0x8(%rcx), %rdx
movq %rdx, -0xa0(%rbp)
shlq $0x3, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x98(%rbp)
je 0x126f9
movq -0x98(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0xb0(%rbp)
callq 0xcd90
movq -0x90(%rbp), %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x98(%rbp)
jne 0x126c8
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
shlq $0x3, %rsi
addq $0x8, %rsi
callq 0xc2c0
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0xb0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x152a9
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15238
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x121b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x152a7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq %rax, %rsi
callq 0x152e0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13b70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x15350
jmp 0x152a9
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
callq 0x153a0
testb $0x1, %al
jne 0x15316
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x153c0
cmpq -0x10(%rbp), %rax
jae 0x15344
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0xb, %rsi
callq 0x153e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x121d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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);
			if (c < i)
				c = 0;
			else
				c -= i;
			buf->setlen(c);
		}
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x1551e
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x152e0
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x154ff
movq $0x0, -0x18(%rbp)
jmp 0x1550e
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13b90
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x155be
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
imulq -0x10(%rbp), %rsi
callq 0x152e0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x155bc
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x13b70
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
imulq -0x20(%rbp), %rcx
callq 0x15350
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x15578
jmp 0x155be
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 (c > i)
			{
				only_and_extend(c);
				buf->setlen(i);
			}
		}
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x15627
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x15625
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x152e0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x13b90
jmp 0x15627
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)