LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: pxzwxx[P]SynBS/./share/log.cpp
// Function: Log::init(char const*, int)
void Log::init(const char *file_name, int max_queue_size) {
    m_max_task = max_queue_size;
    memcpy(m_log_name, file_name, strlen(file_name) + 1);
    m_fp = fopen(file_name, "a");  //追加模式日志文件   
    m_fullBuff.setNum(0);           //设置信号量值
    m_emptyBuff.setNum(m_max_task); //设置信号量值
    log_thread = std::thread(&Log::async_write_log, this);
    log_thread.detach();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
addq $0x10, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3180
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
incq %rdx
callq 0x32b0
movq -0x10(%rbp), %rdi
leaq 0x18e0(%rip), %rsi      # 0xf6c3
callq 0x33e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x9506(%rip), %rdi      # 0x17300
xorl %esi, %esi
callq 0xe0e0
movq -0x40(%rbp), %rax
movl (%rax), %esi
leaq 0x9552(%rip), %rdi      # 0x17360
callq 0xe0e0
movq -0x40(%rbp), %rax
leaq -0x16e(%rip), %rcx      # 0xdcb0
movq %rcx, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xe100
movq -0x40(%rbp), %rdi
addq $0x90, %rdi
leaq -0x20(%rbp), %rsi
callq 0xe1c0
leaq -0x20(%rbp), %rdi
callq 0xc9e0
movq -0x40(%rbp), %rdi
addq $0x90, %rdi
callq 0x34b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pxzwxx[P]SynBS/./share/log.cpp
// Function: Log::destory()
void Log::destory() {
    isRun = false;
    if(m_log) {
        std::unique_lock<std::mutex> ulock(m_mutex);
        if(m_fp) {
            fflush(m_fp);
            fclose(m_fp);
        }
        if(m_log) delete m_log;
        m_max_task = false;
        m_log = NULL;
        m_fp = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, 0x98(%rax)
cmpq $0x0, 0x9455(%rip)      # 0x172f8
je 0xdf55
leaq -0x18(%rbp), %rdi
leaq 0x941c(%rip), %rsi      # 0x172d0
callq 0x5660
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdefb
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x33d0
jmp 0xded3
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3310
jmp 0xdee2
jmp 0xdefb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x56a0
jmp 0xdf5b
cmpq $0x0, 0x93f5(%rip)      # 0x172f8
je 0xdf2f
movq 0x93ec(%rip), %rax      # 0x172f8
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xdf2d
movq -0x38(%rbp), %rdi
callq 0xe200
movq -0x38(%rbp), %rdi
movl $0xa0, %esi
callq 0x3340
jmp 0xdf2f
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, 0x93b4(%rip) # 0x172f8
movq $0x0, 0x8(%rax)
leaq -0x18(%rbp), %rdi
callq 0x56a0
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
// File: ruippeixotog[P]algo-lib/mod-ops.cpp
// Function: mfact(long long)
ll mfact(ll a) {
  if(a >= MOD) return 0;
  while(a >= _mfactMem.size())
    _mfactMem.push_back(mmul(_mfactMem.size(), _mfactMem.back()));
  return _mfactMem[a];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x3b9aca07, 0x18(%rsp) # imm = 0x3B9ACA07
jl 0x139f
movq $0x0, 0x20(%rsp)
jmp 0x141d
jmp 0x13a1
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x3cde(%rip), %rdi      # 0x5090
callq 0x1a20
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x1404
leaq 0x3cc5(%rip), %rdi      # 0x5090
callq 0x1a20
movq %rax, (%rsp)
leaq 0x3cb5(%rip), %rdi      # 0x5090
callq 0x1a70
movq (%rsp), %rdi
movq (%rax), %rsi
callq 0x18f0
movq %rax, 0x10(%rsp)
leaq 0x3c98(%rip), %rdi      # 0x5090
leaq 0x10(%rsp), %rsi
callq 0x1a40
jmp 0x13a1
movq 0x18(%rsp), %rsi
leaq 0x3c80(%rip), %rdi      # 0x5090
callq 0x1ab0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ruippeixotog[P]algo-lib/mod-ops.cpp
// Function: mcomb(long long, long long)
ll mcomb(ll n, ll k) {
  if (n == 0 && k == 0) return 1;
  ll ni = n % MOD, ki = k % MOD;
  if (ni < ki) return 0;
  ll comb = mmul(mfact(ni), mmul(minv(mfact(ki)), minv(mfact(ni - ki))));
  return mcomb(n / MOD, k / MOD) * comb;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x145c
cmpq $0x0, 0x30(%rsp)
jne 0x145c
movq $0x1, 0x40(%rsp)
jmp 0x152e
movq 0x38(%rsp), %rax
movl $0x3b9aca07, %ecx       # imm = 0x3B9ACA07
cqto
idivq %rcx
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl $0x3b9aca07, %ecx       # imm = 0x3B9ACA07
cqto
idivq %rcx
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jge 0x149e
movq $0x0, 0x40(%rsp)
jmp 0x152e
movq 0x28(%rsp), %rdi
callq 0x1380
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1380
movq %rax, %rdi
callq 0x1320
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
subq 0x20(%rsp), %rdi
callq 0x1380
movq %rax, %rdi
callq 0x1320
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x18f0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x18f0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movl $0x3b9aca07, %ecx       # imm = 0x3B9ACA07
cqto
idivq %rcx
movq %rax, %rdi
movq 0x30(%rsp), %rax
movl $0x3b9aca07, %ecx       # imm = 0x3B9ACA07
cqto
idivq %rcx
movq %rax, %rsi
callq 0x1430
imulq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: ruippeixotog[P]algo-lib/miller-rabin.cpp
// Function: isPrime(long long, int)
bool isPrime(ll n, int bases = 10) {
  if (n == 2 || n == 3) return true;
  if (n <= 1 || n % 2 == 0) return false;

  // Write (n - 1) as (d * 2^s) by factoring powers of 2 from (n - 1)
  int s = 0;
  for (ll m = n - 1; m % 2 == 0; ++s, m /= 2);
  ll d = (n - 1) / (1 << s);

  for(int i = 0; i < bases; i++) {
    ll a = randBetween(2, n - 2);
    ll x = mpow(a, d, n);

    if (x == 1 || x == n - 1)
      continue;

    bool found = false;
    for(int r = 1; r <= s - 1; r++) {
      x = mpow(x, 2, n);
      if(x == 1) return false;
      if(x == n - 1) { found = true; break; }
    }
    if(!found) return false;
  }
  return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
cmpq $0x2, 0x38(%rsp)
je 0x12bd
cmpq $0x3, 0x38(%rsp)
jne 0x12c7
movb $0x1, 0x47(%rsp)
jmp 0x1451
cmpq $0x1, 0x38(%rsp)
jle 0x12e4
movq 0x38(%rsp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x12ee
movb $0x0, 0x47(%rsp)
jmp 0x1451
movl $0x0, 0x30(%rsp)
movq 0x38(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x133c
jmp 0x131b
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, 0x28(%rsp)
jmp 0x1304
movq 0x38(%rsp), %rax
subq $0x1, %rax
movl 0x30(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
cqto
idivq %rcx
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x144c
movq 0x38(%rsp), %rsi
subq $0x2, %rsi
movl $0x2, %edi
callq 0x1230
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x1170
movq %rax, 0x8(%rsp)
cmpq $0x1, 0x8(%rsp)
je 0x13c1
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x13c3
jmp 0x143c
movb $0x0, 0x7(%rsp)
movl $0x1, (%rsp)
movl (%rsp), %eax
movl 0x30(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x142c
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rdx
movl $0x2, %esi
callq 0x1170
movq %rax, 0x8(%rsp)
cmpq $0x1, 0x8(%rsp)
jne 0x1405
movb $0x0, 0x47(%rsp)
jmp 0x1451
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x141f
movb $0x1, 0x7(%rsp)
jmp 0x142c
jmp 0x1421
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x13cf
testb $0x1, 0x7(%rsp)
jne 0x143a
movb $0x0, 0x47(%rsp)
jmp 0x1451
jmp 0x143c
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1367
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: ruippeixotog[P]algo-lib/miller-rabin.cpp
// Function: main
int main() {
  srand(time(NULL));

  printf("2 is prime: %d (expected 1)\n", isPrime(2));
  printf("3 is prime: %d (expected 1)\n", isPrime(3));
  printf("4 is prime: %d (expected 0)\n", isPrime(4));
  printf("5 is prime: %d (expected 1)\n", isPrime(5));

  printf("45896223 is prime: %d (expected 0)\n", isPrime(45896223));
  printf("219567251 is prime: %d (expected 1)\n", isPrime(219567251));
  printf("213587648531 is prime: %d (expected 0)\n", isPrime(213587648531L));
  printf("3000011921 is prime: %d (expected 1)\n", isPrime(3000011921L));

  return 0;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1050
movl %eax, %edi
callq 0x1060
movl $0x2, %edi
movl $0xa, %esi
callq 0x12a0
andb $0x1, %al
movzbl %al, %esi
leaq 0xb70(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl $0x3, %edi
movl $0xa, %esi
callq 0x12a0
andb $0x1, %al
movzbl %al, %esi
leaq 0xb6b(%rip), %rdi       # 0x2021
movb $0x0, %al
callq 0x1030
movl $0x4, %edi
movl $0xa, %esi
callq 0x12a0
andb $0x1, %al
movzbl %al, %esi
leaq 0xb66(%rip), %rdi       # 0x203e
movb $0x0, %al
callq 0x1030
movl $0x5, %edi
movl $0xa, %esi
callq 0x12a0
andb $0x1, %al
movzbl %al, %esi
leaq 0xb61(%rip), %rdi       # 0x205b
movb $0x0, %al
callq 0x1030
movl $0x2bc521f, %edi        # imm = 0x2BC521F
movl $0xa, %esi
callq 0x12a0
andb $0x1, %al
movzbl %al, %esi
leaq 0xb5c(%rip), %rdi       # 0x2078
movb $0x0, %al
callq 0x1030
movl $0xd165493, %edi        # imm = 0xD165493
movl $0xa, %esi
callq 0x12a0
andb $0x1, %al
movzbl %al, %esi
leaq 0xb5e(%rip), %rdi       # 0x209c
movb $0x0, %al
callq 0x1030
movabsq $0x31bad0e013, %rdi     # imm = 0x31BAD0E013
movl $0xa, %esi
callq 0x12a0
andb $0x1, %al
movzbl %al, %esi
leaq 0xb5c(%rip), %rdi       # 0x20c1
movb $0x0, %al
callq 0x1030
movl $0xb2d08c91, %edi       # imm = 0xB2D08C91
movl $0xa, %esi
callq 0x12a0
andb $0x1, %al
movzbl %al, %esi
leaq 0xb62(%rip), %rdi       # 0x20e9
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Matan-Vinkler[P]Basic-File-System/myfs.cpp
// Function: MyFs::MyFs(BlockDeviceSimulator*)
MyFs::MyFs(BlockDeviceSimulator *blkdevsim_):blkdevsim(blkdevsim_) {
	struct myfs_header header;
	blkdevsim->read(0, sizeof(header), (char *)&header);

	if (strncmp(header.magic, MYFS_MAGIC, sizeof(header.magic)) != 0 ||
	    (header.version != CURR_VERSION)) {
		std::cout << "Did not find myfs instance on blkdev" << std::endl;
		std::cout << "Creating..." << std::endl;
		format();
		std::cout << "Finished!" << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x4ce0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
movl $0x5, %edx
leaq -0x15(%rbp), %rcx
callq 0x4330
jmp 0x4795
leaq -0x15(%rbp), %rdi
movq 0x8ae0(%rip), %rsi      # 0xd280
movl $0x4, %edx
callq 0x3150
cmpl $0x0, %eax
jne 0x47bc
movzbl -0x11(%rbp), %eax
cmpl $0x3, %eax
je 0x4861
movq 0x87fd(%rip), %rdi      # 0xcfc0
leaq 0x489d(%rip), %rsi      # 0x9067
callq 0x3290
movq %rax, -0x40(%rbp)
jmp 0x47d5
movq -0x40(%rbp), %rdi
movq 0x87c0(%rip), %rsi      # 0xcfa0
callq 0x32c0
jmp 0x47e7
movq 0x87d2(%rip), %rdi      # 0xcfc0
leaq 0x4897(%rip), %rsi      # 0x908c
callq 0x3290
movq %rax, -0x48(%rbp)
jmp 0x4800
movq -0x48(%rbp), %rdi
movq 0x8795(%rip), %rsi      # 0xcfa0
callq 0x32c0
jmp 0x4812
movq -0x30(%rbp), %rdi
callq 0x4870
jmp 0x481d
movq 0x879c(%rip), %rdi      # 0xcfc0
leaq 0x486d(%rip), %rsi      # 0x9098
callq 0x3290
movq %rax, -0x50(%rbp)
jmp 0x4836
movq -0x50(%rbp), %rdi
movq 0x875f(%rip), %rsi      # 0xcfa0
callq 0x32c0
jmp 0x4848
jmp 0x4861
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4d00
jmp 0x4867
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3430
// File: Matan-Vinkler[P]Basic-File-System/myfs.cpp
// Function: MyFs::format()
void MyFs::format() {

	// put the header in place
	struct myfs_header header;
	strncpy(header.magic, MYFS_MAGIC, sizeof(header.magic));
	header.version = CURR_VERSION;
	blkdevsim->write(0, sizeof(header), (const char*)&header);

	// TODO: put your format code here
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0xd(%rbp), %rdi
movq 0x89f1(%rip), %rsi      # 0xd280
movl $0x4, %edx
callq 0x3170
movq -0x18(%rbp), %rax
movb $0x3, -0x9(%rbp)
movq (%rax), %rdi
xorl %esi, %esi
movl $0x5, %edx
leaq -0xd(%rbp), %rcx
callq 0x4370
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Matan-Vinkler[P]Basic-File-System/myfs.cpp
// Function: MyFs::create_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void MyFs::create_file(std::string path_str, bool directory) {
	struct dir_list_entry entry;
	entry.name = path_str;
	entry.is_dir = directory;
	entry.file_size = 0;

	this->list.push_back(entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x78(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4d60
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3030
jmp 0x4905
movq -0x88(%rbp), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, -0x40(%rbp)
movl $0x0, -0x3c(%rbp)
addq $0x8, %rdi
leaq -0x60(%rbp), %rsi
callq 0x4d90
jmp 0x492a
leaq -0x60(%rbp), %rdi
callq 0x4e00
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4e00
movq -0x68(%rbp), %rdi
callq 0x3430
nopw (%rax,%rax)
// File: Matan-Vinkler[P]Basic-File-System/myfs.cpp
// Function: MyFs::get_content(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string MyFs::get_content(std::string path_str) {
	for(int i = 0; i < (int)this->list.size(); i++)
	{
		if(this->list[i].name == path_str)
		{
			return this->list[i].content;
		}
	}

	throw std::runtime_error("No such file or directory");
	return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x54(%rbp)
addq $0x8, %rdi
callq 0x4e30
movq %rax, %rcx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x4a0a
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4ef0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x4e60
testb $0x1, %al
jne 0x49d2
jmp 0x49fd
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4ef0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq $0x28, %rsi
callq 0x3120
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
jmp 0x49ff
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4992
movl $0x10, %edi
callq 0x3160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x467d(%rip), %rsi      # 0x90a2
callq 0x30f0
jmp 0x4a2c
movq -0x60(%rbp), %rdi
movq 0x85b9(%rip), %rsi      # 0xcff0
movq 0x857a(%rip), %rdx      # 0xcfb8
callq 0x3400
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31f0
movq -0x28(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: Matan-Vinkler[P]Basic-File-System/myfs.cpp
// Function: MyFs::set_content(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 MyFs::set_content(std::string path_str, std::string content) {
	for(int i = 0; i < (int)this->list.size(); i++)
	{
		if(this->list[i].name == path_str)
		{
			this->list[i].content = content + '\26';
			this->list[i].file_size = content.size();
			return;
		}
	}

	throw std::runtime_error("No such file or directory");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x58(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x6c(%rbp)
addq $0x8, %rdi
callq 0x4e30
movq %rax, %rcx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jge 0x4b5a
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4ef0
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x4e60
testb $0x1, %al
jne 0x4ae2
jmp 0x4b4a
movq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x16, %edx
callq 0x4f10
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4ef0
movq %rax, %rdi
addq $0x28, %rdi
leaq -0x40(%rbp), %rsi
callq 0x3330
leaq -0x40(%rbp), %rdi
callq 0x34d8
movq -0x60(%rbp), %rdi
callq 0x31d0
movq -0x58(%rbp), %rdi
movl %eax, -0x70(%rbp)
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4ef0
movl -0x70(%rbp), %ecx
movl %ecx, 0x24(%rax)
addq $0x80, %rsp
popq %rbp
retq
jmp 0x4b4c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4a9e
movl $0x10, %edi
callq 0x3160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
leaq 0x452d(%rip), %rsi      # 0x90a2
callq 0x30f0
jmp 0x4b7c
movq -0x78(%rbp), %rdi
movq 0x8469(%rip), %rsi      # 0xcff0
movq 0x842a(%rip), %rdx      # 0xcfb8
callq 0x3400
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x31f0
movq -0x48(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: Matan-Vinkler[P]Basic-File-System/myfs.cpp
// Function: MyFs::list_dir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
MyFs::dir_list MyFs::list_dir(std::string path_str) {
	MyFs::dir_list ans;
	for(int i = 0; i < (int)this->list.size(); i++)
	{
		if(strncmp(this->list[i].name.c_str(), path_str.c_str(), path_str.size()))
		{
			ans.push_back(this->list[i]);
		}
	}

	return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x4ce0
movl $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x54(%rbp)
addq $0x8, %rdi
callq 0x4e30
movq %rax, %rcx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x4cac
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movslq -0x20(%rbp), %rsi
callq 0x4ef0
movq %rax, %rdi
callq 0x3110
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x3110
movq -0x50(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x31d0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x3150
cmpl $0x0, %eax
je 0x4c9c
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movslq -0x20(%rbp), %rsi
callq 0x4ef0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x4d90
jmp 0x4c83
jmp 0x4c9c
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4d00
jmp 0x4cc9
jmp 0x4c9e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4bfb
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x4cbf
movq -0x48(%rbp), %rdi
callq 0x4d00
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Matan-Vinkler[P]Basic-File-System/myfs_main.cpp
// Function: split_cmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<std::string> split_cmd(std::string cmd) {
	std::stringstream ss(cmd);
	std::string part;
	std::vector<std::string> ans;

	while (std::getline(ss, part, ' '))
		ans.push_back(part);

	return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rsi, -0x1e0(%rbp)
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x72b0
movq -0x1e0(%rbp), %rsi
movl %eax, %edx
leaq -0x198(%rbp), %rdi
callq 0x33c0
leaq -0x1b8(%rbp), %rdi
callq 0x3380
movq -0x1d8(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
callq 0x72d0
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
movl $0x20, %edx
callq 0x3470
movq %rax, -0x1f0(%rbp)
jmp 0x5d1f
movq -0x1f0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3350
movb %al, -0x1f1(%rbp)
jmp 0x5d3d
movb -0x1f1(%rbp), %al
testb $0x1, %al
jne 0x5d49
jmp 0x5d98
movq -0x1d8(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x72f0
jmp 0x5d5e
jmp 0x5cfe
movq -0x1d8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
callq 0x7360
leaq -0x1b8(%rbp), %rdi
callq 0x34d8
leaq -0x198(%rbp), %rdi
callq 0x3210
jmp 0x5ddc
movb $0x1, -0x1b9(%rbp)
testb $0x1, -0x1b9(%rbp)
jne 0x5db4
movq -0x1d8(%rbp), %rdi
callq 0x7360
leaq -0x1b8(%rbp), %rdi
callq 0x34d8
leaq -0x198(%rbp), %rdi
callq 0x3210
movq -0x1e8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x3430
nopl (%rax,%rax)
// File: gdaws[P]process-monitor/monitor.cpp
// Function: create_process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
static void create_process(const std::string & filename, 
                           const std::vector<std::string> & arguments)
{
    pid_t child_pid = fork();
    if(child_pid == -1) exit(1);
    
    if(child_pid == 0)
    {
        char ** argv = new char *[arguments.size() + 2];
        for(size_t i = 0; i < arguments.size(); i++)
            argv[i] = const_cast<char *>(arguments[i].c_str());
        argv[arguments.size()] = NULL;
        if(execve(filename.c_str(), argv, environ) == -1) exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x30a0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x3bd8
movl $0x1, %edi
callq 0x3330
cmpl $0x0, -0x14(%rbp)
jne 0x3cbb
movq -0x10(%rbp), %rdi
callq 0x3d50
addq $0x2, %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d50
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x3c6b
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3fa0
movq %rax, %rdi
callq 0x30e0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3c1c
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d50
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movq 0x13326(%rip), %rax     # 0x16fc8
movq (%rax), %rdx
callq 0x3420
cmpl $-0x1, %eax
jne 0x3cb9
movl $0x1, %edi
callq 0x3330
jmp 0x3cbb
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gdaws[P]process-monitor/program_arguments.cpp
// Function: program_arguments::parser::add_option(char, char const*, char const*, char const*, program_arguments::basic_binder*)
parser & parser::add_option(const char     name, 
                            const char *   verbose_name, 
                            const char *   value_name, 
                            const char *   description,
                            basic_binder * binding)
{
    option opt;
    opt.name = name;
    opt.verbose_name = verbose_name;
    opt.value_name = value_name;
    opt.description = description;
    opt.binding = binding;
    
    if(opt.name != '\0') m_names[opt.name] = opt;
    if(opt.verbose_name) m_verbose_names[opt.verbose_name] = opt;
    
    m_groups.back().options.push_back(opt);
    
    std::sort(m_groups.back().options.begin(), 
              m_groups.back().options.end(),
              &parser::compare_option);
    
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movsbl -0x58(%rbp), %eax
cmpl $0x0, %eax
je 0x4450
movq -0xa8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6980
movq %rax, %rdi
leaq -0x58(%rbp), %rsi
movl $0x28, %edx
callq 0x31f0
cmpq $0x0, -0x50(%rbp)
je 0x4520
movq -0xa8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0xc0(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3440
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x6b40
jmp 0x44a1
movq -0xc0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6a60
movq %rax, -0xc8(%rbp)
jmp 0x44ba
movq -0xc8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x28, %edx
callq 0x31f0
leaq -0x78(%rbp), %rdi
callq 0x3160
leaq -0x79(%rbp), %rdi
callq 0x32e0
jmp 0x4520
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x4512
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3160
leaq -0x79(%rbp), %rdi
callq 0x32e0
jmp 0x45b0
movq -0xa8(%rbp), %rdi
addq $0x60, %rdi
callq 0x6bf0
movq %rax, %rdi
addq $0x8, %rdi
leaq -0x58(%rbp), %rsi
callq 0x6c30
movq -0xa8(%rbp), %rdi
addq $0x60, %rdi
callq 0x6bf0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x6cf0
movq -0xa8(%rbp), %rdi
movq %rax, -0x98(%rbp)
addq $0x60, %rdi
callq 0x6bf0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x6d20
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
leaq 0x25(%rip), %rdx        # 0x45c0
callq 0x6ca0
movq -0xa8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x3430
nopl (%rax)
// File: gdaws[P]process-monitor/program_arguments.cpp
// Function: program_arguments::parser::add_argument(char const*, program_arguments::basic_binder*)
parser & parser::add_argument(const char * value_name, basic_binder * binding)
{
    if(m_argument_repeat_last) m_argument_repeat_last++;

    argument arg;
    arg.value_name = value_name;
    arg.binding = binding;
    m_arguments.push_back(arg);
    
    m_next_argument = m_arguments.begin();
    
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x98(%rax)
je 0x4858
movq -0x38(%rbp), %rax
movl 0x98(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x98(%rax)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x78, %rdi
leaq -0x28(%rbp), %rsi
callq 0x6d50
movq -0x38(%rbp), %rdi
addq $0x78, %rdi
callq 0x6dc0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x90(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<bool>::resize(unsigned int)
void vector<bool>::resize(typename vector<bool>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x129d
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x3550
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<signed char>::resize(unsigned int)
void vector<signed char>::resize(typename vector<signed char>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x12dd
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x35d0
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned char>::resize(unsigned int)
void vector<unsigned char>::resize(typename vector<unsigned char>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x131d
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x3650
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<char>::resize(unsigned int)
void vector<char>::resize(typename vector<char>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x135d
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x36d0
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<short>::resize(unsigned int)
void vector<short int>::resize(typename vector<short int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x139d
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x3750
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<int>::resize(unsigned int)
void vector<int>::resize(typename vector<int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x141d
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x3870
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned int>::resize(unsigned int)
void vector<unsigned int>::resize(typename vector<unsigned int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x145d
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x3900
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long>::resize(unsigned int)
void vector<long int>::resize(typename vector<long int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x149d
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x3990
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned long>::resize(unsigned int)
void vector<unsigned long int>::resize(typename vector<unsigned long int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x14dd
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x3a20
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long long>::resize(unsigned int)
void vector<long long int>::resize(typename vector<long long int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x151d
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x3ab0
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned long long>::resize(unsigned int)
void vector<unsigned long long int>::resize(typename vector<unsigned long long int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x155d
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x3b40
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<float>::resize(unsigned int)
void vector<float>::resize(typename vector<float>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x159d
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x3bd0
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<double>::resize(unsigned int)
void vector<double>::resize(typename vector<double>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x15dd
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x3c60
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long double>::resize(unsigned int)
void vector<long double>::resize(typename vector<long double>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x161d
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, (%rdi)
callq 0x3cf0
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<bool>::resize(unsigned int, bool const&)
void vector<bool>::resize(typename vector<bool>::size_type sz, const bool &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x16ac
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x166f
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x3550
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x16aa
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movb (%rcx), %dl
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x167a
jmp 0x16ac
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<signed char>::resize(unsigned int, signed char const&)
void vector<signed char>::resize(typename vector<signed char>::size_type sz, const signed char &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x1739
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x16ff
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x35d0
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1737
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movb (%rcx), %dl
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x170a
jmp 0x1739
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned char>::resize(unsigned int, unsigned char const&)
void vector<unsigned char>::resize(typename vector<unsigned char>::size_type sz, const unsigned char &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x17c9
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x178f
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x3650
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x17c7
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movb (%rcx), %dl
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x179a
jmp 0x17c9
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<char>::resize(unsigned int, char const&)
void vector<char>::resize(typename vector<char>::size_type sz, const char &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x1859
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x181f
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x36d0
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1857
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movb (%rcx), %dl
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x182a
jmp 0x1859
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<short>::resize(unsigned int, short const&)
void vector<short int>::resize(typename vector<short int>::size_type sz, const short int &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x18eb
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x18af
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x3750
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x18e9
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movw (%rcx), %dx
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movw %dx, (%rax,%rcx,2)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x18ba
jmp 0x18eb
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned short>::resize(unsigned int, unsigned short const&)
void vector<unsigned short int>::resize(typename vector<unsigned short int>::size_type sz, const unsigned short int &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x197b
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x193f
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x37e0
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1979
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movw (%rcx), %dx
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movw %dx, (%rax,%rcx,2)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x194a
jmp 0x197b
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<int>::resize(unsigned int, int const&)
void vector<int>::resize(typename vector<int>::size_type sz, const int &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x1a09
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x19cf
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x3870
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1a07
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rcx), %edx
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x19da
jmp 0x1a09
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned int>::resize(unsigned int, unsigned int const&)
void vector<unsigned int>::resize(typename vector<unsigned int>::size_type sz, const unsigned int &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x1a99
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x1a5f
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x3900
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1a97
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rcx), %edx
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1a6a
jmp 0x1a99
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long>::resize(unsigned int, long const&)
void vector<long int>::resize(typename vector<long int>::size_type sz, const long int &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x1b2b
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x1aef
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x3990
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1b29
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1afa
jmp 0x1b2b
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned long>::resize(unsigned int, unsigned long const&)
void vector<unsigned long int>::resize(typename vector<unsigned long int>::size_type sz, const unsigned long int &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x1bbb
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x1b7f
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x3a20
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1bb9
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1b8a
jmp 0x1bbb
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long long>::resize(unsigned int, long long const&)
void vector<long long int>::resize(typename vector<long long int>::size_type sz, const long long int &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x1c4b
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x1c0f
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x3ab0
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1c49
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1c1a
jmp 0x1c4b
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)