LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sopanpatra160[P]OOO_Superscalar_Processor_Simulator/cache.cc
// Function: cache::print_tag_store()
void cache::print_tag_store(){
//printf("num set = %d \n",num_set);
	for(unsigned int i=0; i<num_set; i++){
	printf("set  %4d:  ",i);
		for(unsigned int j=0; j<a; j++){
			printf ("%8x ",tag_store[i][j]);
			if(wp == 0){
				if(dirty_store[i][j]==1)
					printf ("D");
				else
					printf (" ");
			}
		}
	printf ("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x70(%rcx), %eax
jae 0x332d
movl -0xc(%rbp), %esi
leaq 0x3f7a(%rip), %rdi      # 0x71ff
movb $0x0, %al
callq 0x1040
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x18(%rcx), %eax
jae 0x3311
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x10(%rbp), %ecx
movl (%rax,%rcx,4), %esi
leaq 0x3f50(%rip), %rdi      # 0x720b
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x3304
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x10(%rbp), %ecx
cmpl $0x1, (%rax,%rcx,4)
jne 0x32f4
leaq 0x3f25(%rip), %rdi      # 0x7210
movb $0x0, %al
callq 0x1040
jmp 0x3302
leaq 0x3f0e(%rip), %rdi      # 0x7209
movb $0x0, %al
callq 0x1040
jmp 0x3304
jmp 0x3306
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3293
leaq 0x3e88(%rip), %rdi      # 0x71a0
movb $0x0, %al
callq 0x1040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x326b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sopanpatra160[P]OOO_Superscalar_Processor_Simulator/main.cc
// Function: Fetch(_IO_FILE*, unsigned int)
void Fetch(FILE *file, unsigned int n)
{
	unsigned int 	pc;
        unsigned int    op_type;
        int             dest_reg_num;
        int             src1_reg_num;
        int             src2_reg_num;
	unsigned int	fetch_count = 0;
	unsigned int 	mem_address;

	struct instruction instr;
	
	while( !feof(file) && fetch_count<n && dispatch_list.size()<2*n )
        {
	        
        	fscanf (file,"%x %d %d %d %d %x\n",&pc,&op_type,&dest_reg_num,&src1_reg_num,&src2_reg_num,&mem_address);
		instr.operation_type 	= 	op_type;
		instr.dest_regno	=	dest_reg_num;
		instr.src1_regno	=	src1_reg_num;
		instr.src2_regno	=	src2_reg_num;
		instr.src1_regno_new	=	src1_reg_num;
		instr.src2_regno_new	=	src2_reg_num;
		instr.state		=	IF;
		instr.tag		=	tag_num;
		instr.if_begin_cycle	=	cycles;
		instr.ex_latency	=	1;
		instr.mem_latency	=	0;
		if(op_type ==2 )
		{
		instr.mem_addr		=	mem_address;
		}

		dispatch_list.push_back(instr);
		fake_rob.push_back(instr);
		tag_num++;
		fetch_count++;
	
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1110
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x81(%rbp)
jne 0x33e0
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x81(%rbp)
jae 0x33e0
leaq 0x6fe0(%rip), %rdi      # 0xa3a8
callq 0x4c20
movl -0xc(%rbp), %ecx
shll %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
setb %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x33ef
jmp 0x34b6
movq -0x8(%rbp), %rdi
leaq 0x3e18(%rip), %rsi      # 0x7212
leaq -0x10(%rbp), %rdx
leaq -0x14(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x1c(%rbp), %r9
leaq -0x20(%rbp), %r10
leaq -0x28(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x1160
movl -0x14(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x74(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x70(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x68(%rbp)
movl $0x0, -0x34(%rbp)
movl 0x6c91(%rip), %eax      # 0xa0e4
movl %eax, -0x30(%rbp)
movl 0x6c8c(%rip), %eax      # 0xa0e8
movl %eax, -0x64(%rbp)
movl $0x1, -0x3c(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x3479
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq 0x6f28(%rip), %rdi      # 0xa3a8
leaq -0x80(%rbp), %rsi
callq 0x4c50
leaq 0x6f00(%rip), %rdi      # 0xa390
leaq -0x80(%rbp), %rsi
callq 0x4c50
movl 0x6c45(%rip), %eax      # 0xa0e4
addl $0x1, %eax
movl %eax, 0x6c3c(%rip)      # 0xa0e4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3399
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/typealias.cc
// Function: main
int main()
{
	// authors is a pair<string, string>
	twin<string> author("Mark", "Twain");
	
	twin<int> win_loss(2, 45);  // win_loss is a pair<int, int>
	
	typedef string Vehicle;
	partNo<Vehicle> car("volvo", 242);  // car is a pair<Vehicle, unsigned>

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe0b(%rip), %rsi       # 0x2004
leaq 0xe09(%rip), %rdx       # 0x2009
leaq -0x48(%rbp), %rdi
callq 0x12a0
movl $0x2, -0x54(%rbp)
movl $0x2d, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x54(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x1380
jmp 0x122a
movl $0xf2, -0x94(%rbp)
leaq 0xdd4(%rip), %rsi       # 0x200f
leaq -0x90(%rbp), %rdi
leaq -0x94(%rbp), %rdx
callq 0x13b0
jmp 0x1250
movl $0x0, -0x4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1430
leaq -0x48(%rbp), %rdi
callq 0x1450
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1450
movq -0x60(%rbp), %rdi
callq 0x1080
nopw %cs:(%rax,%rax)
// File: kerolloz[P]os/sum.c
// Function: count
void *count(void *args) {
  pthread_mutex_lock(&lock);
  // lock other threads from entring this critical section

  for (int i = 0; i < MAX_N; i++)
    sum++;

  pthread_mutex_unlock(&lock);
  // after finishing unlock this section so, other threads can access it
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2ec5(%rip), %rdi      # 0x4068
callq 0x1080
movl $0x0, -0xc(%rbp)
cmpl $0xf4240, -0xc(%rbp)    # imm = 0xF4240
jge 0x11d5
movq 0x2ea1(%rip), %rax      # 0x4060
addq $0x1, %rax
movq %rax, 0x2e96(%rip)      # 0x4060
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11af
leaq 0x2e8c(%rip), %rdi      # 0x4068
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: kerolloz[P]os/sum.c
// Function: main
int main() {
  pthread_t threads[N_THREADS];

  pthread_mutex_init(&lock, NULL);

  // create the threads
  for (int i = 0; i < N_THREADS; i++)
    pthread_create(&threads[i], NULL, count, NULL);

  // wait for all the threads to finish executing
  for (int i = 0; i < N_THREADS; i++)
    pthread_join(threads[i], NULL);

  printf("%lld\n", sum);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x2e62(%rip), %rdi      # 0x4068
xorl %eax, %eax
movl %eax, %esi
callq 0x1070
movl $0x0, -0x34(%rbp)
cmpl $0x5, -0x34(%rbp)
jge 0x1249
movslq -0x34(%rbp), %rax
leaq -0x30(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xa6(%rip), %rdx       # 0x1190
movq %rcx, %rsi
callq 0x1050
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1216
movl $0x0, -0x38(%rbp)
cmpl $0x5, -0x38(%rbp)
jge 0x1273
movslq -0x38(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1060
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1250
movq 0x2de6(%rip), %rsi      # 0x4060
leaq 0xd83(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: aisthesis[P]realnumber/src/real_number.cpp
// Function: RealNumber::to_decimal_string[abi:cxx11]() const
std::string RealNumber::to_decimal_string() const {
    std::stringstream result;
    result << get_integer_part() << '.';
    // make a copy of value because we will be changing it
    unsigned char* fractional_part = new unsigned char[PRECISION];
    std::size_t i;
    for (i = 0; i < PRECISION; ++i) { fractional_part[i] = value[i + INTEGER_DIGITS]; }
		for (i = 0; i < DECIMAL_PRECISION; ++i) { 
			result << (int)(array_arithmetic::convert::helpers::times_ten(fractional_part, PRECISION)); 
		}    
    delete[] fractional_part;
    return result.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x20d0
movq -0x1d8(%rbp), %rdi
leaq -0x188(%rbp), %rax
movq %rax, -0x1d0(%rbp)
callq 0x3880
movl %eax, -0x1c4(%rbp)
jmp 0x36dd
movl -0x1c4(%rbp), %esi
movq -0x1d0(%rbp), %rdi
callq 0x2220
movq %rax, -0x1f0(%rbp)
jmp 0x36f8
movq -0x1f0(%rbp), %rdi
movl $0x2e, %esi
callq 0x21e0
jmp 0x370b
movl $0x32, %edi
callq 0x2030
movq %rax, -0x1f8(%rbp)
jmp 0x371e
movq -0x1f8(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movq $0x0, -0x1b8(%rbp)
cmpq $0x32, -0x1b8(%rbp)
jae 0x379e
movq -0x1d8(%rbp), %rax
movq (%rax), %rax
movq -0x1b8(%rbp), %rcx
movb 0x4(%rax,%rcx), %dl
movq -0x1b0(%rbp), %rax
movq -0x1b8(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x1b8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1b8(%rbp)
jmp 0x3737
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2100
jmp 0x3865
movq $0x0, -0x1b8(%rbp)
cmpq $0x78, -0x1b8(%rbp)
jae 0x3814
leaq -0x188(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x1b0(%rbp), %rdi
movq $0x32, -0x1c0(%rbp)
leaq -0x1c0(%rbp), %rsi
callq 0x4ff0
movb %al, -0x1f9(%rbp)
jmp 0x37e7
movq -0x208(%rbp), %rdi
movb -0x1f9(%rbp), %al
movzbl %al, %esi
callq 0x2280
jmp 0x37fe
jmp 0x3800
movq -0x1b8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1b8(%rbp)
jmp 0x37a9
movq -0x1b0(%rbp), %rax
movq %rax, -0x210(%rbp)
cmpq $0x0, %rax
je 0x3834
movq -0x210(%rbp), %rdi
callq 0x2200
movq -0x1e8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x2150
jmp 0x3849
leaq -0x198(%rbp), %rdi
callq 0x2100
movq -0x1e0(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
// File: aisthesis[P]realnumber/src/real_number.cpp
// Function: RealNumber::get_integer_part() const
unsigned int RealNumber::get_integer_part() const {
    unsigned int result = 0;
    for (std::size_t i = 0; i < INTEGER_DIGITS; ++i) {
        result = result * array_arithmetic::RADIX + value[i];
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jae 0x38ce
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
shll $0x8, %eax
movq (%rcx), %rcx
movq -0x18(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x389f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aisthesis[P]realnumber/src/real_number.cpp
// Function: RealNumber::operator=(RealNumber const&)
RealNumber& RealNumber::operator=(const RealNumber& num) {
    if (this == &num) { return *this; }
    for (std::size_t i = 0; i < ARRAY_SIZE; ++i) {
        this->value[i] = num.value[i];
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x3904
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3945
movq $0x0, -0x20(%rbp)
cmpq $0x36, -0x20(%rbp)
jae 0x393d
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x390c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: aisthesis[P]realnumber/src/real_number.cpp
// Function: RealNumber::operator>(RealNumber const&) const
bool RealNumber::operator>(const RealNumber& num_to_compare) const {
    for (std::size_t i = 0; i < ARRAY_SIZE; ++i) {
        if (this->value[i] > num_to_compare.value[i]) { return true; }
        else if (this->value[i] < num_to_compare.value[i]) { return false; }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x36, -0x20(%rbp)
jae 0x39d5
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x399b
movb $0x1, -0x1(%rbp)
jmp 0x39d9
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x39c3
movb $0x0, -0x1(%rbp)
jmp 0x39d9
jmp 0x39c5
jmp 0x39c7
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x396c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: aisthesis[P]realnumber/src/real_number.cpp
// Function: RealNumber::operator>=(RealNumber const&) const
bool RealNumber::operator>=(const RealNumber& num_to_compare) const {
    for (std::size_t i = 0; i < ARRAY_SIZE; ++i) {
        if (this->value[i] > num_to_compare.value[i]) { return true; }
        else if (this->value[i] < num_to_compare.value[i]) { return false; }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x36, -0x20(%rbp)
jae 0x3a65
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x3a2b
movb $0x1, -0x1(%rbp)
jmp 0x3a69
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x3a53
movb $0x0, -0x1(%rbp)
jmp 0x3a69
jmp 0x3a55
jmp 0x3a57
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x39fc
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: aisthesis[P]realnumber/src/real_number.cpp
// Function: RealNumber::equals(RealNumber const&) const
bool RealNumber::equals(const RealNumber& num_to_compare) const {
	// get the real number against which to measure difference
	std::size_t total_bits = ARRAY_SIZE * 8;
	std::size_t first_bit_to_set = total_bits - BITS_FOR_EQUALITY;
	RealNumber max_diff;
	for (std::size_t i = first_bit_to_set; i < total_bits; ++i) {
		array_arithmetic::bits::set(max_diff.value, i);
	}
	return this->difference(num_to_compare) <= max_diff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x1b0, -0x18(%rbp)     # imm = 0x1B0
movq -0x18(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x32c0
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3cad
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5580
jmp 0x3c86
jmp 0x3c88
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3c6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3650
jmp 0x3ced
movq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x3d00
jmp 0x3cc0
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3b00
movb %al, -0x51(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3650
leaq -0x28(%rbp), %rdi
callq 0x3650
movb -0x51(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
// File: aisthesis[P]realnumber/src/real_number.cpp
// Function: RealNumber::operator+(RealNumber const&) const
RealNumber RealNumber::operator+(const RealNumber& num_to_add) const {
    RealNumber result = RealNumber();
    int carry = 0, tmp_sum = 0;
    for (int i = ARRAY_SIZE - 1; i >= 0; --i) {
        tmp_sum = carry + this->value[i] + num_to_add.value[i];
        result.value[i] = tmp_sum % array_arithmetic::RADIX;
        carry = tmp_sum / array_arithmetic::RADIX;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %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), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x32c0
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x35, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x3e10
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rdx
movl -0x20(%rbp), %ecx
movq (%rdx), %rdx
movslq -0x28(%rbp), %rsi
movzbl (%rdx,%rsi), %edx
addl %edx, %ecx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
movslq -0x28(%rbp), %rsi
movzbl (%rdx,%rsi), %edx
addl %edx, %ecx
movl %ecx, -0x24(%rbp)
movl -0x24(%rbp), %ecx
andl $0xff, %ecx
movb %cl, %dl
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3db5
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3e23
movq -0x40(%rbp), %rdi
callq 0x3650
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: aisthesis[P]realnumber/src/real_number.cpp
// Function: RealNumber::operator*(RealNumber const&) const
RealNumber RealNumber::operator*(const RealNumber& multiplier) const {
	unsigned char* result_arr = new unsigned char[2 * ARRAY_SIZE + 1];
	RealNumber result;
	array_arithmetic::school_multiply(this->value, multiplier.value, result_arr, ARRAY_SIZE,
			ARRAY_SIZE);
	std::size_t offset = INTEGER_DIGITS + 1;
	for (std::size_t i = 0; i < ARRAY_SIZE; ++i) {
		result.value[i] = result_arr[i + offset];
	}
	delete[] result_arr;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%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, -0x60(%rbp)
movl $0x6d, %edi
callq 0x2030
movq -0x68(%rbp), %rdi
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x32c0
movq -0x60(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
movq $0x36, -0x30(%rbp)
movq $0x36, -0x38(%rbp)
leaq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x5600
jmp 0x3f46
movq $0x5, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
cmpq $0x36, -0x58(%rbp)
jae 0x3f9f
movq -0x68(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x58(%rbp), %rdx
addq -0x50(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq (%rax), %rax
movq -0x58(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x3f56
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3650
jmp 0x3fd6
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x3fb6
movq -0x78(%rbp), %rdi
callq 0x2200
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x3fc9
movq -0x68(%rbp), %rdi
callq 0x3650
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2290
nop
// File: aisthesis[P]realnumber/src/real_number.cpp
// Function: RealNumber::set_integer_part(int const&)
void RealNumber::set_integer_part(const int& integer_part) {
    unsigned int tmp = integer_part;
    for (int i = INTEGER_DIGITS - 1; i >= 0; --i) {
        value[i] = tmp % array_arithmetic::RADIX;
        tmp /= array_arithmetic::RADIX;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x3, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x40e7
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
andl $0xff, %ecx
movb %cl, %dl
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x40b4
popq %rbp
retq
nopl (%rax)
// File: aisthesis[P]realnumber/src/convergent_series.cpp
// Function: ConvergentSeries::babylonian_sqrt(RealNumber const&, RealNumber const&, unsigned long const&)
RealNumber ConvergentSeries::babylonian_sqrt(const RealNumber& num, const RealNumber& guess,
                                            const std::size_t& iterations) {
    RealNumber result = guess;
    RealNumber two("2.0");
    for (std::size_t i = 0; i < iterations; ++i) {
        result = (result + (num / result)) / two;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rsi
callq 0x35e0
leaq -0x51(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x22a0
movq -0x90(%rbp), %rdx
leaq 0x1f1c(%rip), %rsi      # 0x6063
leaq -0x50(%rbp), %rdi
callq 0x2f70
jmp 0x4152
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3340
jmp 0x4161
leaq -0x50(%rbp), %rdi
callq 0x20a0
leaq -0x51(%rbp), %rdi
callq 0x21a0
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x4299
movq -0xa0(%rbp), %rdx
movq -0x10(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x3fe0
jmp 0x41a5
movq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x3d70
jmp 0x41be
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3fe0
jmp 0x41d1
movq -0xa0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x38e0
jmp 0x41e3
leaq -0x78(%rbp), %rdi
callq 0x3650
leaq -0x80(%rbp), %rdi
callq 0x3650
leaq -0x88(%rbp), %rdi
callq 0x3650
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x417b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4235
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x20a0
leaq -0x51(%rbp), %rdi
callq 0x21a0
jmp 0x42d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x42ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x428b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4282
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3650
leaq -0x80(%rbp), %rdi
callq 0x3650
leaq -0x88(%rbp), %rdi
callq 0x3650
jmp 0x42ae
movb $0x1, -0x21(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3650
testb $0x1, -0x21(%rbp)
jne 0x42c5
jmp 0x42b9
leaq -0x30(%rbp), %rdi
callq 0x3650
jmp 0x42d5
movq -0xa0(%rbp), %rdi
callq 0x3650
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x3650
movq -0x60(%rbp), %rdi
callq 0x2290
nopw (%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::convert::from_int(unsigned int const&, unsigned char*, unsigned long const&)
void from_int(const unsigned int& num, unsigned char* result, 
				const std::size_t& result_len) {
			unsigned int num_copy = num;
			std::size_t i = result_len;
			while (i > 0) {
				--i;
				result[i] = num_copy % RADIX;
				num_copy /= RADIX;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x4de7
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4db4
popq %rbp
retq
nopl (%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::convert::to_int(unsigned char const*, unsigned long const&)
unsigned int to_int(const unsigned char* arr, const std::size_t& arr_len) {
			unsigned int result = 0;
			for (std::size_t i = 0; i < arr_len; ++i) {
				result = result * RADIX + arr[i];
			}
			return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x4e3d
movl -0x14(%rbp), %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4e0b
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::convert::helpers::to_digit_array(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
unsigned char* to_digit_array(const std::string& str) {
				std::size_t len = str.size();
				unsigned char* result = new unsigned char[len];
				std::size_t i = 0;
				while (i < len) {
					if (0 <= str[i] - '0' && str[i] - '0' <= 9) {
						result[i] = str[i] - '0';
					}
					else {
						delete[] result;
						throw std::invalid_argument("Input can contain only decimal digits!");
					}
					++i;
				}
				return result;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2030
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4f57
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x21c0
movsbl (%rax), %ecx
subl $0x30, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x4edf
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x21c0
movsbl (%rax), %eax
subl $0x30, %eax
cmpl $0x9, %eax
jg 0x4edf
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x21c0
movsbl (%rax), %eax
subl $0x30, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x4f46
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x4ef6
movq -0x38(%rbp), %rdi
callq 0x2200
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x11c5(%rip), %rsi      # 0x60d6
callq 0x22c0
jmp 0x4f18
movq -0x40(%rbp), %rdi
movq 0x30bd(%rip), %rsi      # 0x7fe0
movq 0x30a6(%rip), %rdx      # 0x7fd0
callq 0x2270
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x20f0
jmp 0x4f61
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4e7e
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2290
nopw (%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::convert::helpers::times_radix(unsigned char*, unsigned long const&)
unsigned char times_radix(unsigned char* decimal_digits, 
					const std::size_t& arr_len) {
				unsigned char carry = 0;
				unsigned int tmp;
				std::size_t i = arr_len;
				while (i > 0) {
					--i;
					tmp = carry + decimal_digits[i] * RADIX;
					decimal_digits[i] = tmp % 10;
					carry = tmp / 10;
				}
				return carry;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x4fde
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movzbl -0x11(%rbp), %eax
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movb %al, -0x11(%rbp)
jmp 0x4f8b
movb -0x11(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::convert::helpers::times_ten(unsigned char*, unsigned long const&)
unsigned char times_ten(unsigned char* radix_digits, const std::size_t& arr_len) {
				unsigned char carry = 0;
				unsigned int tmp;
				std::size_t i = arr_len;
				while (i > 0) {
					--i;
					tmp = carry + radix_digits[i] * 10;
					radix_digits[i] = tmp % RADIX;
					carry = tmp / RADIX;
				}
				return carry;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x5056
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movzbl -0x11(%rbp), %eax
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
imull $0xa, %ecx, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
shrl $0x8, %eax
movb %al, -0x11(%rbp)
jmp 0x500b
movb -0x11(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::helpers::copy_into(unsigned char const*, unsigned char*, unsigned long const&, unsigned long const&)
void copy_into(const unsigned char* source, unsigned char* target, const std::size_t&
				source_len, const std::size_t& target_len) {
			std::size_t i;
			for (i = 0; i < source_len; ++i) {
				target[i] = source[i];
			}
			for ( ; i < target_len; ++i) {
				target[i] = 0;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x50ad
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x507c
jmp 0x50af
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x50d6
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x50af
popq %rbp
retq
nopl (%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::helpers::shift_right(unsigned char*, unsigned long const&, unsigned long const&)
void shift_right(unsigned char* arr, const size_t& places, const size_t& arr_size) {
			std::size_t i = arr_size - places;
			while (i > 0) {
				--i;
				arr[i + places] = arr[i];
			}
			i = places;
			while (i > 0) {
				--i;
				arr[i] = 0;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x5134
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rsi
addq (%rsi), %rcx
movb %dl, (%rax,%rcx)
jmp 0x5102
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x5160
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x513f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::helpers::less_or_equal(unsigned char const*, unsigned char const*, unsigned long const&)
bool less_or_equal(const unsigned char* arr1, const unsigned char* arr2, 
															 const std::size_t& len) {
			for (std::size_t i = 0; i < len; ++i) {
				if (arr1[i] < arr2[i]) { return true; }
				if (arr1[i] > arr2[i]) { return false; }
				// loop continues only when arr1[i] == arr2[i]
			}
			// nothing was returned in the loop, so values are equal
			return true;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x51e9
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x51b7
movb $0x1, -0x1(%rbp)
jmp 0x51ed
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x51d9
movb $0x0, -0x1(%rbp)
jmp 0x51ed
jmp 0x51db
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5188
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::helpers::division::align_dividend(unsigned char*, unsigned char const*, unsigned long const&)
int align_dividend(unsigned char* dividend, const unsigned char* divisor, const std::size_t& len) {
				int result = 0;
				while (less_or_equal(divisor, dividend, len)) {
					bits::shift_right(dividend, 1, len);
					--result;
				}
				return result;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5170
testb $0x1, %al
jne 0x52d2
jmp 0x52f6
movq -0x8(%rbp), %rdi
movq $0x1, -0x28(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rsi
callq 0x5300
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x52bb
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::bits::shift_right(unsigned char*, unsigned long const&, unsigned long const&)
void shift_right(unsigned char* arr, const std::size_t& places, const std::size_t& arr_size) {
			std::size_t byte_places = places / 8;
			std::size_t bit_places = places % 8;
			helpers::shift_right(arr, byte_places, arr_size);
			// now we only have to worry about bit_places
			if (bit_places == 0) { return; }
			unsigned char mask = get_mask(bit_places);
			std::size_t offset = 8 - bit_places;
			unsigned char tmp;
			std::size_t i = arr_size - 1;
			// the first byte_places positions are all 0, so we don't have to worry about them
			while (i > byte_places) {
				// shift the given position
				arr[i] >>= bit_places;
				// get the relevant bits from the position to the left and add them in
				tmp = arr[i - 1] & mask;
				arr[i] += (tmp << offset);
				--i;
			}
			arr[byte_places] >>= bit_places;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0x50e0
cmpq $0x0, -0x28(%rbp)
jne 0x534f
jmp 0x53ff
leaq -0x28(%rbp), %rdi
callq 0x5540
movb %al, -0x29(%rbp)
movl $0x8, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x53e2
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq -0x48(%rbp), %rdx
movq %rdx, -0x50(%rbp)
movzbl (%rax,%rdx), %edx
sarl %cl, %edx
movq -0x50(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq -0x48(%rbp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
movzbl -0x29(%rbp), %ecx
andl %ecx, %eax
movb %al, -0x39(%rbp)
movzbl -0x39(%rbp), %esi
movq -0x38(%rbp), %rax
movl %eax, %ecx
shll %cl, %esi
movq -0x8(%rbp), %rax
movq -0x48(%rbp), %rcx
movzbl (%rax,%rcx), %edx
addl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x5377
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rdx
movq %rdx, -0x58(%rbp)
movzbl (%rax,%rdx), %edx
sarl %cl, %edx
movq -0x58(%rbp), %rcx
movb %dl, (%rax,%rcx)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::helpers::division::align_divisor(unsigned char const*, unsigned char*, unsigned long const&)
int align_divisor(const unsigned char* dividend, unsigned char* divisor, const std::size_t& len) {
			  int result = 0;
				while (!less_or_equal(divisor, dividend, len)) {
					bits::shift_right(divisor, 1, len);
					++result;
				}
				return result;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5170
xorb $-0x1, %al
testb $0x1, %al
jne 0x5444
jmp 0x5468
movq -0x10(%rbp), %rdi
movq $0x1, -0x28(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rsi
callq 0x5300
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x542b
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::helpers::division::readjust(unsigned char const*, unsigned char*, unsigned long const&)
int readjust(const unsigned char* dividend, unsigned char* divisor, const std::size_t& len) {
				int adjustment = 0;
				while (!less_or_equal(divisor, dividend, len)) {
					bits::shift_right(divisor, 1, len);
					++adjustment;
				}
				return adjustment;
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5170
xorb $-0x1, %al
testb $0x1, %al
jne 0x5504
jmp 0x5528
movq -0x10(%rbp), %rdi
movq $0x1, -0x28(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rsi
callq 0x5300
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x54eb
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::bits::set(unsigned char*, unsigned long const&)
void set(unsigned char* arr, const std::size_t& bit_to_set) {
			std::size_t array_index = bit_to_set / 8;
			std::size_t bit_position = bit_to_set % 8;
			unsigned char mask = 1 << (7 - bit_position);
			arr[array_index] |= mask;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
movq %rax, -0x20(%rbp)
movl $0x7, %eax
subq -0x20(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %esi
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::school_multiply(unsigned char const*, unsigned char const*, unsigned char*, unsigned long const&, unsigned long const&)
void school_multiply(const unsigned char* a, const unsigned char* b,
			unsigned char* result, const std::size_t& a_len, const std::size_t& b_len) {
		// end_pos tracks the least significant digit in the result array
		std::size_t a_index, b_index, result_index, end_pos;
		unsigned int carry, tmp;
		const std::size_t RESULT_LEN = a_len + b_len + 1;
		// initialize result to 0
		for (result_index = 0; result_index < RESULT_LEN; ++result_index) {
			result[result_index] = 0;
		}
		b_index = b_len;
		end_pos = RESULT_LEN;
		while (b_index > 0) {
			--b_index;
			result_index = end_pos;
			a_index = a_len;
			carry = 0;
			while (a_index > 0) {
				--a_index;
				--result_index;
				tmp = carry + result[result_index] + a[a_index] * b[b_index];
				result[result_index] = tmp % RADIX;
				carry = tmp / RADIX;
			}
			result[result_index - 1] = carry;
			--end_pos;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
addq (%rcx), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0x565a
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x5636
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x38(%rbp)
jbe 0x5733
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x4c(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x570e
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
movl -0x4c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rsi
movzbl (%rdx,%rsi), %edx
imull %edx, %ecx
addl %ecx, %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x50(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x4c(%rbp)
jmp 0x569e
movl -0x4c(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
subq $0x1, %rcx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x566d
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::add(unsigned char const*, unsigned char const*, unsigned char*, unsigned long const&)
void add(const unsigned char* a, const unsigned char* b, unsigned char* result,
			const std::size_t& len) {
		unsigned int carry = 0, tmp_sum;
		std::size_t i = len;
		while (i > 0) {
			--i;
			tmp_sum = carry + a[i] + b[i];
			result[i] = tmp_sum % RADIX;
			carry = tmp_sum / RADIX;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x57bb
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x24(%rbp)
jmp 0x5766
popq %rbp
retq
nopl (%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::add(unsigned char const*, unsigned char const*, unsigned char*, unsigned long const&, unsigned long const&)
void add(const unsigned char* a, const unsigned char* b,
			unsigned char* result, const std::size_t& a_len, const std::size_t& b_len) {
		unsigned int carry = 0, tmp_sum;
		unsigned int a_b_diff = a_len - b_len;
		std::size_t i = b_len;
		while (i > 0) {
			--i;
			tmp_sum = carry + a[i + a_b_diff] + b[i];
			result[i + a_b_diff + 1] = tmp_sum % RADIX;
			carry = tmp_sum / RADIX;
		}
		i = a_b_diff;
		while (i > 0) {
			--i;
			tmp_sum = carry + a[i];
			result[i + 1] = tmp_sum % RADIX;
			carry = tmp_sum / RADIX;
		}
		result[0] = carry;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
subq (%rcx), %rax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jbe 0x585d
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq -0x40(%rbp), %rdx
movl -0x34(%rbp), %esi
addq %rsi, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %esi
addq %rsi, %rcx
movb %dl, 0x1(%rax,%rcx)
movl -0x30(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x2c(%rbp)
jmp 0x57fb
movl -0x34(%rbp), %eax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jbe 0x58ac
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq -0x40(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movb %dl, 0x1(%rax,%rcx)
movl -0x30(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5864
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq
nopl (%rax)
// File: aisthesis[P]realnumber/src/array_arithmetic.cpp
// Function: array_arithmetic::subtract(unsigned char const*, unsigned char const*, unsigned char*, unsigned long const&)
void subtract(const unsigned char* a, const unsigned char* b, unsigned char* result,
			const std::size_t& len) {
		std::size_t i;
		// copy of a is needed because we have to modify it when we borrow
		unsigned char* a_copy = new unsigned char[len];
		for (i = 0; i < len; ++i) { a_copy[i] = a[i]; }
		i = len;
		int borrow_index;
		while (i > 0) {
			--i;
			if (a_copy[i] >= b[i]) { result[i] = a_copy[i] - b[i]; }
			else {
				result[i] = RADIX + a_copy[i] - b[i];
				borrow_index = i - 1;
				// get to a point where there is something to borrow
				while (borrow_index > 0 && a_copy[borrow_index] == 0) {
					a_copy[borrow_index--] = RADIX_MINUS_ONE;
				}
				--a_copy[borrow_index];
			}
		}
		delete[] a_copy;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x5921
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x58f0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x5a19
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jl 0x598b
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x5a14
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
addl $0x100, %eax            # imm = 0x100
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
subq $0x1, %rax
movl %eax, -0x34(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x34(%rbp)
movb %al, -0x35(%rbp)
jle 0x59e2
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x59eb
jmp 0x5a03
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x34(%rbp)
movslq %ecx, %rcx
movb $-0x1, (%rax,%rcx)
jmp 0x59c2
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb (%rax,%rcx), %dl
addb $-0x1, %dl
movb %dl, (%rax,%rcx)
jmp 0x592c
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x5a30
movq -0x40(%rbp), %rdi
callq 0x2200
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)