LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./CELLServer.hpp
// Function: CELLServer::ClearClients()
void ClearClients() {
		for (auto iter : _clients) {
			delete iter.second;
		}
		_clients.clear();
		_clientSocketBuff.clear();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x20(%rdi), %r15
leaq 0x10(%rdi), %r13
cmpq %r13, %r15
je 0x6ffc
movq 0x28(%r15), %r12
testq %r12, %r12
je 0x6fdf
movq %r12, %rdi
callq 0x5ec0
movl $0x60, %esi
movq %r12, %rdi
callq 0x32a0
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
cmpq %r13, %rax
jne 0x6fce
movq %r14, %rdi
callq 0x7022
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x7012
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./../share/CELLThread.hpp
// Function: CELLThread::OnWork()
void OnWork()
	{
		if (_onCreate)
			_onCreate(this);
		if (_onRun)
			_onRun(this);
		if (_onDestory)
			_onDestory(this);

		//_sem.wakeup();
		m_sem.V();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x70eb
leaq -0x10(%rbp), %rsi
movq %rbx, (%rsi)
movq %rbx, %rdi
callq *0x18(%rbx)
cmpq $0x0, 0x30(%rbx)
je 0x7100
leaq 0x20(%rbx), %rdi
leaq -0x10(%rbp), %rsi
movq %rbx, (%rsi)
callq *0x38(%rbx)
cmpq $0x0, 0x50(%rbx)
je 0x7115
leaq 0x40(%rbx), %rdi
leaq -0x10(%rbp), %rsi
movq %rbx, (%rsi)
callq *0x58(%rbx)
addq $0x88, %rbx
movq %rbx, %rdi
callq 0x47b2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./share/log.cpp
// Function: Log::GetLogInstance()
Log* Log::GetLogInstance() {
    if(m_log == NULL) {
        std::unique_lock<std::mutex> ulock(m_mutex);
        if(m_log == NULL) {
            m_log = new Log;
            if(m_log == NULL) return NULL;
        }
    }
    return m_log;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq 0x4f38(%rip), %rax      # 0xc280
testq %rax, %rax
jne 0x73a8
leaq 0x4f04(%rip), %rax      # 0xc258
leaq -0x18(%rbp), %rbx
movq %rax, (%rbx)
movb $0x0, 0x8(%rbx)
movq %rbx, %rdi
callq 0x481e
movb $0x1, 0x8(%rbx)
cmpq $0x0, 0x4f0d(%rip)      # 0xc280
jne 0x7398
movl $0xa0, %edi
callq 0x3280
movq $0x0, 0x90(%rax)
movb $0x1, 0x98(%rax)
movq %rax, 0x4ee8(%rip)      # 0xc280
leaq -0x18(%rbp), %rdi
callq 0x4804
movq 0x4ed8(%rip), %rax      # 0xc280
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x4804
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./share/log.cpp
// Function: Log::async_write_log()
void Log::async_write_log() {
    while(isRun) {
        m_fullBuff.P();
        m_mutex.lock();
        auto item = m_list.front();
        m_list.pop_front();

        fputs(item.c_str(), m_fp);
        fflush(m_fp);

        m_mutex.unlock();
        m_emptyBuff.V();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x98(%rdi)
jne 0x7490
movq %rdi, %rbx
leaq -0x38(%rbp), %r12
leaq 0x4e68(%rip), %r15      # 0xc258
leaq -0x48(%rbp), %r13
leaq 0x4eed(%rip), %r14      # 0xc2e8
leaq 0x4e86(%rip), %rdi      # 0xc288
callq 0x475c
movq %r15, %rdi
callq 0x3380
testl %eax, %eax
jne 0x749f
movq 0x4f2a(%rip), %rax      # 0xc348
movq %r12, -0x48(%rbp)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x773a
movq 0x4f0c(%rip), %rsi      # 0xc348
leaq 0x4f05(%rip), %rdi      # 0xc348
callq 0x77d8
movq -0x48(%rbp), %rdi
movq 0x8(%rbx), %rsi
callq 0x32c0
movq 0x8(%rbx), %rdi
callq 0x32f0
movq %r15, %rdi
callq 0x3200
movq %r14, %rdi
callq 0x47b2
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x7483
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x32a0
cmpb $0x0, 0x98(%rbx)
jne 0x73fb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x31c0
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x74be
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, (%rdi)
leaq 0x10(%rdi), %r15
movq %rsi, %rdi
callq 0x3130
leaq 0x1(%rax), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3220
leaq 0x11a9(%rip), %rsi      # 0x86a6
movq %r14, %rdi
callq 0x3300
movq %rax, 0x8(%rbx)
movl $0x0, 0x4dcd(%rip)      # 0xc2e0
movl (%rbx), %eax
movl %eax, 0x4e25(%rip)      # 0xc340
leaq -0x15e(%rip), %rax      # 0x73c4
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
leaq -0x28(%rbp), %rdx
movq %rbx, (%rdx)
leaq -0x20(%rbp), %rdi
callq 0x7632
cmpq $0x0, 0x90(%rbx)
jne 0x756c
addq $0x90, %rbx
movq -0x20(%rbp), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x33e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x30b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movb $0x0, 0x98(%rdi)
cmpq $0x0, 0x4cff(%rip)      # 0xc280
je 0x7611
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4cbc(%rip), %rax      # 0xc258
leaq -0x20(%rbp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x481e
movb $0x1, 0x8(%r14)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x75cc
callq 0x32f0
movq 0x8(%rbx), %rdi
callq 0x3270
movq 0x4cad(%rip), %r14      # 0xc280
testq %r14, %r14
je 0x75ed
movq %r14, %rdi
callq 0x76b4
movl $0xa0, %esi
movq %r14, %rdi
callq 0x32a0
movl $0x0, (%rbx)
xorl %eax, %eax
movq %rax, 0x4c84(%rip)      # 0xc280
movq %rax, 0x8(%rbx)
leaq -0x20(%rbp), %rdi
callq 0x4804
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpq $0x3b9aca06, %rdi       # imm = 0x3B9ACA06
jle 0x15d4
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2a92(%rip), %rsi      # 0x4078
movq 0x2a83(%rip), %rdi      # 0x4070
movq %rsi, %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
ja 0x1689
movq 0x2a79(%rip), %r8       # 0x4080
movabsq $-0x768fa0ceed5d701b, %r12 # imm = 0x89705F3112A28FE5
leaq 0x2a58(%rip), %r14      # 0x4070
movq %rsp, %r15
imulq -0x8(%rsi), %rcx
movq %rcx, %rax
imulq %r12
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1d, %rdx
addq %rax, %rdx
imulq $0x3b9aca07, %rdx, %rax # imm = 0x3B9ACA07
subq %rax, %rcx
movq %rcx, (%rsp)
cmpq %r8, %rsi
je 0x165a
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x2a20(%rip)      # 0x4078
jmp 0x167a
movq %r14, %rdi
movq %r15, %rdx
callq 0x1804
movq 0x2a14(%rip), %r8       # 0x4080
movq 0x2a05(%rip), %rsi      # 0x4078
movq 0x29f6(%rip), %rdi      # 0x4070
movq %rsi, %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0x161b
movq (%rdi,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
orq %rdi, %rax
je 0x17ba
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %ebx
movabsq $-0x768fa0ceed5d701b, %r12 # imm = 0x89705F3112A28FE5
movq %r14, %rdi
movq %r15, %r13
movq %r14, %rax
imulq %r12
movq %rdx, %r14
addq %rdi, %r14
movq %r14, %rax
shrq $0x3f, %rax
sarq $0x1d, %r14
addq %rax, %r14
imulq $0x3b9aca07, %r14, %rax # imm = 0x3B9ACA07
subq %rax, %rdi
movq %r15, %rax
imulq %r12
movq %rdx, %r15
addq %r13, %r15
movq %r15, %rax
shrq $0x3f, %rax
sarq $0x1d, %r15
addq %rax, %r15
imulq $0x3b9aca07, %r15, %rax # imm = 0x3B9ACA07
subq %rax, %r13
movq %rdi, %rbp
subq %r13, %rbp
jl 0x17c1
callq 0x15c8
movq %rax, (%rsp)
movq %r13, %rdi
callq 0x15c8
movl $0x3b9aca05, %esi       # imm = 0x3B9ACA05
movq %rax, %rdi
callq 0x14dc
movq %rax, %r13
movq %rbp, %rdi
callq 0x15c8
movl $0x3b9aca05, %esi       # imm = 0x3B9ACA05
movq %rax, %rdi
callq 0x14dc
movq %rax, %rcx
imulq %r13, %rcx
movq %rcx, %rax
imulq %r12
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1d, %rdx
addq %rax, %rdx
imulq $0x3b9aca07, %rdx, %rax # imm = 0x3B9ACA07
subq %rax, %rcx
imulq (%rsp), %rcx
movq %rcx, %rax
imulq %r12
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1d, %rdx
addq %rax, %rdx
imulq $0x3b9aca07, %rdx, %rax # imm = 0x3B9ACA07
subq %rax, %rcx
imulq %rcx, %rbx
movq %r15, %rax
orq %r14, %rax
jne 0x16c5
movl $0x1, %eax
jmp 0x17c3
movl $0x1, %ebx
jmp 0x17c7
xorl %eax, %eax
imulq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rdi, %rax
andq $-0x2, %rax
movb $0x1, %dil
cmpq $0x2, %rax
je 0x1306
cmpq $0x2, %r14
setl %al
testb $0x1, %r14b
sete %cl
orb %al, %cl
jne 0x1304
leaq -0x1(%r14), %r15
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq %r15, %rcx
movq %r15, %rax
shrq %rax
incl %r12d
testb $0x2, %cl
movq %rax, %rcx
je 0x1248
movl $0x2, %eax
movl %r12d, %ecx
shll %cl, %eax
movslq %eax, %rcx
movq %r15, %rax
cqto
idivq %rcx
movq %rax, 0x10(%rsp)
testl %esi, %esi
jle 0x1306
leaq -0x3(%r14), %rbx
xorl %ebp, %ebp
movl %esi, 0x4(%rsp)
movq %rbx, 0x8(%rsp)
callq 0x1040
movl %eax, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
shlq $0x20, %r13
callq 0x1040
cltq
orq %r13, %rax
cqto
idivq %rbx
leaq 0x2(%rdx), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x116c
cmpq $0x1, %rax
sete %cl
cmpq %r15, %rax
sete %dl
orb %cl, %dl
je 0x12dc
incl %ebp
movl 0x4(%rsp), %esi
cmpl %esi, %ebp
movq 0x8(%rsp), %rbx
jne 0x1287
jmp 0x1317
movl %r12d, %r13d
testl %r12d, %r12d
je 0x1304
movl $0x2, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x116c
cmpq $0x1, %rax
je 0x1304
cmpq %r15, %rax
je 0x12cb
decl %r13d
jne 0x12e4
xorl %edi, %edi
movl %edi, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %dil
jmp 0x1306
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %edi, %edi
callq 0x1050
movl %eax, %edi
callq 0x1060
leaq 0xcd2(%rip), %rdi       # 0x2004
movl $0x1, %esi
xorl %eax, %eax
callq 0x1030
leaq 0xcdc(%rip), %rdi       # 0x2021
movl $0x1, %esi
xorl %eax, %eax
callq 0x1030
leaq 0xce6(%rip), %rdi       # 0x203e
xorl %esi, %esi
xorl %eax, %eax
callq 0x1030
movl $0x5, %edi
movl $0xa, %esi
callq 0x11fd
movzbl %al, %esi
leaq 0xce1(%rip), %rdi       # 0x205b
xorl %eax, %eax
callq 0x1030
movl $0x2bc521f, %edi        # imm = 0x2BC521F
movl $0xa, %esi
callq 0x11fd
movzbl %al, %esi
leaq 0xcde(%rip), %rdi       # 0x2078
xorl %eax, %eax
callq 0x1030
movl $0xd165493, %edi        # imm = 0xD165493
movl $0xa, %esi
callq 0x11fd
movzbl %al, %esi
leaq 0xce2(%rip), %rdi       # 0x209c
xorl %eax, %eax
callq 0x1030
movabsq $0x31bad0e013, %rdi     # imm = 0x31BAD0E013
movl $0xa, %esi
callq 0x11fd
movzbl %al, %esi
leaq 0xce2(%rip), %rdi       # 0x20c1
xorl %eax, %eax
callq 0x1030
movl $0xb2d08c91, %edi       # imm = 0xB2D08C91
movl $0xa, %esi
callq 0x11fd
movzbl %al, %esi
leaq 0xcea(%rip), %rdi       # 0x20e9
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
leaq -0x1d(%rbp), %rcx
movq %rsi, %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x32b2
movq 0x5e03(%rip), %rsi      # 0x91d0
leaq -0x1d(%rbp), %rdi
movl $0x4, %edx
callq 0x2100
testl %eax, %eax
jne 0x33e9
cmpb $0x3, -0x19(%rbp)
je 0x34c3
movq 0x5bd0(%rip), %r15      # 0x8fc0
leaq 0x2c70(%rip), %rsi      # 0x6067
movl $0x24, %edx
movq %r15, %rdi
callq 0x2240
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq 0x5b9e(%rip), %rdi      # 0x8fc0
callq 0x2030
movq %rax, %rdi
callq 0x2170
movq 0x5b8a(%rip), %r15      # 0x8fc0
leaq 0x2c4f(%rip), %rsi      # 0x608c
movl $0xb, %edx
movq %r15, %rdi
callq 0x2240
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq 0x5b58(%rip), %rdi      # 0x8fc0
callq 0x2030
movq %rax, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x34e2
movq 0x5b3c(%rip), %r14      # 0x8fc0
leaq 0x2c0d(%rip), %rsi      # 0x6098
movl $0x9, %edx
movq %r14, %rdi
callq 0x2240
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq 0x5b0a(%rip), %rdi      # 0x8fc0
callq 0x2030
movq %rax, %rdi
callq 0x2170
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x38cc
movq %r14, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x5cd9(%rip), %rsi      # 0x91d0
leaq -0x15(%rbp), %r14
movl $0x4, %edx
movq %r14, %rdi
callq 0x2130
movb $0x3, 0x4(%r14)
movq (%rbx), %rdi
xorl %esi, %esi
movl $0x5, %edx
movq %r14, %rcx
callq 0x32ca
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %r14d
movq %rdi, %rbx
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq -0x68(%rbp), %rdi
callq 0x2150
leaq -0x68(%rbp), %rsi
movb %r14b, 0x20(%rsi)
movl $0x0, 0x24(%rsi)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x390a
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3599
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x35ae
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2220
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3942
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %rax
subq %r12, %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %r13 # imm = 0x8E38E38E38E38E39
imulq %rax, %r13
testl %r13d, %r13d
jle 0x363e
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %r15
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
addq $0x30, %r12
cmpq %r15, -0x28(%r12)
jne 0x3635
testq %r15, %r15
je 0x3670
movq (%r14), %rsi
movq -0x30(%r12), %rdi
movq %r15, %rdx
callq 0x2230
testl %eax, %eax
je 0x3670
addq $0x48, %r12
decq %r13
jne 0x3615
movl $0x10, %edi
callq 0x2120
movq %rax, %rbx
leaq 0x2a50(%rip), %rsi      # 0x60a2
movq %rax, %rdi
callq 0x20d0
movq 0x598f(%rip), %rsi      # 0x8ff0
movq 0x5950(%rip), %rdx      # 0x8fb8
movq %rbx, %rdi
callq 0x22d0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x8(%r12), %rsi
movq (%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3988
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2190
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x38(%rbp)
movq 0x8(%rdi), %rbx
movq %rdi, -0x30(%rbp)
movq 0x10(%rdi), %rcx
subq %rbx, %rcx
sarq $0x3, %rcx
movabsq $-0x71c71c71c71c71c7, %rax # imm = 0x8E38E38E38E38E39
imulq %rcx, %rax
testl %eax, %eax
jle 0x3729
movq %rsi, %r15
movq 0x8(%rsi), %r12
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
shlq $0x3, %rax
leaq (%rax,%rax,8), %r14
xorl %r13d, %r13d
cmpq %r12, 0x8(%rbx,%r13)
jne 0x3720
testq %r12, %r12
je 0x375b
movq (%r15), %rsi
movq (%rbx,%r13), %rdi
movq %r12, %rdx
callq 0x2230
testl %eax, %eax
je 0x375b
addq $0x48, %r13
cmpq %r13, %r14
jne 0x3701
movl $0x10, %edi
callq 0x2120
movq %rax, %r14
leaq 0x2965(%rip), %rsi      # 0x60a2
movq %rax, %rdi
callq 0x20d0
movq 0x58a4(%rip), %rsi      # 0x8ff0
movq 0x5865(%rip), %rdx      # 0x8fb8
movq %r14, %rdi
callq 0x22d0
leaq -0x48(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x38(%rbp), %rbx
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x3988
movq 0x8(%r15), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl $0x16, %r8d
callq 0x2330
movq -0x30(%rbp), %r14
movq 0x8(%r14), %rax
leaq (%rax,%r13), %rdi
addq $0x28, %rdi
movq %r15, %rsi
callq 0x2250
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x37c3
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2220
movl 0x8(%rbx), %eax
movq 0x8(%r14), %rcx
movl %eax, 0x24(%rcx,%r13)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x3803
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x3803
movq %rax, %rbx
movq %r14, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r12
movq %rsi, -0x38(%rbp)
movq 0x10(%rsi), %rbx
movq %rbx, %rax
subq %r12, %rax
shrq $0x3, %rax
imull $0x38e38e39, %eax, %eax # imm = 0x38E38E39
testl %eax, %eax
jle 0x38a5
movq %rdx, %r14
xorl %r13d, %r13d
xorl %r15d, %r15d
movq (%r12,%r13), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x2100
testl %eax, %eax
je 0x3887
addq %r13, %r12
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x390a
movq -0x38(%rbp), %rax
movq 0x8(%rax), %r12
movq 0x10(%rax), %rbx
incq %r15
movq %rbx, %rax
subq %r12, %rax
shrq $0x3, %rax
imull $0x38e38e39, %eax, %eax # imm = 0x38E38E39
cltq
addq $0x48, %r13
cmpq %rax, %r15
jl 0x3858
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x38cc
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
leaq -0x1c8(%rbp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x2290
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq -0x40(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x20, %edx
callq 0x2320
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3e37
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5566
jmp 0x3e0c
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3e4c
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2220
movq 0x5145(%rip), %rsi      # 0x8f98
leaq -0x1c8(%rbp), %rdi
callq 0x21b0
leaq -0x148(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x55b2
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3e9e
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2220
movq 0x50f3(%rip), %rsi      # 0x8f98
leaq -0x1c8(%rbp), %rdi
callq 0x21b0
leaq -0x148(%rbp), %rdi
callq 0x2090
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x98(%rdi), %eax
testl %eax, %eax
je 0x3148
incl %eax
movl %eax, 0x98(%rbx)
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
movq 0x80(%rbx), %rsi
cmpq 0x88(%rbx), %rsi
je 0x3172
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x80(%rbx)
jmp 0x317e
leaq 0x78(%rbx), %rdi
movq %rsp, %rdx
callq 0x59ee
movq 0x78(%rbx), %rax
movq %rax, 0x90(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %r13d
cmpl %esi, %r13d
jae 0x1dcd
movl %ebx, %r15d
cmpl %ebx, (%r14)
jae 0x1db4
movq %rdx, (%rsp)
movl %ebx, (%r14)
movq %r15, %rdi
callq 0x1030
movq %rax, %rbp
movq 0x8(%r14), %r12
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x10b0
testq %r12, %r12
je 0x1dac
movq %r12, %rdi
callq 0x10f0
movl 0x4(%r14), %r13d
movq %rbp, 0x8(%r14)
movq (%rsp), %rdx
cmpl %ebx, %r13d
jae 0x1dcd
movl %r13d, %eax
movb (%rdx), %cl
movq 0x8(%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq %rax, %r15
jne 0x1dbe
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %r13d
cmpl %esi, %r13d
jae 0x1e57
movl %ebx, %r15d
cmpl %ebx, (%r14)
jae 0x1e3e
movq %rdx, (%rsp)
movl %ebx, (%r14)
movq %r15, %rdi
callq 0x1030
movq %rax, %rbp
movq 0x8(%r14), %r12
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x10b0
testq %r12, %r12
je 0x1e36
movq %r12, %rdi
callq 0x10f0
movl 0x4(%r14), %r13d
movq %rbp, 0x8(%r14)
movq (%rsp), %rdx
cmpl %ebx, %r13d
jae 0x1e57
movl %r13d, %eax
movb (%rdx), %cl
movq 0x8(%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq %rax, %r15
jne 0x1e48
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %r13d
cmpl %esi, %r13d
jae 0x1ee1
movl %ebx, %r15d
cmpl %ebx, (%r14)
jae 0x1ec8
movq %rdx, (%rsp)
movl %ebx, (%r14)
movq %r15, %rdi
callq 0x1030
movq %rax, %rbp
movq 0x8(%r14), %r12
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x10b0
testq %r12, %r12
je 0x1ec0
movq %r12, %rdi
callq 0x10f0
movl 0x4(%r14), %r13d
movq %rbp, 0x8(%r14)
movq (%rsp), %rdx
cmpl %ebx, %r13d
jae 0x1ee1
movl %r13d, %eax
movb (%rdx), %cl
movq 0x8(%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq %rax, %r15
jne 0x1ed2
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %r15d
cmpl %esi, %r15d
jae 0x26d5
movl %ebx, %ebp
cmpl %ebx, (%r14)
jae 0x25d3
movq %rdx, (%rsp)
movl %ebx, (%r14)
leaq (,%rbp,4), %rdi
callq 0x1030
movq %rax, %r12
movq 0x8(%r14), %r13
leaq (,%r15,4), %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0x10b0
testq %r13, %r13
je 0x25cb
movq %r13, %rdi
callq 0x10f0
movl 0x4(%r14), %r15d
movq %r12, 0x8(%r14)
movq (%rsp), %rdx
cmpl %ebx, %r15d
jae 0x26d5
movq 0x8(%r14), %rdi
movl %r15d, %esi
movl (%rdx), %eax
subq %rsi, %rbp
leaq 0x3(%rbp), %rcx
andq $-0x4, %rcx
decq %rbp
movq %rbp, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdi,%rsi,4), %rdx
addq $0xc, %rdx
xorl %esi, %esi
movdqa 0x1a61(%rip), %xmm1     # 0x4070
movdqa 0x1a69(%rip), %xmm2     # 0x4080
movdqa 0x1a71(%rip), %xmm3     # 0x4090
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rsi, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0x266e
movl %eax, -0xc(%rdx,%rsi,4)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x2681
movl %eax, -0x8(%rdx,%rsi,4)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0x26ba
movl %eax, -0x4(%rdx,%rsi,4)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x26c8
movl %eax, (%rdx,%rsi,4)
addq $0x4, %rsi
cmpq %rsi, %rcx
jne 0x2627
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %r15d
cmpl %esi, %r15d
jae 0x2855
movl %ebx, %ebp
cmpl %ebx, (%r14)
jae 0x2753
movq %rdx, (%rsp)
movl %ebx, (%r14)
leaq (,%rbp,4), %rdi
callq 0x1030
movq %rax, %r12
movq 0x8(%r14), %r13
leaq (,%r15,4), %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0x10b0
testq %r13, %r13
je 0x274b
movq %r13, %rdi
callq 0x10f0
movl 0x4(%r14), %r15d
movq %r12, 0x8(%r14)
movq (%rsp), %rdx
cmpl %ebx, %r15d
jae 0x2855
movq 0x8(%r14), %rdi
movl %r15d, %esi
movl (%rdx), %eax
subq %rsi, %rbp
leaq 0x3(%rbp), %rcx
andq $-0x4, %rcx
decq %rbp
movq %rbp, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdi,%rsi,4), %rdx
addq $0xc, %rdx
xorl %esi, %esi
movdqa 0x18e1(%rip), %xmm1     # 0x4070
movdqa 0x18e9(%rip), %xmm2     # 0x4080
movdqa 0x18f1(%rip), %xmm3     # 0x4090
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rsi, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0x27ee
movl %eax, -0xc(%rdx,%rsi,4)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x2801
movl %eax, -0x8(%rdx,%rsi,4)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0x283a
movl %eax, -0x4(%rdx,%rsi,4)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x2848
movl %eax, (%rdx,%rsi,4)
addq $0x4, %rsi
cmpq %rsi, %rcx
jne 0x27a7
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %r15d
cmpl %esi, %r15d
jae 0x297d
movl %ebx, %ebp
cmpl %ebx, (%r14)
jae 0x28d3
movq %rdx, (%rsp)
movl %ebx, (%r14)
leaq (,%rbp,8), %rdi
callq 0x1030
movq %rax, %r12
movq 0x8(%r14), %r13
leaq (,%r15,8), %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0x10b0
testq %r13, %r13
je 0x28cb
movq %r13, %rdi
callq 0x10f0
movl 0x4(%r14), %r15d
movq %r12, 0x8(%r14)
movq (%rsp), %rdx
cmpl %ebx, %r15d
jae 0x297d
movq 0x8(%r14), %rdi
movl %r15d, %esi
movq (%rdx), %rax
subq %rsi, %rbp
leaq 0x1(%rbp), %rcx
andq $-0x2, %rcx
decq %rbp
movq %rbp, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdi,%rsi,8), %rdx
addq $0x8, %rdx
xorl %esi, %esi
movdqa 0x1770(%rip), %xmm1     # 0x4080
movdqa 0x1778(%rip), %xmm2     # 0x4090
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rsi, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0x2961
movq %rax, -0x8(%rdx,%rsi,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x2974
movq %rax, (%rdx,%rsi,8)
addq $0x2, %rsi
cmpq %rsi, %rcx
jne 0x2920
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %r15d
cmpl %esi, %r15d
jae 0x2aa5
movl %ebx, %ebp
cmpl %ebx, (%r14)
jae 0x29fb
movq %rdx, (%rsp)
movl %ebx, (%r14)
leaq (,%rbp,8), %rdi
callq 0x1030
movq %rax, %r12
movq 0x8(%r14), %r13
leaq (,%r15,8), %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0x10b0
testq %r13, %r13
je 0x29f3
movq %r13, %rdi
callq 0x10f0
movl 0x4(%r14), %r15d
movq %r12, 0x8(%r14)
movq (%rsp), %rdx
cmpl %ebx, %r15d
jae 0x2aa5
movq 0x8(%r14), %rdi
movl %r15d, %esi
movq (%rdx), %rax
subq %rsi, %rbp
leaq 0x1(%rbp), %rcx
andq $-0x2, %rcx
decq %rbp
movq %rbp, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdi,%rsi,8), %rdx
addq $0x8, %rdx
xorl %esi, %esi
movdqa 0x1648(%rip), %xmm1     # 0x4080
movdqa 0x1650(%rip), %xmm2     # 0x4090
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rsi, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0x2a89
movq %rax, -0x8(%rdx,%rsi,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x2a9c
movq %rax, (%rdx,%rsi,8)
addq $0x2, %rsi
cmpq %rsi, %rcx
jne 0x2a48
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %r15d
cmpl %esi, %r15d
jae 0x2bcd
movl %ebx, %ebp
cmpl %ebx, (%r14)
jae 0x2b23
movq %rdx, (%rsp)
movl %ebx, (%r14)
leaq (,%rbp,8), %rdi
callq 0x1030
movq %rax, %r12
movq 0x8(%r14), %r13
leaq (,%r15,8), %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0x10b0
testq %r13, %r13
je 0x2b1b
movq %r13, %rdi
callq 0x10f0
movl 0x4(%r14), %r15d
movq %r12, 0x8(%r14)
movq (%rsp), %rdx
cmpl %ebx, %r15d
jae 0x2bcd
movq 0x8(%r14), %rdi
movl %r15d, %esi
movq (%rdx), %rax
subq %rsi, %rbp
leaq 0x1(%rbp), %rcx
andq $-0x2, %rcx
decq %rbp
movq %rbp, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdi,%rsi,8), %rdx
addq $0x8, %rdx
xorl %esi, %esi
movdqa 0x1520(%rip), %xmm1     # 0x4080
movdqa 0x1528(%rip), %xmm2     # 0x4090
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rsi, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0x2bb1
movq %rax, -0x8(%rdx,%rsi,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x2bc4
movq %rax, (%rdx,%rsi,8)
addq $0x2, %rsi
cmpq %rsi, %rcx
jne 0x2b70
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned long long>::resize(unsigned int, unsigned long long const&)
void vector<unsigned long long int>::resize(typename vector<unsigned long long int>::size_type sz, const unsigned 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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %r15d
cmpl %esi, %r15d
jae 0x2cf5
movl %ebx, %ebp
cmpl %ebx, (%r14)
jae 0x2c4b
movq %rdx, (%rsp)
movl %ebx, (%r14)
leaq (,%rbp,8), %rdi
callq 0x1030
movq %rax, %r12
movq 0x8(%r14), %r13
leaq (,%r15,8), %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0x10b0
testq %r13, %r13
je 0x2c43
movq %r13, %rdi
callq 0x10f0
movl 0x4(%r14), %r15d
movq %r12, 0x8(%r14)
movq (%rsp), %rdx
cmpl %ebx, %r15d
jae 0x2cf5
movq 0x8(%r14), %rdi
movl %r15d, %esi
movq (%rdx), %rax
subq %rsi, %rbp
leaq 0x1(%rbp), %rcx
andq $-0x2, %rcx
decq %rbp
movq %rbp, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdi,%rsi,8), %rdx
addq $0x8, %rdx
xorl %esi, %esi
movdqa 0x13f8(%rip), %xmm1     # 0x4080
movdqa 0x1400(%rip), %xmm2     # 0x4090
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rsi, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0x2cd9
movq %rax, -0x8(%rdx,%rsi,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x2cec
movq %rax, (%rdx,%rsi,8)
addq $0x2, %rsi
cmpq %rsi, %rcx
jne 0x2c98
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<float>::resize(unsigned int, float const&)
void vector<float>::resize(typename vector<float>::size_type sz, const float &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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %r15d
cmpl %esi, %r15d
jae 0x2e85
movl %ebx, %ebp
cmpl %ebx, (%r14)
jae 0x2d73
movq %rdx, (%rsp)
movl %ebx, (%r14)
leaq (,%rbp,4), %rdi
callq 0x1030
movq %rax, %r12
movq 0x8(%r14), %r13
leaq (,%r15,4), %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0x10b0
testq %r13, %r13
je 0x2d6b
movq %r13, %rdi
callq 0x10f0
movl 0x4(%r14), %r15d
movq %r12, 0x8(%r14)
movq (%rsp), %rdx
cmpl %ebx, %r15d
jae 0x2e85
movq 0x8(%r14), %rcx
movl %r15d, %esi
movss (%rdx), %xmm0
subq %rsi, %rbp
leaq 0x3(%rbp), %rax
andq $-0x4, %rax
decq %rbp
movq %rbp, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
leaq (%rcx,%rsi,4), %rcx
addq $0xc, %rcx
xorl %edx, %edx
movdqa 0x12bf(%rip), %xmm2     # 0x4070
movdqa 0x12c7(%rip), %xmm3     # 0x4080
movdqa 0x12cf(%rip), %xmm4     # 0x4090
pxor %xmm4, %xmm1
pcmpeqd %xmm5, %xmm5
movq %rdx, %xmm6
pshufd $0x44, %xmm6, %xmm6     # xmm6 = xmm6[0,1,0,1]
movdqa %xmm6, %xmm7
por %xmm3, %xmm7
pxor %xmm4, %xmm7
movdqa %xmm7, %xmm8
pcmpgtd %xmm1, %xmm8
pcmpeqd %xmm1, %xmm7
pshufd $0xf5, %xmm7, %xmm9     # xmm9 = xmm7[1,1,3,3]
pand %xmm8, %xmm9
pshufd $0xf5, %xmm8, %xmm7     # xmm7 = xmm8[1,1,3,3]
por %xmm9, %xmm7
movd %xmm7, %esi
notl %esi
testb $0x1, %sil
je 0x2e15
movss %xmm0, -0xc(%rcx,%rdx,4)
pxor %xmm5, %xmm7
pextrw $0x4, %xmm7, %esi
testb $0x1, %sil
je 0x2e2a
movss %xmm0, -0x8(%rcx,%rdx,4)
por %xmm2, %xmm6
pxor %xmm4, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm1, %xmm7
pcmpeqd %xmm1, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm5, %xmm6
pextrw $0x0, %xmm6, %esi
testb $0x1, %sil
je 0x2e68
movss %xmm0, -0x4(%rcx,%rdx,4)
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x2e78
movss %xmm0, (%rcx,%rdx,4)
addq $0x4, %rdx
cmpq %rdx, %rax
jne 0x2dc9
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<double>::resize(unsigned int, double const&)
void vector<double>::resize(typename vector<double>::size_type sz, const double &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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %r15d
cmpl %esi, %r15d
jae 0x2fb0
movl %ebx, %ebp
cmpl %ebx, (%r14)
jae 0x2f03
movq %rdx, (%rsp)
movl %ebx, (%r14)
leaq (,%rbp,8), %rdi
callq 0x1030
movq %rax, %r12
movq 0x8(%r14), %r13
leaq (,%r15,8), %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0x10b0
testq %r13, %r13
je 0x2efb
movq %r13, %rdi
callq 0x10f0
movl 0x4(%r14), %r15d
movq %r12, 0x8(%r14)
movq (%rsp), %rdx
cmpl %ebx, %r15d
jae 0x2fb0
movq 0x8(%r14), %rcx
movl %r15d, %esi
movsd (%rdx), %xmm0
subq %rsi, %rbp
leaq 0x1(%rbp), %rax
andq $-0x2, %rax
decq %rbp
movq %rbp, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
leaq (%rcx,%rsi,8), %rcx
addq $0x8, %rcx
xorl %edx, %edx
movdqa 0x113f(%rip), %xmm2     # 0x4080
movdqa 0x1147(%rip), %xmm3     # 0x4090
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
por %xmm2, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm1, %xmm6
pcmpeqd %xmm1, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x2f93
movsd %xmm0, -0x8(%rcx,%rdx,8)
pxor %xmm4, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x2fa7
movsd %xmm0, (%rcx,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rax
jne 0x2f51
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long double>::resize(unsigned int, long double const&)
void vector<long double>::resize(typename vector<long double>::size_type sz, const long double &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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %r15d
cmpl %esi, %r15d
fldz
jae 0x3053
fstp %st(0)
movl %ebx, %ebp
cmpl %ebx, (%r14)
jae 0x302d
movq %rdx, (%rsp)
movl %ebx, (%r14)
movq %rbp, %rdi
shlq $0x4, %rdi
callq 0x1030
movq %rax, %r12
movq 0x8(%r14), %r13
movq %r15, %rdx
shlq $0x4, %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0x10b0
testq %r13, %r13
je 0x3025
movq %r13, %rdi
callq 0x10f0
movl 0x4(%r14), %r15d
movq %r12, 0x8(%r14)
movq (%rsp), %rdx
cmpl %ebx, %r15d
fldz
jae 0x3053
fstp %st(0)
movl %r15d, %eax
fldt (%rdx)
subq %rax, %rbp
shlq $0x4, %rax
addq 0x8(%r14), %rax
fld %st(0)
fstpt (%rax)
addq $0x10, %rax
decq %rbp
jne 0x3046
fstp %st(0)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<int>::erase(int const*, int const*)
typename vector<int>::iterator vector<int>::erase(typename vector<int>::const_iterator first, typename vector<int>::const_iterator last) {
		iterator f = &arr[first - arr];
		if (first == last) return f;
		memmove(f, last, (vec_sz - (last - arr)) * sizeof(int));
		vec_sz -= last - first;
		return f;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq %rdx, %rsi
je 0x35d8
movq %rdx, %r14
movq %rdi, %r15
movq %rdx, %rax
subq 0x8(%rdi), %rax
movl 0x4(%rdi), %edx
shrq $0x2, %rax
subq %rax, %rdx
shlq $0x2, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1110
subq %rbx, %r14
shrq $0x2, %r14
subl %r14d, 0x4(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop