LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::padC(unsigned int, char)
GStr& GStr::padC(uint len, char c) {
 if (my_data->length>=len) return *this; //no room for padding
 make_unique(); //edit operation ahead
 uint istart=(len-length())/2;
 Data *data = new_data(len);
 if (istart>0)
      ::memset(data->chars, c, istart);
 ::memcpy(&data->chars[istart], my_data->chars, length());
 uint iend=istart+length();
 if (iend<len)
      ::memset(&data->chars[iend],c,len-iend);
 replace_data(data);
 return *this;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jb 0x8705
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x87e7
movq -0x38(%rbp), %rdi
callq 0x63e0
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x3c(%rbp), %eax
subl %ecx, %eax
shrl %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %edi
xorl %esi, %esi
callq 0x6100
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0x8756
movq -0x28(%rbp), %rdi
addq $0xc, %rdi
movsbl -0x15(%rbp), %eax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
movzbl %al, %esi
callq 0x21a0
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
addq $0xc, %rax
movl -0x1c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq 0x20(%rdi), %rax
addq $0xc, %rax
movq %rax, -0x48(%rbp)
callq 0xb660
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movslq %eax, %rdx
callq 0x21f0
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x40(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x87d2
movq -0x28(%rbp), %rdi
addq $0xc, %rdi
movl -0x2c(%rbp), %eax
addq %rax, %rdi
movsbl -0x15(%rbp), %eax
movl -0x14(%rbp), %ecx
subl -0x2c(%rbp), %ecx
movl %ecx, %ecx
movl %ecx, %edx
movzbl %al, %esi
callq 0x21a0
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6460
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: operator+(char const*, GStr const&)
GStr operator+(const char *s1, const GStr& s2) {
    const int s1_length = ::strlen(s1);

    if (s1_length == 0)
        return s2;
    else {
        GStr newstring;
        newstring.prep_data(s1_length + s2.length());
        ::memcpy(newstring.chrs(), s1, s1_length);
        ::memcpy(&(newstring.chrs())[s1_length], s2.chars(), s2.length());
        return newstring;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2140
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x8843
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6710
jmp 0x8915
movq -0x40(%rbp), %rdi
movb $0x0, -0x1d(%rbp)
callq 0x6660
movl -0x1c(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb660
movl %eax, -0x44(%rbp)
jmp 0x8864
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %eax
movl -0x48(%rbp), %esi
addl %eax, %esi
xorl %edx, %edx
callq 0x6260
jmp 0x8879
movq -0x40(%rbp), %rdi
callq 0xb630
movq %rax, -0x50(%rbp)
jmp 0x8888
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x21f0
movq -0x40(%rbp), %rdi
callq 0xb630
movq %rax, -0x58(%rbp)
jmp 0x88a8
movq -0x58(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb610
movq %rax, -0x60(%rbp)
jmp 0x88c6
movq -0x18(%rbp), %rdi
callq 0xb660
movl %eax, -0x6c(%rbp)
jmp 0x88d4
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
movl -0x6c(%rbp), %eax
movslq %eax, %rdx
callq 0x21f0
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x8913
jmp 0x890a
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6990
jmp 0x891f
movq -0x40(%rbp), %rdi
callq 0x6990
jmp 0x8915
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2400
nopl (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::operator+(GStr const&) const
GStr GStr::operator+(const GStr& s) const {
    if (length() == 0)
        return s;
    else if (s.length() == 0)
        return *this;
    else {
        GStr newstring;
        newstring.prep_data(length() + s.length());
        ::memcpy(newstring.chrs(), my_data->chars, length());
        ::memcpy(&(newstring.chrs())[length()], s.chars(), s.length());
        return newstring;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %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 0xb660
cmpl $0x0, %eax
jne 0x8976
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6710
jmp 0x8aa8
movq -0x18(%rbp), %rdi
callq 0xb660
cmpl $0x0, %eax
jne 0x8996
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x6710
jmp 0x8aa8
movq -0x48(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x6660
movq -0x38(%rbp), %rdi
callq 0xb660
movl %eax, -0x4c(%rbp)
jmp 0x89b1
movq -0x18(%rbp), %rdi
callq 0xb660
movl %eax, -0x50(%rbp)
jmp 0x89bf
movq -0x48(%rbp), %rdi
movl -0x50(%rbp), %eax
movl -0x4c(%rbp), %esi
addl %eax, %esi
xorl %edx, %edx
callq 0x6260
jmp 0x89d4
movq -0x48(%rbp), %rdi
callq 0xb630
movq %rax, -0x58(%rbp)
jmp 0x89e3
movq -0x38(%rbp), %rdi
movq 0x20(%rdi), %rax
addq $0xc, %rax
movq %rax, -0x68(%rbp)
callq 0xb660
movl %eax, -0x5c(%rbp)
jmp 0x89fd
movq -0x68(%rbp), %rsi
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %eax
movslq %eax, %rdx
callq 0x21f0
movq -0x48(%rbp), %rdi
callq 0xb630
movq %rax, -0x70(%rbp)
jmp 0x8a1f
movq -0x38(%rbp), %rdi
callq 0xb660
movl %eax, -0x74(%rbp)
jmp 0x8a2d
movq -0x70(%rbp), %rax
movl -0x74(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb610
movq %rax, -0x80(%rbp)
jmp 0x8a50
movq -0x18(%rbp), %rdi
callq 0xb660
movl %eax, -0x8c(%rbp)
jmp 0x8a61
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
movl -0x8c(%rbp), %eax
movslq %eax, %rdx
callq 0x21f0
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x8aa6
jmp 0x8a9d
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6990
jmp 0x8ab5
movq -0x48(%rbp), %rdi
callq 0x6990
jmp 0x8aa8
movq -0x40(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2400
nop
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::operator+(char const*) const
GStr GStr::operator+(const char *s) const {

    const int s_length = ::strlen(s);

    if (s_length == 0)
        return *this;
    else {
        GStr newstring;
        newstring.prep_data(length() + s_length);
        ::memcpy(newstring.chrs(), my_data->chars, length());
        ::memcpy(&(newstring.chrs())[length()], s, s_length);
        return newstring;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %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), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2140
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x8b0e
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x6710
jmp 0x8bde
movq -0x48(%rbp), %rdi
movb $0x0, -0x1d(%rbp)
callq 0x6660
movq -0x38(%rbp), %rdi
callq 0xb660
movl %eax, -0x4c(%rbp)
jmp 0x8b29
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %esi
movl -0x1c(%rbp), %eax
addl %eax, %esi
xorl %edx, %edx
callq 0x6260
jmp 0x8b3e
movq -0x48(%rbp), %rdi
callq 0xb630
movq %rax, -0x58(%rbp)
jmp 0x8b4d
movq -0x38(%rbp), %rdi
movq 0x20(%rdi), %rax
addq $0xc, %rax
movq %rax, -0x68(%rbp)
callq 0xb660
movl %eax, -0x5c(%rbp)
jmp 0x8b67
movq -0x68(%rbp), %rsi
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %eax
movslq %eax, %rdx
callq 0x21f0
movq -0x48(%rbp), %rdi
callq 0xb630
movq %rax, -0x70(%rbp)
jmp 0x8b89
movq -0x38(%rbp), %rdi
callq 0xb660
movl %eax, -0x74(%rbp)
jmp 0x8b97
movq -0x70(%rbp), %rdi
movl -0x74(%rbp), %eax
cltq
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x21f0
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x8bdc
jmp 0x8bd3
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6990
jmp 0x8beb
movq -0x48(%rbp), %rdi
callq 0x6990
jmp 0x8bde
movq -0x40(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2400
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::operator+(int) const
GStr GStr::operator+(const int i) const {
    char buf[20];
    sprintf(buf, "%d", i);
    const int s_length = ::strlen(buf);
    GStr newstring;
    newstring.prep_data(length() + s_length);
    ::memcpy(newstring.chrs(), my_data->chars, length());
    ::memcpy(&(newstring.chrs())[length()], buf, s_length);
    return newstring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %edx
leaq 0xb561(%rip), %rsi      # 0x14194
xorl %eax, %eax
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2080
movq -0x60(%rbp), %rdi
callq 0x2140
movq -0x58(%rbp), %rdi
movl %eax, -0x34(%rbp)
movb $0x0, -0x35(%rbp)
callq 0x6660
movq -0x50(%rbp), %rdi
callq 0xb660
movl %eax, -0x48(%rbp)
jmp 0x8c69
movq -0x58(%rbp), %rdi
movl -0x48(%rbp), %esi
movl -0x34(%rbp), %eax
addl %eax, %esi
xorl %edx, %edx
callq 0x6260
jmp 0x8c7e
movq -0x58(%rbp), %rdi
callq 0xb630
movq %rax, -0x70(%rbp)
jmp 0x8c8d
movq -0x50(%rbp), %rdi
movq 0x20(%rdi), %rax
addq $0xc, %rax
movq %rax, -0x80(%rbp)
callq 0xb660
movl %eax, -0x74(%rbp)
jmp 0x8ca7
movq -0x80(%rbp), %rsi
movq -0x70(%rbp), %rdi
movl -0x74(%rbp), %eax
movslq %eax, %rdx
callq 0x21f0
movq -0x58(%rbp), %rdi
callq 0xb630
movq %rax, -0x88(%rbp)
jmp 0x8ccc
movq -0x50(%rbp), %rdi
callq 0xb660
movl %eax, -0x8c(%rbp)
jmp 0x8cdd
movq -0x88(%rbp), %rdi
movl -0x8c(%rbp), %eax
cltq
addq %rax, %rdi
leaq -0x30(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x21f0
movb $0x1, -0x35(%rbp)
testb $0x1, -0x35(%rbp)
jne 0x8d28
jmp 0x8d1f
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x6990
jmp 0x8d35
movq -0x58(%rbp), %rdi
callq 0x6990
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2400
nop
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::operator+(char) const
GStr GStr::operator+(const char c) const {
    char buf[4];
    sprintf(buf, "%c", c);
    const int s_length = ::strlen(buf);
    GStr newstring;
    newstring.prep_data(length() + s_length);
    ::memcpy(newstring.chrs(), my_data->chars, length());
    ::memcpy(&(newstring.chrs())[length()], buf, s_length);
    return newstring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x40(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movsbl -0x11(%rbp), %edx
leaq 0xb51e(%rip), %rsi      # 0x14294
xorl %eax, %eax
leaq -0x15(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2080
movq -0x48(%rbp), %rdi
callq 0x2140
movq -0x40(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
callq 0x6660
movq -0x38(%rbp), %rdi
callq 0xb660
movl %eax, -0x30(%rbp)
jmp 0x8dac
movq -0x40(%rbp), %rdi
movl -0x30(%rbp), %esi
movl -0x1c(%rbp), %eax
addl %eax, %esi
xorl %edx, %edx
callq 0x6260
jmp 0x8dc1
movq -0x40(%rbp), %rdi
callq 0xb630
movq %rax, -0x58(%rbp)
jmp 0x8dd0
movq -0x38(%rbp), %rdi
movq 0x20(%rdi), %rax
addq $0xc, %rax
movq %rax, -0x68(%rbp)
callq 0xb660
movl %eax, -0x5c(%rbp)
jmp 0x8dea
movq -0x68(%rbp), %rsi
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %eax
movslq %eax, %rdx
callq 0x21f0
movq -0x40(%rbp), %rdi
callq 0xb630
movq %rax, -0x70(%rbp)
jmp 0x8e0c
movq -0x38(%rbp), %rdi
callq 0xb660
movl %eax, -0x74(%rbp)
jmp 0x8e1a
movq -0x70(%rbp), %rdi
movl -0x74(%rbp), %eax
cltq
addq %rax, %rdi
leaq -0x15(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x21f0
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x8e5f
jmp 0x8e56
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6990
jmp 0x8e6c
movq -0x40(%rbp), %rdi
callq 0x6990
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2400
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::operator+(double) const
GStr GStr::operator+(const double f) const {
    char buf[30];
    sprintf(buf, "%f", f);
    const int s_length = ::strlen(buf);
    GStr newstring;
    newstring.prep_data(length() + s_length);
    ::memcpy(newstring.chrs(), my_data->chars, length());
    ::memcpy(&(newstring.chrs())[length()], buf, s_length);
    return newstring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd -0x18(%rbp), %xmm0
leaq 0xb2e0(%rip), %rsi      # 0x14197
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movb $0x1, %al
callq 0x2080
movq -0x70(%rbp), %rdi
callq 0x2140
movq -0x68(%rbp), %rdi
movl %eax, -0x44(%rbp)
movb $0x0, -0x45(%rbp)
callq 0x6660
movq -0x60(%rbp), %rdi
callq 0xb660
movl %eax, -0x58(%rbp)
jmp 0x8eed
movq -0x68(%rbp), %rdi
movl -0x58(%rbp), %esi
movl -0x44(%rbp), %eax
addl %eax, %esi
xorl %edx, %edx
callq 0x6260
jmp 0x8f02
movq -0x68(%rbp), %rdi
callq 0xb630
movq %rax, -0x80(%rbp)
jmp 0x8f11
movq -0x60(%rbp), %rdi
movq 0x20(%rdi), %rax
addq $0xc, %rax
movq %rax, -0x90(%rbp)
callq 0xb660
movl %eax, -0x84(%rbp)
jmp 0x8f31
movq -0x90(%rbp), %rsi
movq -0x80(%rbp), %rdi
movl -0x84(%rbp), %eax
movslq %eax, %rdx
callq 0x21f0
movq -0x68(%rbp), %rdi
callq 0xb630
movq %rax, -0x98(%rbp)
jmp 0x8f5c
movq -0x60(%rbp), %rdi
callq 0xb660
movl %eax, -0x9c(%rbp)
jmp 0x8f6d
movq -0x98(%rbp), %rdi
movl -0x9c(%rbp), %eax
cltq
addq %rax, %rdi
leaq -0x40(%rbp), %rsi
movslq -0x44(%rbp), %rdx
callq 0x21f0
movb $0x1, -0x45(%rbp)
testb $0x1, -0x45(%rbp)
jne 0x8fb8
jmp 0x8faf
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x6990
jmp 0x8fc5
movq -0x68(%rbp), %rdi
callq 0x6990
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2400
nop
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::is_space() const
bool GStr::is_space() const {

    if (my_data == &null_data)
        return false;

    for (const char *p = my_data->chars; *p; p++)
        if (!isspace(*p))
            return false;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x1126d(%rip), %rcx     # 0x1a258
cmpq %rcx, 0x20(%rax)
jne 0x8ff7
movb $0x0, -0x1(%rbp)
jmp 0x903b
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
addq $0xc, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x9037
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x2050
cmpl $0x0, %eax
jne 0x9027
movb $0x0, -0x1(%rbp)
jmp 0x903b
jmp 0x9029
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9007
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::substr(int, int) const
GStr GStr::substr(int idx, int len) const {
    // A negative idx specifies an idx from the right of the string.
    if (idx < 0)
        idx += length();
    else if (idx>=length()) {
             len=0;
             idx=length();
             }
    if (len) {
      // A length of -1 specifies the rest of the string.
      if (len < 0  || len>length()-idx)
        len = length() - idx;
      if (idx<0 || idx>=length() || len<0 )
        invalid_args_error("substr()");
    }

    GStr newstring;
    if (len) {
      newstring.prep_data(len);
      ::memcpy(newstring.chrs(), &my_data->chars[idx], len);
    }
    return newstring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x9090
movq -0x38(%rbp), %rdi
callq 0xb660
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x90bd
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jl 0x90bb
movq -0x38(%rbp), %rdi
movl $0x0, -0x18(%rbp)
callq 0xb660
movl %eax, -0x14(%rbp)
jmp 0x90bd
cmpl $0x0, -0x18(%rbp)
je 0x9125
cmpl $0x0, -0x18(%rbp)
jl 0x90e4
movq -0x38(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x50(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x50(%rbp), %eax
subl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jle 0x90f3
movq -0x38(%rbp), %rdi
callq 0xb660
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x9117
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x9117
cmpl $0x0, -0x18(%rbp)
jge 0x9123
leaq 0xb08e(%rip), %rdi      # 0x141ac
callq 0x91c0
jmp 0x9125
movq -0x48(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x6660
cmpl $0x0, -0x18(%rbp)
je 0x9190
movq -0x48(%rbp), %rdi
movl -0x18(%rbp), %esi
xorl %edx, %edx
callq 0x6260
jmp 0x9148
movq -0x48(%rbp), %rdi
callq 0xb630
movq %rax, -0x60(%rbp)
jmp 0x9157
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
movslq -0x18(%rbp), %rdx
callq 0x21f0
jmp 0x9190
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6990
jmp 0x91ad
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x91a3
movq -0x48(%rbp), %rdi
callq 0x6990
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2400
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::reverse()
GStr& GStr::reverse() {
  make_unique();
  int l=0;
  int r=my_data->length-1;
  char c;
  while (l<r) {
     c=my_data->chars[l];
     my_data->chars[l]=my_data->chars[r];
     my_data->chars[r]=c;
     l++;r--;
     }
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x63e0
movq -0x20(%rbp), %rax
movl $0x0, -0xc(%rbp)
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x9279
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0xc(%rbp), %rdx
movb 0xc(%rcx,%rdx), %cl
movb %cl, -0x11(%rbp)
movq 0x20(%rax), %rcx
movslq -0x10(%rbp), %rdx
movb 0xc(%rcx,%rdx), %sil
movq 0x20(%rax), %rcx
movslq -0xc(%rbp), %rdx
movb %sil, 0xc(%rcx,%rdx)
movb -0x11(%rbp), %dl
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
movb %dl, 0xc(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9221
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::cut(int, int)
GStr&  GStr::cut(int idx, int len) {

    if (len == 0)
        return *this;
    make_unique(); //edit operation ahead

    // A negative idx specifies an idx from the right of the string,
    // so the left part will be cut out
    if (idx < 0)
        idx += length();

    // A length of -1 specifies the rest of the string.
    if (len == -1)
        len = length() - idx;

    if (idx<0 || idx>=length() || len<0 || len>length()-idx)
        invalid_args_error("cut()");

    Data *data = new_data(length() - len);
    if (idx > 0)
        ::memcpy(data->chars, my_data->chars, idx);
    ::strcpy(&data->chars[idx], &my_data->chars[idx+len]);
    replace_data(data);

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x977d
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9877
movq -0x28(%rbp), %rdi
callq 0x63e0
cmpl $0x0, -0x14(%rbp)
jge 0x979b
movq -0x28(%rbp), %rdi
callq 0xb660
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x97b0
movq -0x28(%rbp), %rdi
callq 0xb660
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x97ef
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x97ef
cmpl $0x0, -0x18(%rbp)
jl 0x97ef
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x30(%rbp), %eax
subl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jle 0x97fb
leaq 0xa9bf(%rip), %rdi      # 0x141b5
callq 0x91c0
movq -0x28(%rbp), %rdi
callq 0xb660
movl %eax, %edi
subl -0x18(%rbp), %edi
xorl %esi, %esi
callq 0x6100
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x9837
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movslq -0x14(%rbp), %rdx
callq 0x21f0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
movslq -0x14(%rbp), %rcx
addq %rcx, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
cltq
addq %rax, %rsi
callq 0x2240
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6460
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::paste(char const*, int, int)
GStr& GStr::paste(const char *s, int idx, int len) {

    // A negative idx specifies an idx from the right of the string.
    make_unique(); //edit operation ahead
    if (idx < 0)
        idx += length();

    // A length of -1 specifies the rest of the string.
    if (len == -1)
        len = length() - idx;

    if (idx<0 || idx>=length() || len<0 || len>length()-idx)
        invalid_args_error("replace()");

    const int s_length = ::strlen(s);

    if (len == s_length && my_data->ref_count == 1)
        ::memcpy(&chrs()[idx], s, len);
    else {
        Data *data = new_data(length() - len + s_length);
        if (idx > 0)
            ::memcpy(data->chars, my_data->chars, idx);
        if (s_length > 0)
            ::memcpy(&data->chars[idx], s, s_length);
        ::strcpy(&data->chars[idx+s_length], &my_data->chars[idx+len]);
        replace_data(data);
    }

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x63e0
cmpl $0x0, -0x14(%rbp)
jge 0x9ab8
movq -0x30(%rbp), %rdi
callq 0xb660
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x9acd
movq -0x30(%rbp), %rdi
callq 0xb660
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x9b0c
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x9b0c
cmpl $0x0, -0x18(%rbp)
jl 0x9b0c
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x38(%rbp), %eax
subl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jle 0x9b18
leaq 0xa6a8(%rip), %rdi      # 0x141bb
callq 0x91c0
movq -0x10(%rbp), %rdi
callq 0x2140
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x9b5e
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x1, (%rax)
jne 0x9b5e
movq -0x30(%rbp), %rdi
callq 0xb630
movq %rax, %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x21f0
jmp 0x9bfc
movq -0x30(%rbp), %rdi
callq 0xb660
movl %eax, %edi
subl -0x18(%rbp), %edi
addl -0x1c(%rbp), %edi
xorl %esi, %esi
callq 0x6100
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x9b9d
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
addq $0xc, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movslq -0x14(%rbp), %rdx
callq 0x21f0
cmpl $0x0, -0x1c(%rbp)
jle 0x9bbf
movq -0x28(%rbp), %rdi
addq $0xc, %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x21f0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
addq $0xc, %rdi
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
cltq
addq %rax, %rsi
callq 0x2240
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6460
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::insert(GStr const&, int)
GStr& GStr::insert(const GStr& s, int idx) {
    make_unique(); //edit operation ahead

    // A negative idx specifies an idx from the right of the string.
    if (idx < 0)
        idx += length();

    if (idx < 0 || idx >= length())
        invalid_index_error("insert()");

    if (s.length() > 0) {
        Data *data = new_data(length() + s.length());
        if (idx > 0)
            ::memcpy(data->chars, my_data->chars, idx);
        ::memcpy(&data->chars[idx], s.chars(), s.length());
        ::strcpy(&data->chars[idx+s.length()], &my_data->chars[idx]);
        replace_data(data);
    }

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x63e0
cmpl $0x0, -0x14(%rbp)
jge 0x9c45
movq -0x28(%rbp), %rdi
callq 0xb660
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x9c63
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jl 0x9c6f
leaq 0xa55b(%rip), %rdi      # 0x141c5
callq 0x6a80
movq -0x10(%rbp), %rdi
callq 0xb660
cmpl $0x0, %eax
jle 0x9d53
movq -0x28(%rbp), %rdi
callq 0xb660
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb660
movl -0x30(%rbp), %edi
addl %eax, %edi
xorl %esi, %esi
callq 0x6100
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x9cc9
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movslq -0x14(%rbp), %rdx
callq 0x21f0
movq -0x20(%rbp), %rax
addq $0xc, %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb610
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb660
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movslq %eax, %rdx
callq 0x21f0
movq -0x20(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb660
movl -0x3c(%rbp), %ecx
movq -0x38(%rbp), %rdi
movl %eax, %edx
movq -0x28(%rbp), %rax
addl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
callq 0x2240
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6460
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::insert(char const*, int)
GStr& GStr::insert(const char *s, int idx) {
    // A negative idx specifies an idx from the right of the string.
    make_unique(); //edit operation ahead
    if (idx < 0)
        idx += length();

    if (idx < 0 || idx >= length())
        invalid_index_error("insert()");

    const int s_length = ::strlen(s);

    if (s_length > 0) {
        Data *data = new_data(length() + s_length);
        if (idx > 0)
            ::memcpy(data->chars, my_data->chars, idx);
        ::memcpy(&data->chars[idx], s, s_length);
        ::strcpy(&data->chars[idx+s_length], &my_data->chars[idx]);
        replace_data(data);
    }

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x63e0
cmpl $0x0, -0x14(%rbp)
jge 0x9d95
movq -0x28(%rbp), %rdi
callq 0xb660
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x9db3
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jl 0x9dbf
leaq 0xa40b(%rip), %rdi      # 0x141c5
callq 0x6a80
movq -0x10(%rbp), %rdi
callq 0x2140
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x9e66
movq -0x28(%rbp), %rdi
callq 0xb660
movl %eax, %edi
addl -0x18(%rbp), %edi
xorl %esi, %esi
callq 0x6100
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x9e11
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movslq -0x14(%rbp), %rdx
callq 0x21f0
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x21f0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
callq 0x2240
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6460
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::append(char)
GStr& GStr::append(char c) {
  make_unique(); //edit operation ahead
  uint newlen=my_data->length+1;
  if (my_data->cap==0) {
    prep_data(1, 6);
    my_data->chars[0]=c;
    return *this;
  }
  if (newlen>my_data->cap) {
	  //not enough room to append this char
	  GREALLOC(my_data, sizeof(Data)+newlen);
	  my_data->cap=newlen;
  }
  my_data->chars[my_data->length]=c;
  my_data->length++;
  my_data->chars[my_data->length]='\0';
  return *this;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x63e0
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movl 0x8(%rcx), %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movq 0x20(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x9ed1
movq -0x20(%rbp), %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x6260
movq -0x20(%rbp), %rax
movb -0x11(%rbp), %dl
movq 0x20(%rax), %rcx
movb %dl, 0xc(%rcx)
movq %rax, -0x8(%rbp)
jmp 0x9f50
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
movq 0x20(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jbe 0x9f17
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
addq $0x10, %rsi
callq 0x5f10
testb $0x1, %al
jne 0x9f09
leaq 0xa121(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movq 0x20(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movb -0x11(%rbp), %sil
movq 0x20(%rax), %rcx
movq 0x20(%rax), %rdx
movl 0x8(%rdx), %edx
movb %sil, 0xc(%rcx,%rdx)
movq 0x20(%rax), %rcx
movl 0x8(%rcx), %edx
addl $0x1, %edx
movl %edx, 0x8(%rcx)
movq 0x20(%rax), %rcx
movq 0x20(%rax), %rdx
movl 0x8(%rdx), %edx
movb $0x0, 0xc(%rcx,%rdx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::appendQuoted(char const*, char, bool)
GStr& GStr::appendQuoted(const char* s, char q, bool onlyIfSpaced) {
	if (onlyIfSpaced) {
		if (strpbrk(s, "\t ")==NULL)
			return this->append(s);
	}
	char qend=q;
	if (q=='[' || q=='{' || q=='<')
		qend=q+2;
	else if (q=='(')
		qend=')';
	this->append(q);
	this->append(s);
	this->append(qend);
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x1a(%rbp)
je 0x9fb5
movq -0x18(%rbp), %rdi
leaq 0xa239(%rip), %rsi      # 0x141ce
callq 0x23f0
cmpq $0x0, %rax
jne 0x9fb3
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7390
movq %rax, -0x8(%rbp)
jmp 0xa020
jmp 0x9fb5
movb -0x19(%rbp), %al
movb %al, -0x1b(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x5b, %eax
je 0x9fd6
movsbl -0x19(%rbp), %eax
cmpl $0x7b, %eax
je 0x9fd6
movsbl -0x19(%rbp), %eax
cmpl $0x3c, %eax
jne 0x9fe2
movsbl -0x19(%rbp), %eax
addl $0x2, %eax
movb %al, -0x1b(%rbp)
jmp 0x9ff1
movsbl -0x19(%rbp), %eax
cmpl $0x28, %eax
jne 0x9fef
movb $0x29, -0x1b(%rbp)
jmp 0x9ff1
movq -0x28(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x9e70
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7390
movq -0x28(%rbp), %rdi
movsbl -0x1b(%rbp), %esi
callq 0x9e70
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::append(char const*, int)
GStr& GStr::append(const char* s, int len) {
  make_unique(); //edit operation ahead
  //uint len=::strlen(s);
  uint newlen=len+my_data->length;
  if (newlen<=my_data->length) return *this;
  if (my_data->length==0 && my_data->cap<newlen) {
    prep_data(len,4);
    ::strncpy(my_data->chars, s, len);
    return *this;
   }
  if (newlen>=my_data->cap) {
	  //not enough room to append these chars
	  GREALLOC(my_data, sizeof(Data)+newlen+1);
	  my_data->cap=newlen+1;
  }
  //strncpy(my_data->chars+my_data->length, s, len);
  newlen=my_data->length;
  for (int i=0;s[i]!='\0' && i<len;++i) {
	my_data->chars[my_data->length+i]=s[i];
	++newlen;
  }
  my_data->length=newlen;
  my_data->chars[newlen]='\0';
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x63e0
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
movq 0x20(%rcx), %rdx
addl 0x8(%rdx), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq 0x20(%rcx), %rcx
cmpl 0x8(%rcx), %eax
ja 0xa07a
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa1b1
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0xa0cf
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x20(%rbp), %eax
jae 0xa0cf
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x4, %edx
callq 0x6260
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0xc, %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2190
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa1b1
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
movq 0x20(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jb 0xa11c
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
addq $0x10, %rsi
addq $0x1, %rsi
callq 0x5f10
testb $0x1, %al
jne 0xa10b
leaq 0x9f1f(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movq 0x20(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0xa153
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xa15c
jmp 0xa193
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rdx
movb (%rax,%rdx), %dl
movq 0x20(%rcx), %rax
movq 0x20(%rcx), %rcx
movl 0x8(%rcx), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, %ecx
movb %dl, 0xc(%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa131
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %edx
movq 0x20(%rax), %rcx
movl %edx, 0x8(%rcx)
movq 0x20(%rax), %rcx
movl -0x20(%rbp), %edx
movb $0x0, 0xc(%rcx,%rdx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::appendmem(char const*, int)
GStr& GStr::appendmem(const char* m, int len) {
  if (len<=0) return *this;
  make_unique(); //edit operation ahead
  uint newlen=len+my_data->length;
  //if (newlength<=my_data->length) return *this;
  if (my_data->length==0) {
    prep_data(len);
    ::memcpy(my_data->chars, m, len);
    return *this;
   }
  //faster solution with realloc
  if (newlen>=my_data->cap) {
	  //not enough room to append these chars
	  GREALLOC(my_data, sizeof(Data)+newlen+1);
	  my_data->cap=newlen+1;
  }
  ::memcpy(my_data->chars + my_data->length, m, len);
  my_data->length=newlen;
  my_data->chars[newlen]='\0';
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0xa1ee
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa2d4
movq -0x28(%rbp), %rdi
callq 0x63e0
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0x20(%rax), %rdx
addl 0x8(%rdx), %ecx
movl %ecx, -0x20(%rbp)
movq 0x20(%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0xa246
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
callq 0x6260
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0xc, %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x21f0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa2d4
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
movq 0x20(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jb 0xa293
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
addq $0x10, %rsi
addq $0x1, %rsi
callq 0x5f10
testb $0x1, %al
jne 0xa282
leaq 0x9da8(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movq 0x20(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0xc, %rdi
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x21f0
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %edx
movq 0x20(%rax), %rcx
movl %edx, 0x8(%rcx)
movq 0x20(%rax), %rcx
movl -0x20(%rbp), %edx
movb $0x0, 0xc(%rcx,%rdx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::upper()
GStr& GStr::upper() {
  make_unique(); //edit operation ahead
  for (char *p = chrs(); *p; p++)
            *p = (char) toupper(*p);

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x63e0
movq -0x18(%rbp), %rdi
callq 0xb630
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa381
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2440
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa356
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::lower()
GStr& GStr::lower() {
    make_unique();

    for (char *p = chrs(); *p; p++)
          *p = (char) tolower(*p);

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x63e0
movq -0x18(%rbp), %rdi
callq 0xb630
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa3e1
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2380
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa3b6
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::rindex(char, int) const
int GStr::rindex(char c, int end_index) const {
    if (c == 0 || length()==0 || end_index>=length()) return -1;
    if (end_index<0) end_index=my_data->length-1;
    for (int i=end_index;i>=0;i--) {
      if (my_data->chars[i]==c) return i;
      }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
je 0xa43c
movq -0x28(%rbp), %rdi
callq 0xb660
cmpl $0x0, %eax
je 0xa43c
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jl 0xa445
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa49d
cmpl $0x0, -0x18(%rbp)
jge 0xa45c
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xa496
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xa489
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa49d
jmp 0xa48b
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa462
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::rindex(char const*, int) const
int GStr::rindex(const char* str, int end_index) const {
    if (str==NULL || *str == '\0' || length()==0 || end_index>=length())
        return -1;
    int slen=strlen(str);
    if (end_index<0) end_index=my_data->length-1;
    //end_index is the index of the right-side boundary
    //the scanning starts at the end
    if (end_index>=0 && end_index<slen-1) return -1;
    for (int i=end_index-slen+1;i>=0;i--) {
       if (memcmp((void*)(my_data->chars+i),(void*)str, slen)==0)
           return i;
       }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa504
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xa504
movq -0x30(%rbp), %rdi
callq 0xb660
cmpl $0x0, %eax
je 0xa504
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jl 0xa510
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa5a2
movq -0x18(%rbp), %rdi
callq 0x2140
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xa533
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xa54f
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xa54f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa5a2
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xa59b
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0xc, %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x2150
cmpl $0x0, %eax
jne 0xa58e
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa5a2
jmp 0xa590
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa55b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::split(char const*)
GStr GStr::split(const char* delim) {
           /* splits "this" in two parts, at the first (left)
                 encounter of delim:
                 1st would stay in "this",
                 2nd part will be returned
                 as a new string!
           */
 GStr result;
 int i=index(delim);
 if (i>=0){
      result=substr(i+strlen(delim));
      cut(i);
      return result;
      }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x6660
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x76a0
movl %eax, -0x60(%rbp)
jmp 0xa5f7
movl -0x60(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0xa68c
movl -0x20(%rbp), %eax
movl %eax, -0x7c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2140
movl -0x7c(%rbp), %edx
movq -0x68(%rbp), %rsi
addl %eax, %edx
leaq -0x58(%rbp), %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x9050
jmp 0xa62f
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6b20
jmp 0xa63e
leaq -0x58(%rbp), %rdi
callq 0x6990
movq -0x68(%rbp), %rdi
movl -0x20(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x9750
jmp 0xa65a
movb $0x1, -0x19(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0xa697
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xa6b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6990
jmp 0xa6b3
movb $0x1, -0x19(%rbp)
movl $0x1, -0x5c(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xa6a6
movq -0x78(%rbp), %rdi
callq 0x6990
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x6990
movq -0x28(%rbp), %rdi
callq 0x2400
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::split(char)
GStr GStr::split(char c) {
           /* splits "this" in two parts, at the first (left)
                 encounter of delim:
                 1st would stay in "this",
                 2nd part will be returned
                 as a new string!
           */
 GStr result;
 int i=index(c);
 if (i>=0){
      result=substr(i+1);
      cut(i);
      return result;
      }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x6660
movq -0x60(%rbp), %rdi
movsbl -0x11(%rbp), %esi
xorl %edx, %edx
callq 0x78f0
movl %eax, -0x58(%rbp)
jmp 0xa715
movl -0x58(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0xa797
movq -0x60(%rbp), %rsi
movl -0x18(%rbp), %edx
incl %edx
leaq -0x50(%rbp), %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x9050
jmp 0xa73a
movq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6b20
jmp 0xa749
leaq -0x50(%rbp), %rdi
callq 0x6990
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x9750
jmp 0xa765
movb $0x1, -0x12(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0xa7a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xa7bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6990
jmp 0xa7bb
movb $0x1, -0x12(%rbp)
movl $0x1, -0x54(%rbp)
testb $0x1, -0x12(%rbp)
jne 0xa7b1
movq -0x70(%rbp), %rdi
callq 0x6990
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x6990
movq -0x20(%rbp), %rdi
callq 0x2400
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::splitr(char const*)
GStr GStr::splitr(const char* delim) {
 GStr result;
 int i=rindex(delim);
 if (i>=0){
      result=substr(i+strlen(delim));
      cut(i);
      return result;
      }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x6660
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xa4b0
movl %eax, -0x60(%rbp)
jmp 0xa81a
movl -0x60(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0xa8af
movl -0x20(%rbp), %eax
movl %eax, -0x7c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2140
movl -0x7c(%rbp), %edx
movq -0x68(%rbp), %rsi
addl %eax, %edx
leaq -0x58(%rbp), %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x9050
jmp 0xa852
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6b20
jmp 0xa861
leaq -0x58(%rbp), %rdi
callq 0x6990
movq -0x68(%rbp), %rdi
movl -0x20(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x9750
jmp 0xa87d
movb $0x1, -0x19(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0xa8ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xa8d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6990
jmp 0xa8d6
movb $0x1, -0x19(%rbp)
movl $0x1, -0x5c(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xa8c9
movq -0x78(%rbp), %rdi
callq 0x6990
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x6990
movq -0x28(%rbp), %rdi
callq 0x2400
nopl (%rax,%rax)