LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::prep_data(unsigned int, unsigned int)
void GStr::prep_data(uint len, uint addcap) {
	uint newcap=len+addcap;
    if (newcap > 0 && my_data->ref_count <= 1 &&
    	   my_data->cap>=newcap && my_data->cap-newcap<(newcap>>1)+2) {
    	//no need to shrink/reallocate the already allocated space
    	my_data->length = len;
    	my_data->chars[len]=0;
        return;
    }
    if (my_data != &null_data && --my_data->ref_count == 0)
        GFREE(my_data);

    if (len + addcap> 0) {
        GMALLOC(my_data, sizeof(Data)+len+addcap);
        my_data->ref_count = 1;
        my_data->length = len;
        my_data->cap=len+addcap;
        my_data->chars[len] = 0;
    }
    else
        my_data = &null_data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jbe 0x62df
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x1, (%rax)
ja 0x62df
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jb 0x62df
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x4(%rax), %eax
subl -0x14(%rbp), %eax
movl -0x14(%rbp), %ecx
shrl %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jae 0x62df
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edx
movq 0x20(%rax), %rcx
movl %edx, 0x8(%rcx)
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
movb $0x0, 0xc(%rax,%rcx)
jmp 0x638c
movq -0x20(%rbp), %rax
leaq 0x13f6e(%rip), %rcx     # 0x1a258
cmpq %rcx, 0x20(%rax)
je 0x6311
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x6311
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x5a90
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
cmpl $0x0, %eax
jbe 0x637d
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
addq $0x10, %rsi
movl -0x10(%rbp), %eax
addq %rax, %rsi
callq 0x58f0
testb $0x1, %al
jne 0x634a
leaq 0xdce0(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movl $0x1, (%rcx)
movl -0xc(%rbp), %edx
movq 0x20(%rax), %rcx
movl %edx, 0x8(%rcx)
movl -0xc(%rbp), %edx
addl -0x10(%rbp), %edx
movq 0x20(%rax), %rcx
movl %edx, 0x4(%rcx)
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
movb $0x0, 0xc(%rax,%rcx)
jmp 0x638c
movq -0x20(%rbp), %rax
leaq 0x13ed0(%rip), %rcx     # 0x1a258
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::make_unique()
void GStr::make_unique() {//make sure it's not a reference to other string
    if (my_data->ref_count > 1) {
        Data *data = new_data(my_data->length, 0);
        ::memcpy(data->chars, my_data->chars, my_data->length);
        my_data->ref_count--;
        my_data = data;
        my_data->ref_count++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x20(%rax), %rax
cmpl $0x1, (%rax)
jbe 0x645a
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %edi
xorl %esi, %esi
callq 0x6100
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x21f0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movl (%rcx), %edx
addl $-0x1, %edx
movl %edx, (%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::replace_data(GStr::Data*)
void GStr::replace_data(Data *data) {
    if (my_data != &null_data && --my_data->ref_count == 0)
        GFREE(my_data);
    if (data != &null_data)
        data->ref_count++;
    my_data = data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x13dd9(%rip), %rcx     # 0x1a258
cmpq %rcx, 0x20(%rax)
je 0x64a6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x64a6
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x5a90
leaq 0x13dab(%rip), %rax     # 0x1a258
cmpq %rax, -0x10(%rbp)
je 0x64be
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::GStr()
GStr::GStr():my_data(&null_data) {
 fTokenDelimiter=NULL;
 fTokenizeMode=tkCharSet;
 fLastTokenStart=0;
 readbuf=NULL;
 readbufsize=0;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x13be5(%rip), %rcx     # 0x1a258
movq %rcx, 0x20(%rax)
movq $0x0, (%rax)
movl $0x1, 0xc(%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
popq %rbp
retq
nop
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::detach()
char* GStr::detach() {
 make_unique();
 char *r=my_data->chars;
 my_data=&null_data;
 fTokenDelimiter=NULL;
 fTokenizeMode=tkCharSet;
 fLastTokenStart=0;
 readbuf=NULL;
 readbufsize=0;
 return r;
}

// 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), %rax
movq 0x20(%rax), %rcx
addq $0xc, %rcx
movq %rcx, -0x10(%rbp)
leaq 0x13b88(%rip), %rcx     # 0x1a258
movq %rcx, 0x20(%rax)
movq $0x0, (%rax)
movl $0x1, 0xc(%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::GStr(GStr const&)
GStr::GStr(const GStr& s): my_data(&null_data){
 fTokenDelimiter=NULL;
 fTokenizeMode=tkCharSet;
 fLastTokenStart=0;
 readbuf=NULL;
 readbufsize=0;
 replace_data(s.my_data);
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x13b2d(%rip), %rax     # 0x1a258
movq %rax, 0x20(%rdi)
movq $0x0, (%rdi)
movl $0x1, 0xc(%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x6460
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::GStr(char const*, unsigned int)
GStr::GStr(const char *s, uint addcap): my_data(&null_data) {
  fTokenDelimiter=NULL;
  fTokenizeMode=tkCharSet;
  fLastTokenStart=0;
  readbuf=NULL;
  readbufsize=0;
  my_data=new_data(s, addcap);
  my_data->ref_count = 1;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x13ac6(%rip), %rcx     # 0x1a258
movq %rcx, 0x20(%rax)
movq $0x0, (%rax)
movl $0x1, 0xc(%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6190
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rax
movl $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::GStr(int, unsigned int)
GStr::GStr(const int i, uint addcap): my_data(&null_data) {
 fTokenDelimiter=NULL;
 fTokenizeMode=tkCharSet;
 fLastTokenStart=0;
 readbuf=NULL;
 readbufsize=0;
 char buf[20];
 sprintf(buf,"%d",i);
 my_data=new_data(buf, addcap);
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x13a47(%rip), %rcx     # 0x1a258
movq %rcx, 0x20(%rax)
movq $0x0, (%rax)
movl $0x1, 0xc(%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq -0x30(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0xd94c(%rip), %rsi      # 0x14194
movb $0x0, %al
callq 0x2080
leaq -0x30(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x6190
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::GStr(double)
GStr::GStr(const double f): my_data(&null_data) {
 fTokenDelimiter=NULL;
 fTokenizeMode=tkCharSet;
 fLastTokenStart=0;
 readbuf=NULL;
 readbufsize=0;
 char buf[20];
 sprintf(buf,"%f",f);
 const int len = ::strlen(buf);
 prep_data(len);
 ::memcpy(chrs(), buf, len);
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x139c8(%rip), %rcx     # 0x1a258
movq %rcx, 0x20(%rax)
movq $0x0, (%rax)
movl $0x1, 0xc(%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq -0x30(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
leaq 0xd8ce(%rip), %rsi      # 0x14197
movb $0x1, %al
callq 0x2080
leaq -0x30(%rbp), %rdi
callq 0x2140
movq -0x40(%rbp), %rdi
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
xorl %edx, %edx
callq 0x6260
movq -0x40(%rbp), %rdi
callq 0xb630
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x21f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::GStr(char, int)
GStr::GStr(const char c, int n): my_data(&null_data) {
  fTokenDelimiter=NULL;
  fTokenizeMode=tkCharSet;
  fLastTokenStart=0;
  readbuf=NULL;
  readbufsize=0;
  prep_data(n);
  ::memset(chrs(), c, n);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
leaq 0x13924(%rip), %rax     # 0x1a258
movq %rax, 0x20(%rdi)
movq $0x0, (%rdi)
movl $0x1, 0xc(%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x6260
movq -0x18(%rbp), %rdi
callq 0xb630
movq %rax, %rdi
movsbl -0x9(%rbp), %eax
movslq -0x10(%rbp), %rdx
movzbl %al, %esi
callq 0x21a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::~GStr()
GStr::~GStr() {
  if (my_data != &null_data && --my_data->ref_count == 0)
             GFREE(my_data);
  GFREE(fTokenDelimiter);
  GFREE(readbuf);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x138ad(%rip), %rcx     # 0x1a258
cmpq %rcx, 0x20(%rax)
je 0x69d6
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x69d6
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x5a90
jmp 0x69d4
jmp 0x69d6
movq -0x10(%rbp), %rdi
callq 0x5a90
jmp 0x69e1
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x5a90
jmp 0x69f0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb650
nop
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::operator[](int)
char& GStr::operator[](int idx){
//returns reference to char (can be l-value)
  if (idx < 0) idx += length();
  if (idx < 0 || idx >= length()) invalid_index_error("operator[]");
  make_unique();  //because the user will probably modify this char!
  return chrs()[idx];
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x6a2c
movq -0x18(%rbp), %rdi
callq 0xb660
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x6a4a
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jl 0x6a56
leaq 0xd749(%rip), %rdi      # 0x1419a
callq 0x6a80
movq -0x18(%rbp), %rdi
callq 0x63e0
movq -0x18(%rbp), %rdi
callq 0xb630
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::operator[](int) const
char GStr::operator[](int idx) const {
//returns char copy (cannot be l-value!)
  if (idx < 0) idx += length();
  if (idx < 0 || idx >= length()) invalid_index_error("operator[]");
  return my_data->chars[idx];
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x6adc
movq -0x18(%rbp), %rdi
callq 0xb660
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x6afa
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jl 0x6b06
leaq 0xd699(%rip), %rdi      # 0x1419a
callq 0x6a80
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movb 0xc(%rax,%rcx), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::operator=(GStr const&)
GStr& GStr::operator=(const GStr& s) {
  if (s.my_data!=my_data) {
    make_unique(); //edit operation ahead
    replace_data(s.my_data);
  }
  return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq 0x20(%rcx), %rax
je 0x6b60
movq -0x18(%rbp), %rdi
callq 0x63e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x6460
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::operator=(char const*)
GStr& GStr::operator=(const char *s) {
  make_unique(); //edit operation ahead
  if (s==NULL) {
    prep_data(0);
    return *this;
  }
  const int len = ::strlen(s); prep_data(len);
  ::memcpy(my_data->chars, s, len);
  return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x63e0
cmpq $0x0, -0x18(%rbp)
jne 0x6bab
movq -0x28(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6260
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6be6
movq -0x18(%rbp), %rdi
callq 0x2140
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
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)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::assign(char const*)
GStr& GStr::assign(const char* s) {
  make_unique(); //edit operation ahead
  if (s==NULL) {
    prep_data(0, my_data->cap);
    return *this;
  }
  const int len = ::strlen(s);
  prep_data(len, my_data->cap-len-2);
  ::memcpy(my_data->chars, s, len);
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x63e0
cmpq $0x0, -0x18(%rbp)
jne 0x6c30
movq -0x28(%rbp), %rdi
movq 0x20(%rdi), %rax
movl 0x4(%rax), %edx
xorl %esi, %esi
callq 0x6260
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6c76
movq -0x18(%rbp), %rdi
callq 0x2140
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
movq 0x20(%rdi), %rax
movl 0x4(%rax), %edx
subl -0x1c(%rbp), %edx
subl $0x2, %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)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::assign(int)
GStr& GStr::assign(const int v) {
  make_unique(); //edit operation ahead
  char buf[20];
  sprintf(buf,"%d",v);
  const int len = ::strlen(buf);
  prep_data(len, my_data->cap-len-2);
  ::memcpy(my_data->chars, buf, len);
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x63e0
leaq -0x20(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0xd4ea(%rip), %rsi      # 0x14194
movb $0x0, %al
callq 0x2080
leaq -0x20(%rbp), %rdi
callq 0x2140
movq -0x30(%rbp), %rdi
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
movq 0x20(%rdi), %rax
movl 0x4(%rax), %edx
subl -0x24(%rbp), %edx
subl $0x2, %edx
callq 0x6260
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0xc, %rdi
leaq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x21f0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::operator=(double)
GStr& GStr::operator=(const double f) {
 make_unique(); //edit operation ahead
 char buf[20];
 sprintf(buf,"%f",f);
 const int len = ::strlen(buf);
 prep_data(len);
 ::memcpy(my_data->chars, buf, len);
 return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x63e0
leaq -0x30(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
leaq 0xd469(%rip), %rsi      # 0x14197
movb $0x1, %al
callq 0x2080
leaq -0x30(%rbp), %rdi
callq 0x2140
movq -0x40(%rbp), %rdi
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
xorl %edx, %edx
callq 0x6260
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0xc, %rdi
leaq -0x30(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x21f0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::operator=(int)
GStr& GStr::operator=(const int i) {
 make_unique(); //edit operation ahead
 char buf[20];
 sprintf(buf,"%d",i);
 const int len = ::strlen(buf);
 prep_data(len);
 ::memcpy(my_data->chars, buf, len);
 return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x63e0
leaq -0x20(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0xd3ea(%rip), %rsi      # 0x14194
movb $0x0, %al
callq 0x2080
leaq -0x20(%rbp), %rdi
callq 0x2140
movq -0x30(%rbp), %rdi
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
xorl %edx, %edx
callq 0x6260
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0xc, %rdi
leaq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x21f0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::append(char const*)
GStr& GStr::append(const char* s) {
  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);
    ::memcpy(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;
  }
  ::memcpy(my_data->chars+my_data->length, s, 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)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x63e0
movq -0x18(%rbp), %rdi
callq 0x2140
movq -0x28(%rbp), %rcx
movl %eax, -0x1c(%rbp)
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 0x73e3
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x74c8
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0x7439
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x20(%rbp), %eax
jae 0x7439
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x4, %edx
callq 0x6260
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0xc, %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x21f0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x74c8
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
movq 0x20(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jb 0x7486
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 0x7475
leaq 0xcbb5(%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
movl -0x1c(%rbp), %eax
movl %eax, %edx
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
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::index(char const*, int) const
int GStr::index(const char *s, int start_index) const {
    // A negative index specifies an index from the right of the string.
    if (strlen(s)>(size_t)length()) return -1;
    if (start_index < 0)
        start_index += length();

    if (start_index < 0 || start_index >= length())
        invalid_index_error("index()");
    const char* idx = strstr(&my_data->chars[start_index], s);
    if (!idx)
        return -1;
    else
        return idx - my_data->chars;
}

// 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, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2140
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0xb660
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jbe 0x76eb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7770
cmpl $0x0, -0x1c(%rbp)
jge 0x7700
movq -0x38(%rbp), %rdi
callq 0xb660
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x771e
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jl 0x772a
leaq 0xcaac(%rip), %rdi      # 0x141d1
callq 0x6a80
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0xc, %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2090
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x775a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7770
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x20(%rcx), %rcx
addq $0xc, %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::index(char, int) const
int GStr::index(char c, int start_index) const {
    // A negative index specifies an index from the right of the string.
    if (length()==0) return -1;
    if (start_index < 0)
        start_index += length();

    if (start_index < 0 || start_index >= length())
        invalid_index_error("index()");


    if (c == '\0')
        return -1;
    const char *idx=(char *) ::memchr(&my_data->chars[start_index], c,
                                         length()-start_index);
    if (idx==NULL)
        return -1;
    else
        return idx - my_data->chars;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xb660
cmpl $0x0, %eax
jne 0x7923
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x79d3
cmpl $0x0, -0x18(%rbp)
jge 0x7938
movq -0x28(%rbp), %rdi
callq 0xb660
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x7956
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 0x7962
leaq 0xc874(%rip), %rdi      # 0x141d1
callq 0x6a80
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0x7974
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x79d3
movq -0x28(%rbp), %rdi
movq 0x20(%rdi), %rax
addq $0xc, %rax
movslq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movsbl -0x11(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0xb660
movq -0x38(%rbp), %rdi
movl -0x30(%rbp), %esi
subl -0x18(%rbp), %eax
movslq %eax, %rdx
callq 0x22b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x79bd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x79d3
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rcx), %rcx
addq $0xc, %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::format(char const*, ...)
GStr& GStr::format(const char *fmt,...) {
// Format as in sprintf
  make_unique(); //edit operation ahead
  char* buf;
  GMALLOC(buf, strlen(fmt)+1024);
  va_list arguments;
  va_start(arguments,fmt);
  //+1K buffer, should be enough for common expressions
  int len=vsprintf(buf,fmt,arguments);
  va_end(arguments);
  prep_data(len); //this also adds the '\0' at the end!
                     //and sets the right len
  ::memcpy(chrs(), buf, len);
  GFREE(buf);
  return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x7a1b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x63e0
movq -0x10(%rbp), %rdi
callq 0x2140
movq %rax, %rsi
addq $0x400, %rsi            # imm = 0x400
leaq -0x18(%rbp), %rdi
callq 0x58f0
testb $0x1, %al
jne 0x7a7d
leaq 0xc5ad(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2170
movq -0xf8(%rbp), %rdi
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
xorl %edx, %edx
callq 0x6260
movq -0xf8(%rbp), %rdi
callq 0xb630
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x21f0
leaq -0x18(%rbp), %rdi
callq 0x5a90
movq -0xf8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::appendfmt(char const*, ...)
GStr& GStr::appendfmt(const char *fmt,...) {
// Format as in sprintf
  make_unique(); //edit operation ahead
  char* buf;
  GMALLOC(buf, strlen(fmt)+1024);
  va_list arguments;
  va_start(arguments,fmt);
  //+1K buffer, should be enough for common expressions
  vsprintf(buf,fmt,arguments);
  va_end(arguments);
  append(buf);
  GFREE(buf);
  return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x7b38
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x63e0
movq -0x10(%rbp), %rdi
callq 0x2140
movq %rax, %rsi
addq $0x400, %rsi            # imm = 0x400
leaq -0x18(%rbp), %rdi
callq 0x58f0
testb $0x1, %al
jne 0x7b9a
leaq 0xc490(%rip), %rdi      # 0x14023
movb $0x0, %al
callq 0x2640
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2170
movq -0xe8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7390
leaq -0x18(%rbp), %rdi
callq 0x5a90
movq -0xe8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::trim(char)
GStr& GStr::trim(char c) {
 int istart;
 int iend;
 for (istart=0; istart<length() && my_data->chars[istart]==c;istart++) ;
 if (istart==length()) {
       make_unique(); //edit operation ahead
       prep_data(0); //string was entirely trimmed
       return *this;
       }
 for (iend=length()-1; iend>istart && my_data->chars[iend]==c;iend--) ;
 int newlen=iend-istart+1;
 if (newlen==length())  //nothing to trim
           return *this;
 make_unique(); //edit operation ahead
 Data *data = new_data(newlen);
 ::memcpy(data->chars, &my_data->chars[istart], newlen);
 replace_data(data);
 return *this;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0xb660
movl -0x38(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x31(%rbp)
jge 0x7c5b
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x7c64
jmp 0x7c71
jmp 0x7c66
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7c21
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jne 0x7cac
movq -0x30(%rbp), %rdi
callq 0x63e0
movq -0x30(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6260
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7d7c
movq -0x30(%rbp), %rdi
callq 0xb660
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x3d(%rbp)
jle 0x7ce5
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x7cee
jmp 0x7cfb
jmp 0x7cf0
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7cbb
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jne 0x7d29
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7d7c
movq -0x30(%rbp), %rdi
callq 0x63e0
movl -0x20(%rbp), %edi
xorl %esi, %esi
callq 0x6100
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0xc, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movslq -0x20(%rbp), %rdx
callq 0x21f0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6460
movq -0x30(%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: GStr::trim(char const*)
GStr& GStr::trim(const char* c) {
 int istart;
 int iend;
 for (istart=0; istart<length() && strchr(c, my_data->chars[istart])!=NULL ;istart++) ;
 if (istart==length()) {
        prep_data(0); //string was entirely trimmed
        return *this;
        }
 for (iend=length()-1; iend>istart && strchr(c, my_data->chars[iend])!=NULL;iend--) ;
 int newlen=iend-istart+1;
 if (newlen==length())  //nothing to trim
           return *this;
 make_unique(); //edit operation ahead
 Data *data = new_data(newlen);
 ::memcpy(data->chars, & (my_data->chars[istart]), newlen);
 replace_data(data);
 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, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0xb660
movl -0x40(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x39(%rbp)
jge 0x7df0
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %esi
callq 0x2100
cmpq $0x0, %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x7df9
jmp 0x7e06
jmp 0x7dfb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7daf
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jne 0x7e38
movq -0x38(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6260
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7f0f
movq -0x38(%rbp), %rdi
callq 0xb660
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x45(%rbp)
jle 0x7e78
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x20(%rax), %rax
movslq -0x20(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %esi
callq 0x2100
cmpq $0x0, %rax
setne %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0x7e81
jmp 0x7e8e
jmp 0x7e83
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7e47
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jne 0x7ebc
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7f0f
movq -0x38(%rbp), %rdi
callq 0x63e0
movl -0x24(%rbp), %edi
xorl %esi, %esi
callq 0x6100
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0xc, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
movslq -0x24(%rbp), %rdx
callq 0x21f0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6460
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::trimR(char)
GStr& GStr::trimR(char c) {
 //only trim the right end
 int iend;
 for (iend=length()-1; iend>=0 && my_data->chars[iend]==c;iend--) ;
 if (iend==-1) {
       make_unique();
       prep_data(0); //string was entirely trimmed
       return *this;
       }
 int newlen=iend+1;
 if (newlen==length())  //nothing to trim
           return *this;
 make_unique(); //edit operation ahead
 my_data->length=newlen;
 my_data->chars[newlen]='\0';
 /*

 Data *data = new_data(newlen);
 ::memcpy(data->chars, my_data->chars, newlen);
 replace_data(data);
 */
 return *this;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xb660
subl $0x1, %eax
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x29(%rbp)
jl 0x7f6d
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x7f76
jmp 0x7f83
jmp 0x7f78
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7f45
cmpl $-0x1, -0x18(%rbp)
jne 0x7fa9
movq -0x28(%rbp), %rdi
callq 0x63e0
movq -0x28(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6260
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7ffc
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jne 0x7fd4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7ffc
movq -0x28(%rbp), %rdi
callq 0x63e0
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %edx
movq 0x20(%rax), %rcx
movl %edx, 0x8(%rcx)
movq 0x20(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movb $0x0, 0xc(%rcx,%rdx)
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::trimR(char const*)
GStr& GStr::trimR(const char* c) {
 int iend;
 for (iend=length()-1; iend>=0 && strchr(c,my_data->chars[iend])!=NULL;iend--) ;
 if (iend==-1) {
       make_unique();
       prep_data(0); //string was entirely trimmed
       return *this;
       }
 int newlen=iend+1;
 if (newlen==length())  //nothing to trim
           return *this;
 make_unique(); //edit operation ahead
 my_data->length=newlen;
 my_data->chars[newlen]='\0';
 /*
 Data *data = new_data(newlen);
 ::memcpy(data->chars, my_data->chars, newlen);
 replace_data(data);
 */
 return *this;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xb660
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x29(%rbp)
jl 0x8062
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %esi
callq 0x2100
cmpq $0x0, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x806b
jmp 0x8078
jmp 0x806d
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8033
cmpl $-0x1, -0x1c(%rbp)
jne 0x809e
movq -0x28(%rbp), %rdi
callq 0x63e0
movq -0x28(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6260
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x80f1
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jne 0x80c9
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x80f1
movq -0x28(%rbp), %rdi
callq 0x63e0
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %edx
movq 0x20(%rax), %rcx
movl %edx, 0x8(%rcx)
movq 0x20(%rax), %rcx
movslq -0x20(%rbp), %rdx
movb $0x0, 0xc(%rcx,%rdx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::chomp(char const*)
GStr& GStr::chomp(const char* cstr) {
 int iend;
 if (cstr==NULL || *cstr==0) return *this;
 //check if this ends with cstr
 int cend=strlen(cstr)-1;
 iend=my_data->length-1;
 while (iend>=0 && cend>=0) {
  if (my_data->chars[iend]!=cstr[cend]) return *this;
  iend--;
  cend--;
  }
 if (iend==-1) {
       make_unique();
       prep_data(0); //string will be entirely trimmed
       return *this;
       }
 int newlen=iend+1;
 make_unique(); //edit operation ahead
 my_data->length=newlen;
 my_data->chars[newlen]='\0';
 //Data *data = new_data(newlen);
 //::memcpy(data->chars, my_data->chars, newlen);
 //replace_data(data);
 return *this;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x812b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x8138
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8210
movq -0x18(%rbp), %rdi
callq 0x2140
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
movl %ecx, -0x20(%rbp)
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x31(%rbp)
jl 0x8171
cmpl $0x0, -0x20(%rbp)
setge %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x817a
jmp 0x81b9
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x81a5
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8210
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x815c
cmpl $-0x1, -0x1c(%rbp)
jne 0x81df
movq -0x30(%rbp), %rdi
callq 0x63e0
movq -0x30(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6260
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8210
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
callq 0x63e0
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %edx
movq 0x20(%rax), %rcx
movl %edx, 0x8(%rcx)
movq 0x20(%rax), %rcx
movslq -0x24(%rbp), %rdx
movb $0x0, 0xc(%rcx,%rdx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::trimL(char)
GStr& GStr::trimL(char c) {
 int istart;
 for (istart=0; istart<length() && my_data->chars[istart]==c;istart++) ;
 if (istart==length()) {
       prep_data(0); //string was entirely trimmed
       return *this;
       }
 int newlen=length()-istart;
 if (newlen==length())  //nothing to trim
           return *this;
 make_unique(); //edit operation ahead
 Data *data = new_data(newlen);
 ::memcpy(data->chars, &my_data->chars[istart], newlen);
 replace_data(data);
 return *this;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0xb660
movl -0x38(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x31(%rbp)
jge 0x827b
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x8284
jmp 0x8291
jmp 0x8286
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8241
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jne 0x82c3
movq -0x30(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6260
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8347
movq -0x30(%rbp), %rdi
callq 0xb660
movq -0x30(%rbp), %rdi
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jne 0x82f4
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8347
movq -0x30(%rbp), %rdi
callq 0x63e0
movl -0x1c(%rbp), %edi
xorl %esi, %esi
callq 0x6100
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0xc, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x21f0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6460
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::trimL(char const*)
GStr& GStr::trimL(const char* c) {
 int istart;
 for (istart=0; istart<length() && strchr(c,my_data->chars[istart])!=NULL;istart++) ;
 if (istart==length()) {
       prep_data(0); //string was entirely trimmed
       return *this;
       }
 int newlen=length()-istart;
 if (newlen==length())  //nothing to trim
           return *this;
 make_unique(); //edit operation ahead

 Data *data = new_data(newlen);
 ::memcpy(data->chars, &my_data->chars[istart], newlen);
 replace_data(data);
 return *this;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0xb660
movl -0x38(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x31(%rbp)
jge 0x83c0
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %esi
callq 0x2100
cmpq $0x0, %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x83c9
jmp 0x83d6
jmp 0x83cb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x837f
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jne 0x8408
movq -0x30(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6260
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x848c
movq -0x30(%rbp), %rdi
callq 0xb660
movq -0x30(%rbp), %rdi
subl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0xb660
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jne 0x8439
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x848c
movq -0x30(%rbp), %rdi
callq 0x63e0
movl -0x20(%rbp), %edi
xorl %esi, %esi
callq 0x6100
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0xc, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
movslq -0x20(%rbp), %rdx
callq 0x21f0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6460
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::padR(unsigned int, char)
GStr& GStr::padR(uint len, char c) {
 //pad with c until total string length is len
 if (my_data->length>=len) return *this; //no room for padding
 make_unique(); //edit operation ahead
 if (my_data->cap>=len) {
	 ::memset(my_data->chars, c, len-my_data->length);
	 my_data->length=len;
	 return *this;
 }
 Data *data = new_data(len);
 ::memset(data->chars,c,len-my_data->length);
 ::memcpy(&data->chars[len-length()], my_data->chars, my_data->length);
 replace_data(data);
 return *this;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jb 0x84d5
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x85b9
movq -0x28(%rbp), %rdi
callq 0x63e0
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jb 0x852b
movq -0x28(%rbp), %rdx
movq 0x20(%rdx), %rdi
addq $0xc, %rdi
movsbl -0x15(%rbp), %eax
movl -0x14(%rbp), %ecx
movq 0x20(%rdx), %rdx
subl 0x8(%rdx), %ecx
movl %ecx, %ecx
movl %ecx, %edx
movzbl %al, %esi
callq 0x21a0
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %edx
movq 0x20(%rax), %rcx
movl %edx, 0x8(%rcx)
movq %rax, -0x8(%rbp)
jmp 0x85b9
movl -0x14(%rbp), %edi
xorl %esi, %esi
callq 0x6100
movq -0x28(%rbp), %rdx
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
movsbl -0x15(%rbp), %eax
movl -0x14(%rbp), %ecx
movq 0x20(%rdx), %rdx
subl 0x8(%rdx), %ecx
movl %ecx, %ecx
movl %ecx, %edx
movzbl %al, %esi
callq 0x21a0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0xb660
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rdi
movl %eax, %edx
movq -0x28(%rbp), %rax
subl %edx, %ecx
movl %ecx, %ecx
addq %rcx, %rdi
movq 0x20(%rax), %rsi
addq $0xc, %rsi
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x21f0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6460
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gpertea[P]gclib/GStr.cpp
// Function: GStr::padL(unsigned int, char)
GStr& GStr::padL(uint len, char c) { //align left the string
 if (my_data->length>=len) return *this; //no room for padding
 make_unique(); //edit operation ahead
 Data *data = new_data(len);
 ::memcpy(data->chars, my_data->chars, length());
 ::memset(&data->chars[length()],c,len-length());
 replace_data(data);
 return *this;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jb 0x8605
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x86b7
movq -0x28(%rbp), %rdi
callq 0x63e0
movl -0x14(%rbp), %edi
xorl %esi, %esi
callq 0x6100
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x58(%rbp)
movq 0x20(%rdi), %rax
addq $0xc, %rax
movq %rax, -0x50(%rbp)
callq 0xb660
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movslq %eax, %rdx
callq 0x21f0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x48(%rbp)
callq 0xb660
movq -0x28(%rbp), %rdi
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movsbl -0x15(%rbp), %eax
movb %al, -0x29(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0xb660
movl -0x3c(%rbp), %ecx
movq -0x38(%rbp), %rdi
movl %eax, %edx
movb -0x29(%rbp), %al
subl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
movzbl %al, %esi
callq 0x21a0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6460
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)