LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: matteotiziano[P]simple-wavelet/./vector.h
// Function: std::vector<double, std::allocator<double>>& Vector::operator*=<double>(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>> const&)
std::vector<T>& operator*=(std::vector<T>& vector1, const std::vector<T>& vector2) {
    if(vector1.size() != vector2.size()) {
      throw std::invalid_argument("std::vector operator*=");
    }
    std::transform(vector1.begin(), vector1.end(), vector2.begin(), vector1.begin(), std::multiplies<T>());
    return vector1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31e0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xeb32
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x3ab4(%rip), %rsi      # 0x125b1
callq 0x2380
jmp 0xeb04
movq -0x60(%rbp), %rdi
movq 0xb4d1(%rip), %rsi      # 0x19fe0
movq 0xb4aa(%rip), %rdx      # 0x19fc0
callq 0x2330
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2170
jmp 0xeb89
movq -0x8(%rbp), %rdi
callq 0x45b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4270
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45b0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x4ad0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: matteotiziano[P]simple-wavelet/matrix.cpp
// Function: Matrix<double>::ElementQuotient(Matrix<double>) const
Matrix<T> Matrix<T>::ElementQuotient(Matrix<T> rhs) const {
  if (Size() != rhs.Size()) {
    throw std::invalid_argument("Matrix::ElementQuotient");
  }
  rhs.GetData() /= data_;
  return rhs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xca80
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
callq 0xca80
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xe6a0
testb $0x1, %al
jne 0xebff
jmp 0xec4f
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x3932(%rip), %rsi      # 0x1254c
callq 0x2380
jmp 0xec21
movq -0x70(%rbp), %rdi
movq 0xb3b4(%rip), %rsi      # 0x19fe0
movq 0xb38d(%rip), %rdx      # 0x19fc0
callq 0x2330
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x2170
jmp 0xec8a
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x78(%rbp)
callq 0xd4d0
movq -0x78(%rbp), %rsi
movq %rax, %rdi
callq 0xeca0
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3490
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: matteotiziano[P]simple-wavelet/./vector.h
// Function: std::vector<double, std::allocator<double>>& Vector::operator/=<double>(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>> const&)
std::vector<T>& operator/=(std::vector<T>& vector1, const std::vector<T>& vector2) {
    if(vector1.size() != vector2.size()) {
      throw std::invalid_argument("std::vector operator/=");
    }
    std::transform(vector1.begin(), vector1.end(), vector2.begin(), vector1.begin(), std::divides<T>());
    return vector1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31e0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xed22
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x38db(%rip), %rsi      # 0x125c8
callq 0x2380
jmp 0xecf4
movq -0x60(%rbp), %rdi
movq 0xb2e1(%rip), %rsi      # 0x19fe0
movq 0xb2ba(%rip), %rdx      # 0x19fc0
callq 0x2330
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2170
jmp 0xed79
movq -0x8(%rbp), %rdi
callq 0x45b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4270
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45b0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x10eb0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: rupc[P]xor-secret-sharing-scheme/main.cpp
// Function: XORSecretShares::XORSecretShares(unsigned long)
explicit XORSecretShares(size_t n): key_size(n) {
            if (!(n == 64 || n == 128 || n == 256)) {
                std::cerr << "Only 64/128/256 possible" << std::endl;
                _init = false;
            }
            _init = true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl %eax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x21c0
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x3bf0
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x3c10
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0x3c30
cmpq $0x40, -0x10(%rbp)
je 0x3949
cmpq $0x80, -0x10(%rbp)
je 0x3949
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
je 0x3949
movq 0x56ec(%rip), %rdi      # 0x8ff0
leaq 0x2751(%rip), %rsi      # 0x605c
callq 0x2150
movq %rax, -0x38(%rbp)
jmp 0x3916
movq -0x38(%rbp), %rdi
movq 0x569f(%rip), %rsi      # 0x8fc0
callq 0x2170
jmp 0x3928
movq -0x28(%rbp), %rax
movb $0x0, 0x4(%rax)
jmp 0x3949
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20c0
jmp 0x3957
movq -0x28(%rbp), %rax
movb $0x1, 0x4(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2220
// File: Manu343726[P]Polyop/main.cpp
// Function: main
int main()
{
    using pop::trigger::_;
    
    auto op = _( 1.0f ) == 1.0f;
    
    std::cout << std::boolalpha << op() << std::endl;
    std::cout << std::boolalpha << op( floating_point_context_tag{} ) << std::endl;
    std::cout << std::boolalpha << (_(1.0f) == 2.0f)( floating_point_context_tag{} ) << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movss 0xe05(%rip), %xmm0      # 0x2008
movss %xmm0, -0x24(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x1420
movq %rax, -0x20(%rbp)
movss 0xdeb(%rip), %xmm0      # 0x2008
movss %xmm0, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x13e0
movq 0x2d9e(%rip), %rdi      # 0x3fd8
leaq 0x20f(%rip), %rsi       # 0x1450
callq 0x1030
movq %rax, -0x78(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1480
movq -0x78(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1080
movq %rax, %rdi
movq 0x2d5c(%rip), %rsi      # 0x3fc8
callq 0x1060
movq 0x2d60(%rip), %rdi      # 0x3fd8
leaq 0x1d1(%rip), %rsi       # 0x1450
callq 0x1030
movq %rax, -0x70(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x14a0
movq -0x70(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1080
movq %rax, %rdi
movq 0x2d1e(%rip), %rsi      # 0x3fc8
callq 0x1060
movq 0x2d22(%rip), %rdi      # 0x3fd8
leaq 0x193(%rip), %rsi       # 0x1450
callq 0x1030
movq %rax, -0x68(%rbp)
movss 0xd3a(%rip), %xmm0      # 0x2008
movss %xmm0, -0x54(%rbp)
leaq -0x54(%rbp), %rdi
callq 0x1420
movq %rax, -0x50(%rbp)
movss 0xd1c(%rip), %xmm0      # 0x2004
movss %xmm0, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x13e0
leaq -0x48(%rbp), %rdi
callq 0x14a0
movq -0x68(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x1080
movq %rax, %rdi
movq 0x2ca8(%rip), %rsi      # 0x3fc8
callq 0x1060
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
// File: t0mm4rx[P]piscine_cpp/day04/ex01/AWeapon.cpp
// Function: AWeapon::operator=(AWeapon const&)
AWeapon &AWeapon::operator=(const AWeapon &other)
{
	this->name = other.name;
	this->apCost = other.apCost;
	this->damage = other.damage;
	return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movl 0x2c(%rcx), %ecx
movl %ecx, 0x2c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day04/ex01/Character.cpp
// Function: operator<<(std::ostream&, Character const&)
std::ostream& operator<<(std::ostream& os, const Character& c)
{
	(void) c;
    os << c.getName() << " has " << c.getAP() << " AP and ";
	if (c.getWeapon() == NULL)
		os << "is unarmed";
	else
		os << "carries " << c.getWeapon()->getName();
	os << std::endl;
	return (os);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2800
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x20f0
movq %rax, -0x68(%rbp)
jmp 0x2adf
movq -0x68(%rbp), %rdi
leaq 0x2580(%rip), %rsi      # 0x506a
callq 0x2100
movq %rax, -0x80(%rbp)
jmp 0x2af5
movq -0x10(%rbp), %rdi
callq 0x2a60
movq -0x80(%rbp), %rdi
movl %eax, %esi
callq 0x21e0
movq %rax, -0x88(%rbp)
jmp 0x2b12
movq -0x88(%rbp), %rdi
leaq 0x2550(%rip), %rsi      # 0x5070
callq 0x2100
jmp 0x2b27
leaq -0x30(%rbp), %rdi
callq 0x2090
movq -0x10(%rbp), %rdi
callq 0x2a80
cmpq $0x0, %rax
jne 0x2b6e
movq -0x8(%rbp), %rdi
leaq 0x252f(%rip), %rsi      # 0x5079
callq 0x2100
jmp 0x2bd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2090
jmp 0x2bf5
movq -0x8(%rbp), %rdi
leaq 0x250b(%rip), %rsi      # 0x5084
callq 0x2100
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a80
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x26a0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x20f0
jmp 0x2bb6
leaq -0x60(%rbp), %rdi
callq 0x2090
jmp 0x2bd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2090
jmp 0x2bf5
movq -0x8(%rbp), %rdi
movq 0x53e5(%rip), %rsi      # 0x7fc8
callq 0x2130
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x21f0
nop
// File: t0mm4rx[P]piscine_cpp/day04/ex01/PlasmaRifle.cpp
// Function: PlasmaRifle::operator=(PlasmaRifle const&)
PlasmaRifle &PlasmaRifle::operator=(const PlasmaRifle &other)
{
	this->name = other.getName();
	this->apCost = other.getAPCost();
	this->damage = other.getDamage();
	return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x26a0
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x2180
leaq -0x30(%rbp), %rdi
callq 0x2090
movq -0x10(%rbp), %rdi
callq 0x2680
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x26d0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x2c(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: t0mm4rx[P]piscine_cpp/day04/ex01/SuperMutant.cpp
// Function: SuperMutant::takeDamage(int)
void SuperMutant::takeDamage(int damage)
{
	(void)damage;
	this->hp -= 3;
	this->hp = (this->hp < 0 ? 0 : this->hp);
	std::cout << this->hp << " HP remaining for " << this->type << std::endl;
}

// 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)
movl 0x8(%rax), %ecx
subl $0x3, %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
jge 0x3b2d
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3b37
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %esi
movq 0x448d(%rip), %rdi      # 0x7fd8
callq 0x21e0
movq %rax, %rdi
leaq 0x1533(%rip), %rsi      # 0x508d
callq 0x2100
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rsi
callq 0x20f0
movq %rax, %rdi
movq 0x444f(%rip), %rsi      # 0x7fc8
callq 0x2130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: rapirent[P]JPEG/encoder.c
// Function: write_one_bit(_IO_FILE*, int, bool)
void write_one_bit(FILE *fp, int value, bool mode)
{
    static byte buffer = 0x00;
    static byte count = 0;
    if(mode==true) {
        for (int i = count; i<7; i++) {
            buffer = (buffer << 1);
        }
        fwrite(&buffer,1,1,fp);
        return;
    }
    if (value != 1 && value != 0) {
        printf("bit number should be a binary\n");
        exit(1);
    }
    buffer = (buffer << 1) | value;
    if(count==7) {
        fwrite(&buffer,1,1,fp);
        if(buffer == 0xff) {
            byte c = 0x00;
            fwrite(&c,1,1,fp);
        }
        buffer = 0x00;
    }
    count = (count == 7 ? 0 : count + 1);
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
andb $0x1, %al
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x56ef
movzbl 0xa337(%rip), %eax      # 0xf9e1
movl %eax, 0x14(%rsp)
cmpl $0x7, 0x14(%rsp)
jge 0x56d1
movzbl 0xa324(%rip), %eax      # 0xf9e0
shll %eax
movb %al, 0xa31c(%rip)       # 0xf9e0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x56ae
movq 0x20(%rsp), %rcx
leaq 0xa303(%rip), %rdi      # 0xf9e0
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5370
jmp 0x57aa
cmpl $0x1, 0x1c(%rsp)
je 0x5715
cmpl $0x0, 0x1c(%rsp)
je 0x5715
leaq 0x51b9(%rip), %rdi      # 0xa8bd
movb $0x0, %al
callq 0x5040
movl $0x1, %edi
callq 0x5260
movzbl 0xa2c4(%rip), %eax      # 0xf9e0
shll %eax
orl 0x1c(%rsp), %eax
movb %al, 0xa2b8(%rip)       # 0xf9e0
movzbl 0xa2b2(%rip), %eax      # 0xf9e1
cmpl $0x7, %eax
jne 0x577e
movq 0x20(%rsp), %rcx
leaq 0xa2a0(%rip), %rdi      # 0xf9e0
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5370
movzbl 0xa28c(%rip), %eax      # 0xf9e0
cmpl $0xff, %eax
jne 0x5777
movb $0x0, 0x13(%rsp)
movq 0x20(%rsp), %rcx
leaq 0x13(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5370
movb $0x0, 0xa262(%rip)      # 0xf9e0
movzbl 0xa25c(%rip), %eax      # 0xf9e1
cmpl $0x7, %eax
jne 0x5792
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x57a0
movzbl 0xa248(%rip), %eax      # 0xf9e1
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movb %al, 0xa237(%rip)       # 0xf9e1
addq $0x28, %rsp
retq
nop
// File: rapirent[P]JPEG/encoder.c
// Function: find_length(int*)
byte find_length (int* value)
{
    byte need_write_length = 0;
    int tmp = (*value);
    if (*value < 0) {
        tmp = -(*value);
    }
    for (; tmp ; tmp = tmp >> 1) {
        need_write_length++;
    }
    *value = (*value) > 0 ? (*value) : ((0x1 << need_write_length) + (*value) -1);
    return need_write_length;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movb $0x0, -0x9(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpl $0x0, (%rax)
jge 0x583c
movq -0x8(%rsp), %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x10(%rsp)
jmp 0x583e
cmpl $0x0, -0x10(%rsp)
je 0x585b
movb -0x9(%rsp), %al
addb $0x1, %al
movb %al, -0x9(%rsp)
movl -0x10(%rsp), %eax
sarl %eax
movl %eax, -0x10(%rsp)
jmp 0x583e
movq -0x8(%rsp), %rax
cmpl $0x0, (%rax)
jle 0x5872
movq -0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rsp)
jmp 0x588c
movzbl -0x9(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movq -0x8(%rsp), %rcx
addl (%rcx), %eax
subl $0x1, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movb -0x9(%rsp), %al
retq
nopl (%rax)
// File: rapirent[P]JPEG/./bitmap_image.hpp
// Function: bitmap_image::operator!()
inline bool operator!()
   {
      return (data_.size()   == 0) ||
             (width_         == 0) ||
             (height_        == 0) ||
             (row_increment_ == 0);
   }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x38, %rdi
callq 0x8550
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, 0xf(%rsp)
je 0x73b9
movq (%rsp), %rcx
movb $0x1, %al
cmpl $0x0, 0x20(%rcx)
movb %al, 0xf(%rsp)
je 0x73b9
movq (%rsp), %rcx
movb $0x1, %al
cmpl $0x0, 0x24(%rcx)
movb %al, 0xf(%rsp)
je 0x73b9
movq (%rsp), %rax
cmpl $0x0, 0x28(%rax)
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: rapirent[P]JPEG/./bitmap_image.hpp
// Function: bitmap_image::operator=(bitmap_image const&)
bitmap_image& operator=(const bitmap_image& image)
   {
      if (this != &image)
      {
         file_name_       = image.file_name_;
         bytes_per_pixel_ = image.bytes_per_pixel_;
         width_           = image.width_;
         height_          = image.height_;
         row_increment_   = 0;
         channel_mode_    = image.channel_mode_;
         create_bitmap();
         data_ = image.data_;
      }

      return *this;
   }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq 0x8(%rsp), %rax
je 0x746e
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5030
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x2c(%rdi)
movq 0x8(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x20(%rdi)
movq 0x8(%rsp), %rax
movl 0x24(%rax), %eax
movl %eax, 0x24(%rdi)
movl $0x0, 0x28(%rdi)
movq 0x8(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x30(%rdi)
callq 0x8320
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x8f10
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: rapirent[P]JPEG/./bitmap_image.hpp
// Function: bitmap_image::file_size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline std::size_t file_size(const std::string& file_name)
   {
      std::ifstream file(file_name.c_str(),std::ios::in | std::ios::binary);
      if (!file) return 0;
      file.seekg (0, std::ios::end);
      return static_cast<std::size_t>(file.tellg());
   }

// Assembly:
subq $0x268, %rsp            # imm = 0x268
movq %rdi, 0x258(%rsp)
movq %rsi, 0x250(%rsp)
movq 0x250(%rsp), %rdi
callq 0x50c0
movq %rax, 0x18(%rsp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x8480
movq 0x18(%rsp), %rsi
movl %eax, %edx
leaq 0x48(%rsp), %rdi
callq 0x5350
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x48(%rsp,%rax), %rdi
callq 0x5100
movb %al, 0x27(%rsp)
jmp 0x8242
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x824c
jmp 0x827c
movq $0x0, 0x260(%rsp)
movl $0x1, 0x38(%rsp)
jmp 0x82df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5080
jmp 0x82f9
xorl %eax, %eax
movl %eax, %esi
leaq 0x48(%rsp), %rdi
movl $0x2, %edx
callq 0x52a0
jmp 0x8291
leaq 0x48(%rsp), %rdi
callq 0x5310
movq %rdx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x82a7
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x84a0
movq %rax, (%rsp)
jmp 0x82cb
movq (%rsp), %rax
movq %rax, 0x260(%rsp)
movl $0x1, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5080
movq 0x260(%rsp), %rax
addq $0x268, %rsp            # imm = 0x268
retq
movq 0x40(%rsp), %rdi
callq 0x5320
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mapequation[P]partition-validation/./partition-validation.h
// Function: tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> tokenize(const string &str, char delimiter) {
    vector<string> tokens;

    // skip delimiter at beginning.
    auto lastPos = str.find_first_not_of(delimiter, 0);

    // find first "non-delimiter".
    auto pos = str.find_first_of(delimiter, lastPos);

    while (string::npos != pos || string::npos != lastPos) {
        // found a token, add it to the vector.
        tokens.push_back(str.substr(lastPos, pos - lastPos));

        // skip delimiter.  Note the "not_of"
        lastPos = str.find_first_not_of(delimiter, pos);

        // find next "non-delimiter"
        pos = str.find_first_of(delimiter, lastPos);
    }

    return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x8100
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x11(%rbp), %esi
callq 0x3290
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0x31b0
movq %rax, -0x28(%rbp)
movb $0x1, %al
movq $-0x1, %rcx
cmpq -0x28(%rbp), %rcx
movb %al, -0x69(%rbp)
jne 0x36f8
movq $-0x1, %rax
cmpq -0x20(%rbp), %rax
setne %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x3704
jmp 0x378e
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq %rdx, %rcx
leaq -0x48(%rbp), %rdi
callq 0x32f0
jmp 0x371e
movq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8120
jmp 0x372d
leaq -0x48(%rbp), %rdi
callq 0x31a0
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movq -0x28(%rbp), %rdx
movsbl %al, %esi
callq 0x3290
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0x31b0
movq %rax, -0x28(%rbp)
jmp 0x36d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x37ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31a0
jmp 0x37ab
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x37a1
movq -0x68(%rbp), %rdi
callq 0x8150
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x8150
movq -0x50(%rbp), %rdi
callq 0x34a0
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/unique.cc
// Function: main
int main() {
	shared_ptr<string> p(new string("Hello"));
	shared_ptr<string> p2(p);    // two users of the allocated string
	string newVal = " World!";
	if (!p.unique())
		p.reset(new string(*p)); // we aren't alone; allocate a new copy
	*p += newVal; // now that we know we're the only pointer, okay to change this object
	cout << *p << endl;
	cout << *p2 << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl $0x20, %edi
callq 0x2090
movq %rax, -0x78(%rbp)
movq %rax, -0x80(%rbp)
movb $0x1, -0x2d(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2130
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0xd40(%rip), %rsi       # 0x3004
callq 0x20e0
jmp 0x22cb
movq -0x80(%rbp), %rsi
movb $0x0, -0x2d(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x24d0
jmp 0x22de
leaq -0x19(%rbp), %rdi
callq 0x20c0
leaq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2500
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2130
movq -0x88(%rbp), %rdx
leaq 0xcf8(%rip), %rsi       # 0x300a
leaq -0x60(%rbp), %rdi
callq 0x20e0
jmp 0x231d
leaq -0x61(%rbp), %rdi
callq 0x20c0
leaq -0x18(%rbp), %rdi
callq 0x2530
testb $0x1, %al
jne 0x23f5
movl $0x20, %edi
callq 0x2090
movq %rax, -0x90(%rbp)
jmp 0x234a
leaq -0x18(%rbp), %rdi
callq 0x25b0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x2050
jmp 0x2364
movq -0x90(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x2560
jmp 0x2376
jmp 0x23f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x20c0
testb $0x1, -0x2d(%rbp)
jne 0x2395
jmp 0x23a3
movq -0x80(%rbp), %rdi
movl $0x20, %esi
callq 0x20a0
jmp 0x24ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x20c0
jmp 0x24a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x249f
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x20, %esi
callq 0x20a0
jmp 0x249f
leaq -0x18(%rbp), %rdi
callq 0x25b0
movq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0x20d0
jmp 0x240c
leaq -0x18(%rbp), %rdi
callq 0x25b0
movq %rax, %rsi
movq 0x2bb9(%rip), %rdi      # 0x4fd8
callq 0x2080
movq %rax, -0x98(%rbp)
jmp 0x242d
movq -0x98(%rbp), %rdi
movq 0x2b85(%rip), %rsi      # 0x4fc0
callq 0x20b0
jmp 0x2442
leaq -0x40(%rbp), %rdi
callq 0x25b0
movq %rax, %rsi
movq 0x2b83(%rip), %rdi      # 0x4fd8
callq 0x2080
movq %rax, -0xa0(%rbp)
jmp 0x2463
movq -0xa0(%rbp), %rdi
movq 0x2b4f(%rip), %rsi      # 0x4fc0
callq 0x20b0
jmp 0x2478
leaq -0x60(%rbp), %rdi
callq 0x2060
leaq -0x40(%rbp), %rdi
callq 0x25e0
leaq -0x18(%rbp), %rdi
callq 0x25e0
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x2060
leaq -0x40(%rbp), %rdi
callq 0x25e0
leaq -0x18(%rbp), %rdi
callq 0x25e0
movq -0x28(%rbp), %rdi
callq 0x2120
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: obliviousram[P]oblivious-avl-tree/src/Block.cpp
// Function: Block::Block(Block const&)
Block::Block(const Block& b) {
    for (int i = 0; i<BLOCK_SIZE; i++) {
		this->data[i] = b.data[i];
	}
    this->leaf_id = b.leaf_id;
    this->id = b.id;
    this->leftChildPos = b.leftChildPos;
    this->leftChildId = b.leftChildId;
    this->rightChildPos = b.rightChildPos;
    this->rightChildId = b.rightChildId;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x1a385(%rip), %rcx     # 0x1dac0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x24(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x379c
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movl 0x10(%rcx,%rdx,4), %edx
movslq -0x14(%rbp), %rcx
movl %edx, 0x10(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3773
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movl 0x2c(%rcx), %ecx
movl %ecx, 0x2c(%rax)
popq %rbp
retq
nop
// File: obliviousram[P]oblivious-avl-tree/src/Block.cpp
// Function: Block::printBlock()
void Block::printBlock(){
	string data_holder = "";
	for (int i = 0; i<BLOCK_SIZE; i++) {
		data_holder += to_string(this->data[i]);
		data_holder += " ";
	}
	cout << "id: " << to_string(this->id) << " leaf id: " << to_string(this->leaf_id) << " data: " << data_holder << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x33b0
movq -0xa8(%rbp), %rdx
leaq 0x126de(%rip), %rsi     # 0x16016
leaq -0x28(%rbp), %rdi
callq 0x3b60
jmp 0x3943
leaq -0x29(%rbp), %rdi
callq 0x3250
movl $0x0, -0x40(%rbp)
cmpl $0x4, -0x40(%rbp)
jge 0x39f3
movq -0xb0(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl 0x10(%rax,%rcx,4), %esi
leaq -0x60(%rbp), %rdi
callq 0x3c10
jmp 0x3977
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x32c0
jmp 0x3986
leaq -0x60(%rbp), %rdi
callq 0x3120
leaq 0x1267f(%rip), %rsi     # 0x16015
leaq -0x28(%rbp), %rdi
callq 0x31e0
jmp 0x39a1
jmp 0x39a3
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x3953
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x3250
jmp 0x3b36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3b2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3120
jmp 0x3b2d
movq 0x1a5de(%rip), %rdi     # 0x1dfd8
leaq 0x12609(%rip), %rsi     # 0x1600a
callq 0x31f0
movq %rax, -0xb8(%rbp)
jmp 0x3a0f
movq -0xb0(%rbp), %rax
movl 0xc(%rax), %esi
leaq -0x80(%rbp), %rdi
callq 0x3c10
jmp 0x3a24
movq -0xb8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x31c0
movq %rax, -0xc0(%rbp)
jmp 0x3a3d
movq -0xc0(%rbp), %rdi
leaq 0x125b9(%rip), %rsi     # 0x16004
callq 0x31f0
movq %rax, -0xc8(%rbp)
jmp 0x3a59
movq -0xb0(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0xa0(%rbp), %rdi
callq 0x3c10
jmp 0x3a71
movq -0xc8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x31c0
movq %rax, -0xd0(%rbp)
jmp 0x3a8d
movq -0xd0(%rbp), %rdi
leaq 0x12574(%rip), %rsi     # 0x1600f
callq 0x31f0
movq %rax, -0xd8(%rbp)
jmp 0x3aa9
movq -0xd8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x31c0
movq %rax, -0xe0(%rbp)
jmp 0x3ac2
movq -0xe0(%rbp), %rdi
movq 0x1a4f8(%rip), %rsi     # 0x1dfc8
callq 0x3230
jmp 0x3ad7
leaq -0xa0(%rbp), %rdi
callq 0x3120
leaq -0x80(%rbp), %rdi
callq 0x3120
leaq -0x28(%rbp), %rdi
callq 0x3120
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3b24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3120
leaq -0x80(%rbp), %rdi
callq 0x3120
leaq -0x28(%rbp), %rdi
callq 0x3120
movq -0x38(%rbp), %rdi
callq 0x33a0
nop
// File: obliviousram[P]oblivious-avl-tree/src/Bucket.cpp
// Function: Bucket::Bucket(Bucket*)
Bucket::Bucket(Bucket *other){
    if(other == NULL){
        throw new runtime_error("the other bucket is not malloced.");
    }
    blocks = vector<Block>(max_size);
    for(int i = 0; i < max_size; i++){
        blocks[i] = Block(other->blocks[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x48b0
cmpq $0x0, -0x10(%rbp)
jne 0x438b
movl $0x8, %edi
callq 0x30d0
movq %rax, -0x88(%rbp)
movl $0x10, %edi
callq 0x3210
movq %rax, -0x80(%rbp)
jmp 0x430c
movq -0x80(%rbp), %rdi
leaq 0x11e32(%rip), %rsi     # 0x16149
callq 0x30a0
jmp 0x431e
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, (%rdi)
leaq 0x197bd(%rip), %rsi     # 0x1daf0
xorl %eax, %eax
movl %eax, %edx
callq 0x3370
jmp 0x446d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x4369
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x3220
movq -0x88(%rbp), %rdi
callq 0x3160
jmp 0x445b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x445b
movslq 0x19e96(%rip), %rax     # 0x1e228
movq %rax, -0x98(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4960
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x4980
jmp 0x43c2
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x48d0
leaq -0x38(%rbp), %rdi
callq 0x4900
leaq -0x39(%rbp), %rdi
callq 0x49f0
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl 0x19e37(%rip), %eax     # 0x1e228
jge 0x4452
movq -0x10(%rbp), %rdi
movslq -0x40(%rbp), %rsi
callq 0x4a10
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x3720
jmp 0x440e
movq -0x78(%rbp), %rdi
movslq -0x40(%rbp), %rsi
callq 0x4a10
movq %rax, %rdi
leaq -0x70(%rbp), %rsi
callq 0x4a30
leaq -0x70(%rbp), %rdi
callq 0x3830
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x43e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x49f0
jmp 0x445b
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x4900
movq -0x18(%rbp), %rdi
callq 0x33a0
nopl (%rax)
// File: obliviousram[P]oblivious-avl-tree/src/Bucket.cpp
// Function: Bucket::getBlockByIndex(int)
Block Bucket::getBlockByIndex(int id) {
    Block *copy_block = NULL;
    for(Block b: blocks){
        if(b.id == id){
            copy_block = new Block(b);
            break;
        }
    }
    return *copy_block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4a70
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4aa0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4ad0
testb $0x1, %al
jne 0x44d4
jmp 0x458d
leaq -0x30(%rbp), %rdi
callq 0x4b10
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x3720
movl -0x5c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x4557
movl $0x30, %edi
callq 0x3210
movq %rax, -0x90(%rbp)
jmp 0x4504
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3720
jmp 0x4516
movq -0x90(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x2, -0x78(%rbp)
jmp 0x455e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4582
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl $0x30, %esi
callq 0x3220
jmp 0x4582
movl $0x0, -0x78(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3830
movl -0x78(%rbp), %eax
testl %eax, %eax
je 0x4572
jmp 0x4570
jmp 0x458d
jmp 0x4574
leaq -0x30(%rbp), %rdi
callq 0x4b30
jmp 0x44be
leaq -0x68(%rbp), %rdi
callq 0x3830
jmp 0x45aa
movq -0x88(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3720
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x33a0
nopw %cs:(%rax,%rax)
// File: obliviousram[P]oblivious-avl-tree/src/Bucket.cpp
// Function: Bucket::removeBlock(Block)
bool Bucket::removeBlock(Block rm_blk){
    bool removed = false;
    for(int i = 0; i < blocks.size(); i++){
        if(blocks[i].id == rm_blk.id){
            blocks.erase(blocks.begin() + i);
            removed = true;
            break;
        }
    }
    return removed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x4b50
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x46ef
movq -0x40(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x4a10
movq -0x48(%rbp), %rcx
movl 0xc(%rax), %eax
cmpl 0xc(%rcx), %eax
jne 0x46df
movq -0x40(%rbp), %rdi
callq 0x4a70
movq %rax, -0x30(%rbp)
movslq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4c60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4ca0
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4bf0
movq %rax, -0x38(%rbp)
movb $0x1, -0x11(%rbp)
jmp 0x46ef
jmp 0x46e1
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4667
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: obliviousram[P]oblivious-avl-tree/src/Bucket.cpp
// Function: Bucket::setMaxSize(int)
void Bucket::setMaxSize(int maximumSize){
    if(is_init == true){
        throw new runtime_error("Max Bucket Size was already set");
    }
    max_size = maximumSize;
    is_init = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movb 0x19af2(%rip), %al      # 0x1e233
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x47c9
movl $0x8, %edi
callq 0x30d0
movq %rax, -0x28(%rbp)
movl $0x10, %edi
callq 0x3210
movq %rax, -0x20(%rbp)
jmp 0x4769
movq -0x20(%rbp), %rdi
leaq 0x119f7(%rip), %rsi     # 0x1616b
callq 0x30a0
jmp 0x477b
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, (%rdi)
leaq 0x19363(%rip), %rsi     # 0x1daf0
xorl %eax, %eax
movl %eax, %edx
callq 0x3370
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x47be
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x10, %esi
callq 0x3220
movq -0x28(%rbp), %rdi
callq 0x3160
jmp 0x47df
movl -0x4(%rbp), %eax
movl %eax, 0x19a56(%rip)     # 0x1e228
movb $0x1, 0x19a5a(%rip)     # 0x1e233
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x33a0
nopl (%rax,%rax)
// File: obliviousram[P]oblivious-avl-tree/src/OAVLTreeDeterministicEviction.cpp
// Function: OAVLTreeDeterministicEviction::performDummyFinds(int)
void OAVLTreeDeterministicEviction::performDummyFinds(int num) {
    for (int i = 0; i < num; ++i) {
        auto leaf = rand_gen->getRandomLeaf();
        for (int i = 0; i < num_levels; i++) {
            vector<Block> blocks = storage->readBucket(P(leaf, i)).getBlocks();
            Bucket writeBack;
            for (Block &b: blocks) {
                writeBack.addBlock(b);
            }
            storage->writeBucket(P(leaf, i), writeBack);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xbf59
movq -0xc8(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0xc8(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0xbf49
movq -0xc8(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, -0xd8(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq 0x10(%rax), %rax
callq *%rax
movq -0xd8(%rbp), %rsi
movl %eax, %edx
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x48(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq *%rax
movq -0xd0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4700
jmp 0xbddd
leaq -0x48(%rbp), %rdi
callq 0xcfd0
leaq -0x70(%rbp), %rdi
callq 0x41c0
jmp 0xbdf1
leaq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x4a70
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x4aa0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x4ad0
testb $0x1, %al
jne 0xbe2f
jmp 0xbed0
leaq -0x80(%rbp), %rdi
callq 0x4b10
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x3720
jmp 0xbe54
leaq -0x70(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x45c0
jmp 0xbe66
leaq -0xc0(%rbp), %rdi
callq 0x3830
leaq -0x80(%rbp), %rdi
callq 0x4b30
jmp 0xbe16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xcfd0
jmp 0xbf62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xbf3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xbf35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x3830
jmp 0xbf35
movq -0xc8(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, -0xe8(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq 0x10(%rax), %rax
callq *%rax
movl %eax, -0xdc(%rbp)
jmp 0xbef9
movl -0xdc(%rbp), %esi
movq -0xe8(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x70(%rbp), %rdx
callq *%rax
jmp 0xbf15
leaq -0x70(%rbp), %rdi
callq 0xcfd0
leaq -0x30(%rbp), %rdi
callq 0x4900
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbd7a
leaq -0x70(%rbp), %rdi
callq 0xcfd0
leaq -0x30(%rbp), %rdi
callq 0x4900
jmp 0xbf62
jmp 0xbf4b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbd54
addq $0xf0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33a0
nopl (%rax,%rax)
// File: obliviousram[P]oblivious-avl-tree/src/OAVLTreeDeterministicEviction.cpp
// Function: OAVLTreeDeterministicEviction::evictTwoPaths()
void OAVLTreeDeterministicEviction::evictTwoPaths() {
    int g_1 = ReverseBits(this->G, num_levels - 1);
    this->G += 1;
    this->evictByLeaf(g_1);
    int g_2 = ReverseBits(this->G, num_levels - 1);
    this->G += 1;
    this->evictByLeaf(g_2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl 0x18(%rdi), %esi
movl 0x20(%rdi), %edx
subl $0x1, %edx
callq 0xc5e0
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
movl 0x18(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x18(%rdi)
movl -0xc(%rbp), %esi
callq 0xc640
movq -0x18(%rbp), %rdi
movl 0x18(%rdi), %esi
movl 0x20(%rdi), %edx
subl $0x1, %edx
callq 0xc5e0
movq -0x18(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl 0x18(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x18(%rdi)
movl -0x10(%rbp), %esi
callq 0xc640
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: obliviousram[P]oblivious-avl-tree/src/OAVLTreeDeterministicEviction.cpp
// Function: OAVLTreeDeterministicEviction::updateHeight()
void OAVLTreeDeterministicEviction::updateHeight() {
    for (int i = local.size() - 2; i >= 0; i--) {
        if (local[i].leftChildId == local[i+1].id) {
            local[i].data[2] = 1 + max(local[i+1].data[2], local[i+1].data[3]);
        } else local[i].data[3] = 1 + max(local[i+1].data[2], local[i+1].data[3]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x48, %rdi
callq 0x4b50
subq $0x2, %rax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xc16e
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movslq -0xc(%rbp), %rsi
callq 0x4a10
movq -0x18(%rbp), %rdi
movl 0x24(%rax), %eax
movl %eax, -0x1c(%rbp)
addq $0x48, %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x4a10
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl 0xc(%rcx), %eax
jne 0xc0f3
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x4a10
movq -0x18(%rbp), %rdi
addq $0x10, %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
addq $0x48, %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x4a10
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rsi
addq $0xc, %rsi
callq 0xd0a0
movq -0x18(%rbp), %rdi
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
addq $0x48, %rdi
movslq -0xc(%rbp), %rsi
callq 0x4a10
movl -0x20(%rbp), %ecx
movl %ecx, 0x18(%rax)
jmp 0xc15e
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x4a10
movq -0x18(%rbp), %rdi
addq $0x10, %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
addq $0x48, %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x4a10
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rsi
addq $0xc, %rsi
callq 0xd0a0
movq -0x18(%rbp), %rdi
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
addq $0x48, %rdi
movslq -0xc(%rbp), %rsi
callq 0x4a10
movl -0x2c(%rbp), %ecx
movl %ecx, 0x1c(%rax)
jmp 0xc160
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc044
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: obliviousram[P]oblivious-avl-tree/src/OAVLTreeDeterministicEviction.cpp
// Function: OAVLTreeDeterministicEviction::ReverseBits(int, int)
int OAVLTreeDeterministicEviction::ReverseBits(int g, int bits_length) {
    /*
    INPUT: Integers g and bits_length.
    OUTPUT: Integer reverse of length bits_length consisting of reversed bits of g.
    To be used to traverse the leaves and run eviction in reverse lexicographical order.
    */
    int g_mod = g % num_leaves;
    int reverse = 0;
    while(g_mod) {
        reverse <<= 1;
        reverse |= g_mod & 1;
        g_mod >>= 1;
        bits_length--;
    }
    
    reverse <<= bits_length;
    return reverse;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %eax
cltd
idivl 0x24(%rcx)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xc630
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc603
movl -0x10(%rbp), %ecx
movl -0x18(%rbp), %eax
shll %cl, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: obliviousram[P]oblivious-avl-tree/src/OAVLTreePathEviction.cpp
// Function: OAVLTreePathEviction::evictTwoPaths()
void OAVLTreePathEviction::evictTwoPaths() {
    int random_leaf_one = this->rand_gen->getRandomLeaf()/2;
    int random_leaf_two = this->rand_gen->getRandomLeaf()/2 + this->num_leaves/2;
    this->evictByLeaf(random_leaf_one);
    this->evictByLeaf(random_leaf_two);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl 0x20(%rdi), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %esi
callq 0x11500
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x11500
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: obliviousram[P]oblivious-avl-tree/src/RandomForOram.cpp
// Function: RandomForOram::RandomForOram()
RandomForOram::RandomForOram() {

	if (this->is_initialized) {
		throw new runtime_error("ONLY ONE RANDOM INSTANCE CAN BE USED AT A TIME");
	}
	this->rng(long());
	this->rand_history = vector<int>();
	is_initialized  = true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x124c0
movq -0x40(%rbp), %rdi
leaq 0xbe8c(%rip), %rax      # 0x1dc90
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x6c30
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x124e0
jmp 0x11e23
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
callq 0x12500
jmp 0x11e32
movq -0x40(%rbp), %rdi
movq $0x0, 0x13b0(%rdi)
addq $0x13b8, %rdi           # imm = 0x13B8
movq %rdi, -0x50(%rbp)
callq 0x12520
jmp 0x11e53
testb $0x1, 0xc3de(%rip)      # 0x1e238
je 0x11f02
movl $0x8, %edi
callq 0x30d0
movq %rax, -0x60(%rbp)
movl $0x10, %edi
callq 0x3210
movq %rax, -0x58(%rbp)
jmp 0x11e7e
movq -0x58(%rbp), %rdi
leaq 0x4487(%rip), %rsi      # 0x16310
callq 0x30a0
jmp 0x11e90
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rax
movq %rax, (%rdi)
leaq 0xbc4e(%rip), %rsi      # 0x1daf0
xorl %eax, %eax
movl %eax, %edx
callq 0x3370
jmp 0x11f7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x11f69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x11ee9
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x10, %esi
callq 0x3220
movq -0x60(%rbp), %rdi
callq 0x3160
jmp 0x11f60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x11f60
movq -0x40(%rbp), %rdi
addq $0x13b8, %rdi           # imm = 0x13B8
movq $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x125c0
jmp 0x11f20
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3100
leaq -0x38(%rbp), %rdi
callq 0x6c30
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
leaq -0x38(%rbp), %rsi
callq 0x125f0
leaq -0x38(%rbp), %rdi
callq 0x6f40
movb $0x1, 0xc2de(%rip)      # 0x1e238
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x12620
movq -0x48(%rbp), %rdi
callq 0x6f40
movq -0x10(%rbp), %rdi
callq 0x33a0
nopl (%rax,%rax)
// File: obliviousram[P]oblivious-avl-tree/src/RandomForOram.cpp
// Function: RandomForOram::getRandomLeaf()
int RandomForOram::getRandomLeaf() {
	
	long next = this->rng();
	int randVal = next % this->bound;
	if (randVal < 0) {
		randVal += this->bound;
	}
	//this->rand_history.push_back(randVal);
	return randVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x13b8, %rdi           # imm = 0x13B8
callq 0x12660
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq 0xc281(%rip), %rcx      # 0x1e22c
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x11fc7
movl 0xc26b(%rip), %eax      # 0x1e22c
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq