LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: IlyaSamoylov45[P]MapReduce-Project/main.cpp
// Function: split_string_by_space(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<std::string> split_string_by_space(std::string input){
  std::string buf;
  std::stringstream ss(input);

  std::vector<std::string> words;
  while(ss >> buf)
    words.push_back(buf);

  return words;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rsi, -0x1e8(%rbp)
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4450
movl $0x10, %edi
movl $0x8, %esi
callq 0xac60
movl %eax, -0x1cc(%rbp)
jmp 0x7dcb
movl -0x1cc(%rbp), %edx
movq -0x1e8(%rbp), %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x4510
jmp 0x7de6
movq -0x1e0(%rbp), %rdi
movb $0x0, -0x1c5(%rbp)
callq 0xac80
leaq -0x1b8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4400
movq %rax, -0x1f0(%rbp)
jmp 0x7e12
movq -0x1f0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x43f0
movb %al, -0x1f1(%rbp)
jmp 0x7e30
movb -0x1f1(%rbp), %al
testb $0x1, %al
jne 0x7e3c
jmp 0x7e90
movq -0x1e0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xaca0
jmp 0x7e4e
jmp 0x7df9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x7ed1
movq -0x1e0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
callq 0x97e0
leaq -0x1b8(%rbp), %rdi
callq 0x4250
jmp 0x7ed1
movb $0x1, -0x1c5(%rbp)
testb $0x1, -0x1c5(%rbp)
jne 0x7eac
movq -0x1e0(%rbp), %rdi
callq 0x97e0
leaq -0x1b8(%rbp), %rdi
callq 0x4250
leaq -0x30(%rbp), %rdi
callq 0x41f0
movq -0x1d8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x41f0
movq -0x1c0(%rbp), %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)
// File: IlyaSamoylov45[P]MapReduce-Project/main.cpp
// Function: red_proc()
void *red_proc(){
    managed_shared_memory segment(open_or_create, "shared_memory", SHAREDMEMSIZE);
    typedef std::string KeyType;
    typedef int MappedType;
    typedef std::pair<const std::string, int> ValueType;
    typedef allocator<ValueType, managed_shared_memory::segment_manager> ShmemAllocator;
    typedef map<KeyType, MappedType, std::less<KeyType>, ShmemAllocator> MySHMMap;
    ShmemAllocator alloc_inst (segment.get_segment_manager());
    MySHMMap :: iterator iter;
    offset_ptr<MySHMMap> m_pmap = segment.find<MySHMMap>("MySHMMapName").first;
    for(iter=m_pmap->begin(); iter!=m_pmap->end();iter++)
    {
	//std::cout<< iter->second << std::endl;
	//std::cout<< iter->first << std::endl;
    }
 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xa5e0
movq -0xa0(%rbp), %r8
leaq 0x1f2fd(%rip), %rsi     # 0x28186
xorl %eax, %eax
movl %eax, %ecx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0xa0000, %edx          # imm = 0xA0000
callq 0xa6f0
movq -0x98(%rbp), %rdi
callq 0xa7b0
movq %rax, -0x90(%rbp)
jmp 0x8eb7
movq -0x90(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xa7d0
jmp 0x8ec9
leaq -0x50(%rbp), %rdi
callq 0xa800
jmp 0x8ed4
leaq 0x1f313(%rip), %rsi     # 0x281ee
leaq -0x70(%rbp), %rdi
callq 0xa8a0
jmp 0x8ee6
movq -0x70(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xa820
movq %rdx, -0xb0(%rbp)
movq %rax, -0xa8(%rbp)
jmp 0x8f03
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xa8c0
movq -0xb8(%rbp), %rdi
callq 0xa910
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
callq 0xa930
jmp 0x8f47
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xa980
leaq -0x58(%rbp), %rdi
callq 0xa910
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0xaa00
jmp 0x8f6b
leaq -0x50(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xa9d0
testb $0x1, %al
jne 0x8f7e
jmp 0x8fab
jmp 0x8f80
leaq -0x88(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0xaa50
jmp 0x8f54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa6c0
jmp 0x8fad
ud2
movq -0x40(%rbp), %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)
// File: IlyaSamoylov45[P]MapReduce-Project/main.cpp
// Function: check_values(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void check_values(std::string value, std::string correct){
  if(value.compare(correct) != 0){
    std::cout << "\n" << "Usage is: --app [wordcount, sort] --impl [procs, threads] --maps num_maps --reduces num_reduces --input infile --output outfile" << std::endl;
    std::cout << "Error was in the argument " << correct << std::endl;
    std::cout << "You wrote: " << value << "\n" << std::endl;
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4030
cmpl $0x0, %eax
je 0x908c
movq 0x36fd3(%rip), %rdi     # 0x3ffc0
leaq 0x1f1f8(%rip), %rsi     # 0x281ec
callq 0x4340
movq %rax, %rdi
leaq 0x1f1f8(%rip), %rsi     # 0x281fb
callq 0x4340
movq %rax, %rdi
movq 0x36f96(%rip), %rsi     # 0x3ffa8
callq 0x4370
movq 0x36fa2(%rip), %rdi     # 0x3ffc0
leaq 0x1f256(%rip), %rsi     # 0x2827b
callq 0x4340
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x42c0
movq %rax, %rdi
movq 0x36f68(%rip), %rsi     # 0x3ffa8
callq 0x4370
movq 0x36f74(%rip), %rdi     # 0x3ffc0
leaq 0x1f26b(%rip), %rsi     # 0x282be
callq 0x4340
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x42c0
movq %rax, %rdi
leaq 0x1f17e(%rip), %rsi     # 0x281ec
callq 0x4340
movq %rax, %rdi
movq 0x36f2b(%rip), %rsi     # 0x3ffa8
callq 0x4370
movl $0x1, %edi
callq 0x43c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: IlyaSamoylov45[P]MapReduce-Project/main.cpp
// Function: check_file(char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void check_file(char* filename, std::string correct){
  struct stat test;
  if (stat(filename, &test) != 0) {
    std::cout << "\n" << "Usage is: --app [wordcount, sort] --impl [procs, threads] --maps num_maps --reduces num_reduces --input infile --output outfile" << std::endl;
    std::cout << "Error was in the argument " << correct << std::endl;
    std::cout << "Error was:" << strerror(errno) << std::endl;
    std::cout << "You wrote: " << filename << "\n" << std::endl;
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x42f0
cmpl $0x0, %eax
je 0x94a0
movq 0x36c06(%rip), %rdi     # 0x3ffc0
leaq 0x1ee2b(%rip), %rsi     # 0x281ec
callq 0x4340
movq %rax, %rdi
leaq 0x1ee2b(%rip), %rsi     # 0x281fb
callq 0x4340
movq %rax, %rdi
movq 0x36bc9(%rip), %rsi     # 0x3ffa8
callq 0x4370
movq 0x36bd5(%rip), %rdi     # 0x3ffc0
leaq 0x1ee89(%rip), %rsi     # 0x2827b
callq 0x4340
movq -0xa8(%rbp), %rsi
movq %rax, %rdi
callq 0x42c0
movq %rax, %rdi
movq 0x36b98(%rip), %rsi     # 0x3ffa8
callq 0x4370
movq 0x36ba4(%rip), %rdi     # 0x3ffc0
leaq 0x1efa5(%rip), %rsi     # 0x283c8
callq 0x4340
movq %rax, -0xb0(%rbp)
callq 0x4050
movl (%rax), %edi
callq 0x40e0
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x4340
movq %rax, %rdi
movq 0x36b54(%rip), %rsi     # 0x3ffa8
callq 0x4370
movq 0x36b60(%rip), %rdi     # 0x3ffc0
leaq 0x1ee57(%rip), %rsi     # 0x282be
callq 0x4340
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x4340
movq %rax, %rdi
leaq 0x1ed6a(%rip), %rsi     # 0x281ec
callq 0x4340
movq %rax, %rdi
movq 0x36b17(%rip), %rsi     # 0x3ffa8
callq 0x4370
movl $0x1, %edi
callq 0x43c0
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: aman-agrawal[P]Terminal-based-file-explorer/cursor_handle.cpp
// Function: cursor_handle(int&, int&)
int cursor_handle(int &x, int &y)
{
	printf("\033[%d;%dH",x,y) ; // going to x row y column
	char c;
	while(1)
{		c=getchar();
	if(c==65 && x>1) {
		//cursorup
		x--;
		mov(x,y);
	}

	else if(c==66) {
		//cursordown
		x++;
		mov(x,y);
	}		
		
	else if(c==68) {
		//cursorbackward
		return 3;
	}
	else if(c==67) {
		//cursorforward
		return 4;
	}
	else if(c==10) {
		//enter key is tapped
		return 1;
	}
	else if(c=='h'|| c=='H') {
		//home key is pressed
		return 2;
	}
	else if(c==127) {
		//backspace key is pressed
		return 5;
	}
	else if(c==':') {
		//colon is pressed
		return 6;
	}

	return -1;
		
}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
leaq 0x5f5c(%rip), %rdi      # 0xb04f
movb $0x0, %al
callq 0x3030
callq 0x3400
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x41, %eax
jne 0x5135
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jle 0x5135
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x50a0
jmp 0x51e2
movsbl -0x19(%rbp), %eax
cmpl $0x42, %eax
jne 0x515f
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x50a0
jmp 0x51e0
movsbl -0x19(%rbp), %eax
cmpl $0x44, %eax
jne 0x5171
movl $0x3, -0x4(%rbp)
jmp 0x51e9
movsbl -0x19(%rbp), %eax
cmpl $0x43, %eax
jne 0x5183
movl $0x4, -0x4(%rbp)
jmp 0x51e9
movsbl -0x19(%rbp), %eax
cmpl $0xa, %eax
jne 0x5195
movl $0x1, -0x4(%rbp)
jmp 0x51e9
movsbl -0x19(%rbp), %eax
cmpl $0x68, %eax
je 0x51a7
movsbl -0x19(%rbp), %eax
cmpl $0x48, %eax
jne 0x51b0
movl $0x2, -0x4(%rbp)
jmp 0x51e9
movsbl -0x19(%rbp), %eax
cmpl $0x7f, %eax
jne 0x51c2
movl $0x5, -0x4(%rbp)
jmp 0x51e9
movsbl -0x19(%rbp), %eax
cmpl $0x3a, %eax
jne 0x51d4
movl $0x6, -0x4(%rbp)
jmp 0x51e9
jmp 0x51d6
jmp 0x51d8
jmp 0x51da
jmp 0x51dc
jmp 0x51de
jmp 0x51e0
jmp 0x51e2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: aman-agrawal[P]Terminal-based-file-explorer/keyboard.cpp
// Function: off_keyboard()
void off_keyboard()
{
tcgetattr(0,&initial_settings);
new_settings = initial_settings;
new_settings.c_lflag &= ~ICANON;
new_settings.c_lflag &= ~ECHO;
tcsetattr(0, TCSANOW, &new_settings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
leaq 0xb0f3(%rip), %rsi      # 0x10300
callq 0x3370
leaq 0xb123(%rip), %rdi      # 0x1033c
leaq 0xb0e0(%rip), %rsi      # 0x10300
movl $0x3c, %edx
callq 0x3240
movl 0xb118(%rip), %eax      # 0x10348
andl $-0x3, %eax
movl %eax, 0xb10f(%rip)      # 0x10348
movl 0xb109(%rip), %eax      # 0x10348
andl $-0x9, %eax
movl %eax, 0xb100(%rip)      # 0x10348
xorl %esi, %esi
leaq 0xb0eb(%rip), %rdx      # 0x1033c
movl %esi, %edi
callq 0x33d0
popq %rbp
retq
nopw (%rax,%rax)
// File: aman-agrawal[P]Terminal-based-file-explorer/pathtrim.cpp
// Function: trim1(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string trim1(string largepath)
{
   int len=largepath.size(),i,countt=0,j,k=0,flag=0;
    char d2=largepath[len-2];
    char d1=largepath[len-1];

    if(d1=='.' && d2=='.')
    {
        for(i=len-1;i>=0;i--)
        {
            if(flag==1)
                break;
            if(largepath[i]=='/')
            {
                countt++;
            }
            if(countt==2)
            {
                j=i-1;
                flag=1;
                break;
            }
        }
    }
    if(countt==2)
       return largepath.substr(0,j+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq %rax, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3200
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x14(%rbp), %eax
subl $0x2, %eax
movslq %eax, %rsi
callq 0x35a0
movq -0x38(%rbp), %rdi
movb (%rax), %al
movb %al, -0x29(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x35a0
movb (%rax), %al
movb %al, -0x2a(%rbp)
movsbl -0x2a(%rbp), %eax
cmpl $0x2e, %eax
jne 0x535f
movsbl -0x29(%rbp), %eax
cmpl $0x2e, %eax
jne 0x535f
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x535d
cmpl $0x1, -0x28(%rbp)
jne 0x531a
jmp 0x535d
movq -0x38(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x35a0
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x5338
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jne 0x5350
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x28(%rbp)
jmp 0x535d
jmp 0x5352
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x530c
jmp 0x535f
cmpl $0x2, -0x1c(%rbp)
jne 0x5389
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl -0x20(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x3310
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
ud2
nopl (%rax,%rax)
// File: aman-agrawal[P]Terminal-based-file-explorer/aman.cpp
// Function: mycwd[abi:cxx11]()
string mycwd() {

    char cwd[1000];
   if (getcwd(cwd, sizeof(cwd)) != NULL)
   {
        string ans=cwd;
       return ans;
   }
   else
    return "error";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x418(%rbp)
movq %rdi, %rax
movq %rax, -0x410(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x3f0(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x3180
cmpq $0x0, %rax
je 0x544d
movb $0x0, -0x3f1(%rbp)
leaq -0x3f2(%rbp), %rdi
movq %rdi, -0x420(%rbp)
callq 0x3520
movq -0x418(%rbp), %rdi
movq -0x420(%rbp), %rdx
leaq -0x3f0(%rbp), %rsi
callq 0x3f30
jmp 0x5401
leaq -0x3f2(%rbp), %rdi
callq 0x3340
movb $0x1, -0x3f1(%rbp)
testb $0x1, -0x3f1(%rbp)
jne 0x544b
jmp 0x543f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x400(%rbp)
movl %eax, -0x404(%rbp)
leaq -0x3f2(%rbp), %rdi
callq 0x3340
jmp 0x54ba
movq -0x418(%rbp), %rdi
callq 0x35b8
jmp 0x54aa
leaq -0x405(%rbp), %rdi
movq %rdi, -0x428(%rbp)
callq 0x3520
movq -0x418(%rbp), %rdi
movq -0x428(%rbp), %rdx
leaq 0x5be3(%rip), %rsi      # 0xb058
callq 0x3f30
jmp 0x547c
leaq -0x405(%rbp), %rdi
callq 0x3340
jmp 0x54aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x400(%rbp)
movl %eax, -0x404(%rbp)
leaq -0x405(%rbp), %rdi
callq 0x3340
jmp 0x54ba
movq -0x410(%rbp), %rax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
movq -0x400(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: aman-agrawal[P]Terminal-based-file-explorer/aman.cpp
// Function: copyfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void copyfile(string a,string b){       //copy files

    ifstream f1;
    f1.open(a);

    if(!f1){
        cout<<"error in read file";
        return;
    }
    ofstream f2;
    f2.open(b);


    if(!f2){
        cout<<"error";
        return;
    }

    char line[80];

    while(f1.good()) {
        f1.getline(line, 80);
        f2 << line;
        f2 << endl;
    }
    f1.close();
    f2.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4a0, %rsp            # imm = 0x4A0
movq %rdi, -0x488(%rbp)
movq %rsi, -0x498(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x490(%rbp)
callq 0x3380
movq -0x490(%rbp), %rdi
movq -0x488(%rbp), %rsi
movl $0x8, %edx
callq 0x3270
jmp 0x551e
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3150
movb %al, -0x499(%rbp)
jmp 0x553e
movb -0x499(%rbp), %al
testb $0x1, %al
jne 0x554a
jmp 0x5585
movq 0xaa7f(%rip), %rdi      # 0xffd0
leaq 0x5b06(%rip), %rsi      # 0xb05e
callq 0x32d0
jmp 0x555f
movl $0x1, -0x228(%rbp)
jmp 0x56c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x56db
leaq -0x428(%rbp), %rdi
callq 0x34f0
jmp 0x5593
movq -0x498(%rbp), %rsi
leaq -0x428(%rbp), %rdi
movl $0x10, %edx
callq 0x3170
jmp 0x55ad
movq -0x428(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x428(%rbp,%rax), %rdi
callq 0x3150
movb %al, -0x49a(%rbp)
jmp 0x55cd
movb -0x49a(%rbp), %al
testb $0x1, %al
jne 0x55d9
jmp 0x5620
movq 0xa9f0(%rip), %rdi      # 0xffd0
leaq 0x5a71(%rip), %rsi      # 0xb058
callq 0x32d0
jmp 0x55ee
movl $0x1, -0x228(%rbp)
jmp 0x56ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x428(%rbp), %rdi
callq 0x3440
jmp 0x56db
jmp 0x5622
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x34e0
movb %al, -0x49b(%rbp)
jmp 0x5642
movb -0x49b(%rbp), %al
testb $0x1, %al
jne 0x564e
jmp 0x5694
leaq -0x218(%rbp), %rdi
leaq -0x480(%rbp), %rsi
movl $0x50, %edx
callq 0x30c0
jmp 0x5668
leaq -0x428(%rbp), %rdi
leaq -0x480(%rbp), %rsi
callq 0x32d0
jmp 0x567d
movq 0xa92c(%rip), %rsi      # 0xffb0
leaq -0x428(%rbp), %rdi
callq 0x3320
jmp 0x5692
jmp 0x5622
leaq -0x218(%rbp), %rdi
callq 0x3080
jmp 0x56a2
leaq -0x428(%rbp), %rdi
callq 0x3420
jmp 0x56b0
movl $0x0, -0x228(%rbp)
leaq -0x428(%rbp), %rdi
callq 0x3440
leaq -0x218(%rbp), %rdi
callq 0x3090
addq $0x4a0, %rsp            # imm = 0x4A0
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x3090
movq -0x220(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: aman-agrawal[P]Terminal-based-file-explorer/aman.cpp
// Function: createfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void createfile(string a,string b)   //create file
{
    string name;
    string x;
    if(b==".")
        x=sonu+"/"+a;
    else
        x=sonu+"/"+b+"/"+a;

    ofstream f(x);
    f.close();
    cout << "file Created successfully";

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp            # imm = 0x340
movq %rdi, -0x338(%rbp)
movq %rsi, -0x330(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x33f0
leaq -0x50(%rbp), %rdi
callq 0x33f0
movq -0x330(%rbp), %rdi
leaq 0x59ad(%rip), %rsi      # 0xb0ee
callq 0x7c80
movb %al, -0x321(%rbp)
jmp 0x574e
movb -0x321(%rbp), %al
testb $0x1, %al
jne 0x575d
jmp 0x57e7
leaq 0xac24(%rip), %rsi      # 0x10388
leaq 0x5996(%rip), %rdx      # 0xb101
leaq -0xa0(%rbp), %rdi
callq 0x4030
jmp 0x5779
movq -0x338(%rbp), %rdx
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3fe0
jmp 0x5792
leaq -0x50(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x33b0
leaq -0x80(%rbp), %rdi
callq 0x35b8
leaq -0xa0(%rbp), %rdi
callq 0x35b8
jmp 0x58e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5960
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x35b8
jmp 0x5960
leaq 0xab9a(%rip), %rsi      # 0x10388
leaq 0x590c(%rip), %rdx      # 0xb101
leaq -0x120(%rbp), %rdi
callq 0x4030
jmp 0x5803
movq -0x330(%rbp), %rdx
leaq -0x100(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x3fe0
jmp 0x581f
leaq 0x58db(%rip), %rdx      # 0xb101
leaq -0xe0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x7cb0
jmp 0x583b
movq -0x338(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x3fe0
jmp 0x5857
leaq -0x50(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x33b0
leaq -0xc0(%rbp), %rdi
callq 0x35b8
leaq -0xe0(%rbp), %rdi
callq 0x35b8
leaq -0x100(%rbp), %rdi
callq 0x35b8
leaq -0x120(%rbp), %rdi
callq 0x35b8
jmp 0x58e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x58d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x58cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x35b8
leaq -0x100(%rbp), %rdi
callq 0x35b8
leaq -0x120(%rbp), %rdi
callq 0x35b8
jmp 0x5960
leaq -0x320(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x10, %edx
callq 0x3570
jmp 0x58fe
leaq -0x320(%rbp), %rdi
callq 0x3420
jmp 0x590c
movq 0xa6bd(%rip), %rdi      # 0xffd0
leaq 0x5757(%rip), %rsi      # 0xb071
callq 0x32d0
jmp 0x5921
leaq -0x320(%rbp), %rdi
callq 0x3440
leaq -0x50(%rbp), %rdi
callq 0x35b8
leaq -0x30(%rbp), %rdi
callq 0x35b8
addq $0x340, %rsp            # imm = 0x340
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x320(%rbp), %rdi
callq 0x3440
leaq -0x50(%rbp), %rdi
callq 0x35b8
leaq -0x30(%rbp), %rdi
callq 0x35b8
movq -0x58(%rbp), %rdi
callq 0x3510
nopl (%rax,%rax)
// File: aman-agrawal[P]Terminal-based-file-explorer/aman.cpp
// Function: createdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void createdir(string a,string b)   //create file
{
    string name;
    string x;
    if(b==".")
        x=sonu+"/"+a;
    else
        x=sonu+"/"+b+"/"+a;
    int y= mkdir(x.c_str(),0777);
    if(y==-1)
        cout<<"error, directory not created";
    else
        cout << "directory Created successfully";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x138(%rbp)
movq %rsi, -0x130(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x33f0
leaq -0x50(%rbp), %rdi
callq 0x33f0
movq -0x130(%rbp), %rdi
leaq 0x572d(%rip), %rsi      # 0xb0ee
callq 0x7c80
movb %al, -0x125(%rbp)
jmp 0x59ce
movb -0x125(%rbp), %al
testb $0x1, %al
jne 0x59dd
jmp 0x5a67
leaq 0xa9a4(%rip), %rsi      # 0x10388
leaq 0x5716(%rip), %rdx      # 0xb101
leaq -0xa0(%rbp), %rdi
callq 0x4030
jmp 0x59f9
movq -0x138(%rbp), %rdx
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3fe0
jmp 0x5a12
leaq -0x50(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x33b0
leaq -0x80(%rbp), %rdi
callq 0x35b8
leaq -0xa0(%rbp), %rdi
callq 0x35b8
jmp 0x5b67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5bd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x35b8
jmp 0x5bd5
leaq 0xa91a(%rip), %rsi      # 0x10388
leaq 0x568c(%rip), %rdx      # 0xb101
leaq -0x120(%rbp), %rdi
callq 0x4030
jmp 0x5a83
movq -0x130(%rbp), %rdx
leaq -0x100(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x3fe0
jmp 0x5a9f
leaq 0x565b(%rip), %rdx      # 0xb101
leaq -0xe0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x7cb0
jmp 0x5abb
movq -0x138(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x3fe0
jmp 0x5ad7
leaq -0x50(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x33b0
leaq -0xc0(%rbp), %rdi
callq 0x35b8
leaq -0xe0(%rbp), %rdi
callq 0x35b8
leaq -0x100(%rbp), %rdi
callq 0x35b8
leaq -0x120(%rbp), %rdi
callq 0x35b8
jmp 0x5b67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5b59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5b4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x35b8
leaq -0x100(%rbp), %rdi
callq 0x35b8
leaq -0x120(%rbp), %rdi
callq 0x35b8
jmp 0x5bd5
leaq -0x50(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3160
movl %eax, -0x124(%rbp)
cmpl $-0x1, -0x124(%rbp)
jne 0x5ba3
movq 0xa43d(%rip), %rdi      # 0xffd0
leaq 0x54f1(%rip), %rsi      # 0xb08b
callq 0x32d0
jmp 0x5ba1
jmp 0x5bba
movq 0xa426(%rip), %rdi      # 0xffd0
leaq 0x54f7(%rip), %rsi      # 0xb0a8
callq 0x32d0
jmp 0x5bb8
jmp 0x5bba
leaq -0x50(%rbp), %rdi
callq 0x35b8
leaq -0x30(%rbp), %rdi
callq 0x35b8
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x35b8
leaq -0x30(%rbp), %rdi
callq 0x35b8
movq -0x58(%rbp), %rdi
callq 0x3510
// File: aman-agrawal[P]Terminal-based-file-explorer/aman.cpp
// Function: renamefile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void renamefile(string a,string b)      //rename file
{
    string a1=sonu+"/"+a;
    string b1=sonu+"/"+b;
    int result= (!rename(a1.c_str(),b1.c_str()))  || (!rename(a.c_str(),b.c_str())) ; //converting string into const char*
    if (result == 1)
         cout<<"File successfully renamed";
    else
        cout<<"wrong input";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rsi, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xa770(%rip), %rsi      # 0x10388
leaq 0x54e2(%rip), %rdx      # 0xb101
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4030
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3fe0
jmp 0x5c48
leaq -0x50(%rbp), %rdi
callq 0x35b8
leaq 0xa730(%rip), %rsi      # 0x10388
leaq 0x54a2(%rip), %rdx      # 0xb101
leaq -0xa0(%rbp), %rdi
callq 0x4030
jmp 0x5c6d
movq -0xc0(%rbp), %rdx
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3fe0
jmp 0x5c86
leaq -0xa0(%rbp), %rdi
callq 0x35b8
leaq -0x30(%rbp), %rdi
callq 0x3110
movq %rax, -0xd0(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3110
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
callq 0x31e0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0xc1(%rbp)
je 0x5d05
movq -0xb0(%rbp), %rdi
callq 0x3110
movq -0xc0(%rbp), %rdi
movq %rax, -0xd8(%rbp)
callq 0x3110
movq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0x31e0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0xc1(%rbp)
movb -0xc1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xa4(%rbp)
cmpl $0x1, -0xa4(%rbp)
jne 0x5d8c
movq 0xa2aa(%rip), %rdi      # 0xffd0
leaq 0x539a(%rip), %rsi      # 0xb0c7
callq 0x32d0
jmp 0x5d34
jmp 0x5da3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x35b8
jmp 0x5dc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5dbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x35b8
jmp 0x5dbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x35b8
jmp 0x5dbe
movq 0xa23d(%rip), %rdi      # 0xffd0
leaq 0x5347(%rip), %rsi      # 0xb0e1
callq 0x32d0
jmp 0x5da1
jmp 0x5da3
leaq -0x80(%rbp), %rdi
callq 0x35b8
leaq -0x30(%rbp), %rdi
callq 0x35b8
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x35b8
movq -0x58(%rbp), %rdi
callq 0x3510
// File: aman-agrawal[P]Terminal-based-file-explorer/aman.cpp
// Function: deletedir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int deletedir(string dirpath)
{
    DIR *dir;
    struct dirent *data;
    char path[maxpath];

    const char *dirname=dirpath.c_str();

    dir = opendir(dirname);
    if (dir == NULL)
        return 0;   //wrong input

    while ((data = readdir(dir)) != NULL) {
        if (strcmp(data->d_name, ".") && strcmp(data->d_name, "..")) {
            snprintf(path, (size_t) maxpath, "%s/%s", dirname, data->d_name);
            if (data->d_type == DT_DIR) {
                char* path1= (char*)path;      //converting const char* into char*
                string dirpath1(path1);    //converting char* into string
                deletedir(dirpath1);
            }
            remove(path);
        }
    }
    remove(dirname) ; 
    closedir(dir);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x27b0, %rsp           # imm = 0x27B0
movq %rdi, -0x10(%rbp)
callq 0x3110
movq %rax, -0x2738(%rbp)
movq -0x2738(%rbp), %rdi
callq 0x3450
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5fce
movl $0x0, -0x4(%rbp)
jmp 0x617c
jmp 0x5fd0
movq -0x18(%rbp), %rdi
callq 0x3460
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6160
movq -0x20(%rbp), %rdi
addq $0x13, %rdi
leaq 0x50f8(%rip), %rsi      # 0xb0ee
callq 0x3410
cmpl $0x0, %eax
je 0x615b
movq -0x20(%rbp), %rdi
addq $0x13, %rdi
leaq 0x50da(%rip), %rsi      # 0xb0ed
callq 0x3410
cmpl $0x0, %eax
je 0x615b
leaq -0x2730(%rbp), %rdi
movq -0x2738(%rbp), %rcx
movq -0x20(%rbp), %r8
addq $0x13, %r8
movl $0x2710, %esi           # imm = 0x2710
leaq 0x50ad(%rip), %rdx      # 0xb0f0
movb $0x0, %al
callq 0x3490
movq -0x20(%rbp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
jne 0x614f
leaq -0x2730(%rbp), %rax
movq %rax, -0x2740(%rbp)
movq -0x2740(%rbp), %rax
movq %rax, -0x27a8(%rbp)
leaq -0x2761(%rbp), %rdi
movq %rdi, -0x27a0(%rbp)
callq 0x3520
movq -0x27a8(%rbp), %rsi
movq -0x27a0(%rbp), %rdx
leaq -0x2760(%rbp), %rdi
callq 0x3f30
jmp 0x60a6
leaq -0x2761(%rbp), %rdi
callq 0x3340
leaq -0x2798(%rbp), %rdi
leaq -0x2760(%rbp), %rsi
callq 0x3120
jmp 0x60c7
leaq -0x2798(%rbp), %rdi
callq 0x5f90
jmp 0x60d5
leaq -0x2798(%rbp), %rdi
callq 0x35b8
leaq -0x2760(%rbp), %rdi
callq 0x35b8
jmp 0x614f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2770(%rbp)
movl %eax, -0x2774(%rbp)
leaq -0x2761(%rbp), %rdi
callq 0x3340
jmp 0x6188
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2770(%rbp)
movl %eax, -0x2774(%rbp)
jmp 0x6141
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2770(%rbp)
movl %eax, -0x2774(%rbp)
leaq -0x2798(%rbp), %rdi
callq 0x35b8
leaq -0x2760(%rbp), %rdi
callq 0x35b8
jmp 0x6188
leaq -0x2730(%rbp), %rdi
callq 0x3540
jmp 0x5fd0
movq -0x2738(%rbp), %rdi
callq 0x3540
movq -0x18(%rbp), %rdi
callq 0x34a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x27b0, %rsp           # imm = 0x27B0
popq %rbp
retq
movq -0x2770(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: ashlall[P]StreamStats/ChiSquareExperiments/./DataGenerator.cpp
// Function: DataGenerator::get_stat_one_sample(int, double*, double*)
double DataGenerator::get_stat_one_sample(int num_buckets, double *upper_intervals, double *lower_intervals)
{
  if (num_buckets <= 0)
    throw ParameterError();
  double expected = (double)stream_size / num_buckets;
  double chi_squared = 0;
  for (int i = 1; i <= num_buckets; i++)
  { 
    double observed = 0;
    for (int j = 0; j < stream_size; j++)
    {
      if (stream[j] <= upper_intervals[i] && stream[j] > lower_intervals[i])
	observed++;
    }
    chi_squared += (observed - expected) * (observed - expected) / expected;
  }
  return chi_squared;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x2842
movl $0x1, %edi
callq 0x20c0
movq %rax, %rdi
leaq 0x17417(%rip), %rsi     # 0x19c50
xorl %eax, %eax
movl %eax, %edx
callq 0x22f0
movq -0x50(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x2925
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x50(%rbp), %rcx
movl -0x44(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x28f0
movq -0x50(%rbp), %rax
movq (%rax), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x28e3
movq -0x50(%rbp), %rax
movq (%rax), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x28e3
movsd 0xf72f(%rip), %xmm0     # 0x12008
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x28e5
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2883
movsd -0x40(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
subsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm0
divsd -0x28(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2868
movsd -0x30(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
// File: ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/../Quantiles/QuantileSketch.h
// Function: QuantileSketch::reverseQuantile(double, int)
double QuantileSketch::reverseQuantile(double r, int n)
{
  int lo=0, hi= n;
  while (lo < hi)
  {
    int mid = (lo+hi)/2;
    double value = getQuantile(((double)mid)/n);
    if (value < r)
      lo = mid+1;
    else
      hi = mid;
  }
  return lo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2be2
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
cvtsi2sdl -0x20(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
divsd %xmm1, %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2bda
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2be0
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2b89
cvtsi2sdl -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/../Quantiles/GK.cpp
// Function: GK::GK(int)
GK::GK(int maxTuples)
{
	num_tuples=0;
	num_observations=0;
	max=maxTuples;
	summary=new Tuple*[maxTuples];
	for (int i = 0; i < max; i++)
		summary[i] = NULL;
	stream_size =0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x8920
movq -0x30(%rbp), %rax
leaq 0x17059(%rip), %rcx     # 0x19c70
movq %rcx, (%rax)
movl $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x2030
movq %rax, -0x28(%rbp)
jmp 0x2c54
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x2ca9
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2c67
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x9600
jmp 0x2cbb
movq -0x30(%rbp), %rax
movq $0x0, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/../Quantiles/GK.cpp
// Function: GK::insert(double)
void GK::insert(double val)
{ 
	stream_size +=1; 
	int index= find_index(val);
	if(summary[index]==NULL)
	{
		insert_tuple(new Tuple(val),index); 
	}
	else
	{
		double store=summary[index]->g+summary[index]->delta-1; 
		insert_tuple(new Tuple(val,1.0,store),index);
	}
	if(num_tuples==max)
		delete_merge();
	num_observations++;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x28(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x28(%rdi)
movsd -0x10(%rbp), %xmm0
callq 0x2ec0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x2df6
movl $0x18, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x8940
jmp 0x2dc7
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %edx
callq 0x2f30
jmp 0x2e7d
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x2ea8
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x8(%rax), %xmm0
movsd 0x10(%rax), %xmm1
addsd %xmm1, %xmm0
movsd 0xf1ec(%rip), %xmm1     # 0x12008
movsd %xmm1, -0x50(%rbp)
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x18, %edi
callq 0x21c0
movsd -0x50(%rbp), %xmm1
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
callq 0x8980
jmp 0x2e54
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %edx
callq 0x2f30
jmp 0x2e7d
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x2ea8
movq -0x38(%rbp), %rcx
movl 0x18(%rcx), %eax
cmpl 0x8(%rcx), %eax
jne 0x2e92
movq -0x38(%rbp), %rdi
callq 0x2fb0
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/../Quantiles/GK.cpp
// Function: GK::find_index(double)
int GK::find_index(double val)
{
	int high= num_tuples;int low=-1,mid;
	while(high-low >1)
	{
		mid=(high+low)/2;
		if(summary[mid]->v >val)
			high=mid;
		else
			low=mid;
	}
	return high;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl $0x1, %eax
jle 0x2f2b
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x2f23
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x2f29
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x2ee2
movl -0x14(%rbp), %eax
popq %rbp
retq
// File: ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/../Quantiles/GK.cpp
// Function: GK::insert_tuple(Tuple*, int)
void GK::insert_tuple(Tuple* t,int index)
{	
	/*int destpos=num_tuples;
	int srcpos=num_tuples-1;
	for(int i=0;i<num_tuples-index;i++)
	{	
		summary[destpos]=summary[srcpos];
		srcpos--;
		destpos--;
	}*/
	
	int size_of_pointer= sizeof(summary[0]);
        int total_size=size_of_pointer * (num_tuples-index);
        memmove(&(summary[index+1]),&(summary[index]),total_size);
	
	summary[index]=t;
	num_tuples++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x8, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movl 0x18(%rax), %edx
subl -0x14(%rbp), %edx
imull %edx, %ecx
movl %ecx, -0x1c(%rbp)
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
movq 0x10(%rax), %rsi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x22a0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x10(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/../Quantiles/GK.cpp
// Function: GK::delete_merge()
void GK::delete_merge()
{	
	int leastIndex = 0;
	long leastFull= LLONG_MAX;
        for (int i = 1; i <num_tuples - 1; i++) 
        {
            long f = summary[i]->g + summary[i + 1]->g+summary[i + 1]->delta;   
            if ((summary[i]->delta >=summary[i + 1]->delta)
                    && (f < leastFull)) 
            {
                leastFull = f;
                leastIndex = i;
            }
        }
        if (leastIndex > 0) 
            delete_tuple(leastIndex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0xc(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3090
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsd 0x8(%rcx), %xmm0
movq 0x10(%rax), %rcx
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
addsd 0x8(%rcx), %xmm0
movq 0x10(%rax), %rcx
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
addsd 0x10(%rcx), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsd 0x10(%rcx), %xmm0
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
ucomisd 0x10(%rax), %xmm0
jb 0x3080
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x3080
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x3082
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2fe0
cmpl $0x0, -0xc(%rbp)
jle 0x30a2
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x30b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/../Quantiles/GK.cpp
// Function: GK::delete_tuple(int)
void GK::delete_tuple(int index)
{	
        Tuple *hold  = summary[index];
	summary[index] = new Tuple(summary[index + 1]->v,
                summary[index]->g + summary[index + 1]->g,
                summary[index + 1]->delta);
        delete hold;
	delete summary[index+1];
        int size_of_pointer= sizeof(summary[0]);
        int total_size=size_of_pointer * (num_tuples-index-2);
        memmove(&(summary[index+1]),&(summary[index+2]),total_size);
	summary[num_tuples-1]=NULL;
	num_tuples--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl $0x18, %edi
callq 0x21c0
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rcx
movq 0x8(%rax,%rdx,8), %rax
movsd 0x8(%rcx), %xmm1
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm2
addsd %xmm2, %xmm1
movsd 0x10(%rax), %xmm2
callq 0x8980
jmp 0x311e
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x3149
movq -0x48(%rbp), %rdi
callq 0x21a0
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x3171
movq -0x50(%rbp), %rdi
callq 0x21a0
movq -0x40(%rbp), %rax
movl $0x8, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl 0x18(%rax), %edx
subl -0xc(%rbp), %edx
subl $0x2, %edx
imull %edx, %ecx
movl %ecx, -0x2c(%rbp)
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
movq 0x10(%rax), %rsi
movl -0xc(%rbp), %eax
addl $0x2, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movslq -0x2c(%rbp), %rdx
callq 0x22a0
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
movl 0x18(%rax), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq $0x0, (%rcx,%rdx,8)
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
movq -0x20(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/../Quantiles/GK.cpp
// Function: GK::getQuantile(double)
double GK::getQuantile(double quant)
{
	long rank= (long) ceil(quant* num_observations);
	long current_rank=0;
	for (int i = 0; i < num_tuples - 1; i++)
	{
		current_rank +=summary[i]->g;
		if ((current_rank +summary[i + 1]->g) > rank)
            	    return summary[i]->v;
        }
        return summary[num_tuples - 1]->v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsi2sdq 0x20(%rax), %xmm1
mulsd %xmm1, %xmm0
callq 0x2070
cvttsd2si %xmm0, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x32e1
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsd 0x8(%rcx), %xmm1
cvtsi2sdq -0x28(%rbp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, -0x28(%rbp)
cvtsi2sdq -0x28(%rbp), %xmm0
movq 0x10(%rax), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
addsd 0x8(%rax), %xmm0
cvtsi2sdq -0x20(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x32d1
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x32ff
jmp 0x32d3
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3255
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rax
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/../Quantiles/ReservoirSampling.cpp
// Function: ReservoirSampling::copy(ReservoirSampling const&)
void ReservoirSampling::copy(const ReservoirSampling& other)
{
  sample_size = other.sample_size;
  stream_size = other.stream_size;
  array = new double[sample_size];
  for (int i = 0; i < sample_size; i++)
    array[i] = other.array[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movslq 0xc(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x349c
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3463
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ashlall[P]StreamStats/ChiSquareExperiments/./../SourceCode/ChiSquare/../Quantiles/ReservoirSampling.cpp
// Function: ReservoirSampling::insert(double)
void ReservoirSampling::insert(double value)
{
  stream_size += 1; //incrementing the size of the stream as a new element is inserted
  if (stream_size <= sample_size) //Checking if stream size is less than random sample size
    array[stream_size - 1] = value;
  else if ((rand() % stream_size + 1) <= sample_size)
    array[(rand() % sample_size)] = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x8(%rcx)
movl 0x8(%rcx), %eax
cmpl 0xc(%rcx), %eax
jg 0x3597
movq -0x18(%rbp), %rcx
movsd -0x10(%rbp), %xmm0
movq 0x10(%rcx), %rax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x35e6
callq 0x2080
movq -0x18(%rbp), %rcx
cltd
idivl 0x8(%rcx)
movq -0x18(%rbp), %rax
addl $0x1, %edx
cmpl 0xc(%rax), %edx
jg 0x35e4
movq -0x18(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x2080
movq -0x18(%rbp), %rcx
movsd -0x28(%rbp), %xmm0
cltd
idivl 0xc(%rcx)
movq -0x20(%rbp), %rax
movslq %edx, %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x35e6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)