LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/sjtuwrk[P]SunwayMR/tools/SunwayMRHelper.hpp
// Function: SunwayMRHelper::initListening(int)
bool SunwayMRHelper::initListening(int port) {
	string msg;
	int listenPort = port;
	struct thread_data *data = new thread_data (*this, "", listenPort);
	pthread_t thread;
	pthread_mutex_init(&mutex_listen_status, NULL);
	pthread_mutex_lock(&mutex_listen_status);
	int rc = pthread_create(&thread, NULL, startHelperListening, (void *)data);
	if (rc){
		Logging::logError("JobScheduler: failed to create thread to listen");
	}

	pthread_mutex_lock(&mutex_listen_status);
	pthread_mutex_unlock(&mutex_listen_status);

	if(getListenStatus() == SUCCESS) {
		setLocalResouce(this->threads, this->memory);
		void *status;
		pthread_join(thread, &status); // always listen

		Logging::logInfo("SunwayMRHelper: listen thread finished");

		return true;
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
pushq $0x18
popq %rdi
callq 0x3370
movq %rax, %r15
movq %rbx, (%rax)
leaq 0x3f74(%rip), %rax      # 0xc09b
movq %rax, 0x8(%r15)
movl %ebp, 0x10(%r15)
leaq 0x8(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x34f0
movq %r14, %rdi
callq 0x34d0
leaq -0x1ae7(%rip), %rdx     # 0x6665
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x3640
testl %eax, %eax
je 0x8189
leaq 0x4599(%rip), %rsi      # 0xc6ff
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x915a
leaq 0x10(%rsp), %rdi
callq 0x4efc
leaq 0x10(%rsp), %rdi
callq 0x36e8
movq %r14, %rdi
callq 0x34d0
movq %r14, %rdi
callq 0x3280
movl 0xe8(%rbx), %ebp
cmpl $0x1, %ebp
jne 0x81f1
movl 0x134(%rbx), %esi
movl 0x138(%rbx), %edx
movq %rbx, %rdi
callq 0x6f54
movq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3310
leaq 0x4561(%rip), %rsi      # 0xc72f
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x915a
leaq 0x10(%rsp), %rdi
callq 0x4dbc
leaq 0x10(%rsp), %rdi
callq 0x36e8
cmpl $0x1, %ebp
sete %bl
leaq 0x38(%rsp), %rdi
callq 0x36e8
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8216
jmp 0x8227
jmp 0x8227
jmp 0x8227
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x36e8
jmp 0x822a
jmp 0x8227
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x36e8
movq %rbx, %rdi
callq 0x3610
// File: /workspace/github_cpp_makefile_star2_O2/sjtuwrk[P]SunwayMR/tools/SunwayMRHelper.hpp
// Function: SunwayMRHelper::update(HostResource)
void SunwayMRHelper::update(HostResource hr) {
	bool updated = false;
	for (unsigned int i=0; i<allResources.size(); i++) {
		if(allResources[i].host == hr.host) {
			allResources[i].threads = hr.threads;
			allResources[i].memory = hr.memory;
			allResources[i].listenPort = hr.listenPort;
			updated = true;
			break;
		}
	}
	if(!updated) {
		allResources.push_back(hr);
	}

	saveLocalHostFile();
	saveAllHostsFile();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x140(%rdi), %r15
xorl %ecx, %ecx
pushq $0x30
popq %r12
movl %ecx, %r13d
movq 0x140(%rbx), %rdi
movq 0x148(%rbx), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x893d
imulq $0x30, %r13, %rbp
addq %rbp, %rdi
movq %r14, %rsi
callq 0x906f
leal 0x1(%r13), %ecx
testb %al, %al
je 0x88f2
movq (%r15), %rax
movq 0x20(%r14), %rcx
movq %rcx, 0x20(%rax,%rbp)
movl 0x28(%r14), %ecx
movl %ecx, 0x28(%rax,%rbp)
jmp 0x8948
movq %r15, %rdi
movq %r14, %rsi
callq 0x9430
movq %rbx, %rdi
callq 0x8966
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b42
// File: /workspace/github_cpp_makefile_star2_O2/sjtuwrk[P]SunwayMR/tools/SunwayMRHelper.hpp
// Function: SunwayMRHelper::saveLocalHostFile()
void SunwayMRHelper::saveLocalHostFile() {
	stringstream ss;
	ss << localAddr << " " << threads << " " << memory << " " << listenPort;
	bool ret = writeFile(fileSaveDir, localHostFileName, ss.str());
	if (!ret) {
		stringstream error;
		error << "SunwayMRHelper: unable to write file: " << fileSaveDir << localHostFileName;
		Logging::logError(error.str());
	}
}

// Assembly:
pushq %rbx
subq $0x390, %rsp            # imm = 0x390
movq %rdi, %rbx
leaq 0x208(%rsp), %rdi
callq 0x3230
leaq 0x218(%rsp), %rdi
leaq 0x110(%rbx), %rsi
callq 0x3300
leaq 0x3bf5(%rip), %rsi      # 0xc58e
movq %rax, %rdi
callq 0x3360
movl 0x134(%rbx), %esi
movq %rax, %rdi
callq 0x35e0
leaq 0x3bd8(%rip), %rsi      # 0xc58e
movq %rax, %rdi
callq 0x3360
movl 0x138(%rbx), %esi
movq %rax, %rdi
callq 0x35e0
leaq 0x3bbb(%rip), %rsi      # 0xc58e
movq %rax, %rdi
callq 0x3360
movl 0x13c(%rbx), %esi
movq %rax, %rdi
callq 0x35e0
leaq 0x9a00(%rip), %rsi      # 0x123f0
leaq 0x60(%rsp), %rdi
callq 0x3490
leaq 0x9a0f(%rip), %rsi      # 0x12410
leaq 0x40(%rsp), %rdi
callq 0x3490
leaq 0x220(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3550
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x41d9
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0x36e8
leaq 0x40(%rsp), %rdi
callq 0x36e8
leaq 0x60(%rsp), %rdi
callq 0x36e8
testb %bl, %bl
jne 0x8ac1
leaq 0x80(%rsp), %rdi
callq 0x3230
leaq 0x90(%rsp), %rdi
leaq 0x3d8f(%rip), %rsi      # 0xc800
callq 0x3360
leaq 0x9973(%rip), %rsi      # 0x123f0
movq %rax, %rdi
callq 0x3300
leaq 0x9984(%rip), %rsi      # 0x12410
movq %rax, %rdi
callq 0x3300
leaq 0x98(%rsp), %rsi
movq %rsp, %rdi
callq 0x3550
movq %rsp, %rdi
callq 0x4efc
movq %rsp, %rdi
callq 0x36e8
leaq 0x80(%rsp), %rdi
callq 0x3260
leaq 0x208(%rsp), %rdi
callq 0x3260
addq $0x390, %rsp            # imm = 0x390
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x36e8
jmp 0x8b1a
jmp 0x8b17
jmp 0x8b29
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x36e8
jmp 0x8afa
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x36e8
jmp 0x8b09
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x36e8
jmp 0x8b2c
jmp 0x8b29
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x3260
jmp 0x8b2c
movq %rax, %rbx
leaq 0x208(%rsp), %rdi
callq 0x3260
movq %rbx, %rdi
callq 0x3610
nop
// File: /workspace/github_cpp_makefile_star2_O2/sjtuwrk[P]SunwayMR/tools/SunwayMRHelper.hpp
// Function: SunwayMRHelper::saveAllHostsFile()
void SunwayMRHelper::saveAllHostsFile() {
	stringstream ss;
	for(unsigned int i=0; i<allResources.size(); i++) {
		ss << allResources[i].host << " " << allResources[i].threads << " " << allResources[i].memory << " " << allResources[i].listenPort;
		if (allResources[i].host == masterAddr) {
			ss << " master";
		}
		ss << endl;

	}
	bool ret = writeFile(fileSaveDir, allHostsFileName, ss.str());
	if (!ret) {
		stringstream error;
		error << "SunwayMRHelper: unable to write file: " << fileSaveDir << allHostsFileName;
		Logging::logError(error.str());
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x398, %rsp            # imm = 0x398
movq %rdi, %rbx
leaq 0x210(%rsp), %rdi
callq 0x3230
leaq 0x220(%rsp), %r14
leaq 0xf0(%rbx), %r15
xorl %r13d, %r13d
leaq 0x3a12(%rip), %r12      # 0xc58e
movl %r13d, %r13d
movq 0x140(%rbx), %rsi
movq 0x148(%rbx), %rax
subq %rsi, %rax
cqto
pushq $0x30
popq %rcx
idivq %rcx
cmpq %r13, %rax
jbe 0x8c3f
imulq $0x30, %r13, %rbp
addq %rbp, %rsi
movq %r14, %rdi
callq 0x3300
movq %rax, %rdi
movq %r12, %rsi
callq 0x3360
movq 0x140(%rbx), %rcx
movl 0x20(%rcx,%rbp), %esi
movq %rax, %rdi
callq 0x35e0
movq %rax, %rdi
movq %r12, %rsi
callq 0x3360
movq 0x140(%rbx), %rcx
movl 0x24(%rcx,%rbp), %esi
movq %rax, %rdi
callq 0x35e0
movq %rax, %rdi
movq %r12, %rsi
callq 0x3360
movq 0x140(%rbx), %rcx
movl 0x28(%rcx,%rbp), %esi
movq %rax, %rdi
callq 0x35e0
addq 0x140(%rbx), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x906f
testb %al, %al
je 0x8c2f
movq %r14, %rdi
leaq 0x3c1d(%rip), %rsi      # 0xc847
callq 0x3360
movq %r14, %rdi
callq 0x31b0
incl %r13d
jmp 0x8b7c
leaq 0x97aa(%rip), %rsi      # 0x123f0
leaq 0x68(%rsp), %rdi
callq 0x3490
leaq 0x97d9(%rip), %rsi      # 0x12430
leaq 0x48(%rsp), %rdi
callq 0x3490
leaq 0x228(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3550
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x41d9
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x36e8
leaq 0x48(%rsp), %rdi
callq 0x36e8
leaq 0x68(%rsp), %rdi
callq 0x36e8
testb %bl, %bl
jne 0x8d1d
leaq 0x88(%rsp), %rdi
callq 0x3230
leaq 0x98(%rsp), %rdi
leaq 0x3b39(%rip), %rsi      # 0xc800
callq 0x3360
leaq 0x971d(%rip), %rsi      # 0x123f0
movq %rax, %rdi
callq 0x3300
leaq 0x974e(%rip), %rsi      # 0x12430
movq %rax, %rdi
callq 0x3300
leaq 0xa0(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3550
leaq 0x8(%rsp), %rdi
callq 0x4efc
leaq 0x8(%rsp), %rdi
callq 0x36e8
leaq 0x88(%rsp), %rdi
callq 0x3260
leaq 0x210(%rsp), %rdi
callq 0x3260
addq $0x398, %rsp            # imm = 0x398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x36e8
jmp 0x8d81
jmp 0x8d7e
jmp 0x8d90
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x36e8
jmp 0x8d61
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x36e8
jmp 0x8d70
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x36e8
jmp 0x8d93
jmp 0x8d90
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x3260
jmp 0x8d93
movq %rax, %rbx
leaq 0x210(%rsp), %rdi
callq 0x3260
movq %rbx, %rdi
callq 0x3610
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_benchmark.cpp
// Function: bool load_expression<double, std::allocator<exprtk::expression<double>>, std::deque>(exprtk::symbol_table<double>&, std::deque<exprtk::expression<double>, std::allocator<exprtk::expression<double>>>&)
bool load_expression(exprtk::symbol_table<T>& symbol_table,
                     Sequence<exprtk::expression<T>,Allocator>& expr_seq)
{
   exprtk::parser<double> parser;

   for (std::size_t i = 0; i < global_expression_list_size; ++i)
   {
      exprtk::expression<double> expression;
      expression.register_symbol_table(symbol_table);

      if (!parser.compile(global_expression_list[i],expression))
      {
         printf("[load_expression] - Parser Error: %s\tExpression: %s\n",
                parser.error().c_str(),
                global_expression_list[i].c_str());

         return false;
      }

      expr_seq.push_back(expression);
   }

   return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xaa8, %rsp            # imm = 0xAA8
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
leaq 0x30(%rsp), %rbx
pushq $0x7f
popq %rsi
movq %rbx, %rdi
callq 0x116c42
leaq 0x180(%rsp), %rdi
movq %rbx, %rsi
callq 0x116d52
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x11736a
leaq 0x2c320f(%rip), %r12    # 0x3d8e40
xorl %eax, %eax
movq %rax, %rbp
cmpq $0x11, %rax
je 0x115cc7
movq %r15, %rdi
callq 0x1173c2
movq %r15, %rdi
movq %r14, %rsi
callq 0x117422
leaq 0x180(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x11747e
movl %eax, %ebx
testb %al, %al
je 0x115c7b
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x117954
jmp 0x115caf
leaq 0x10(%rsp), %r13
movq %r13, %rdi
leaq 0x180(%rsp), %rsi
callq 0x117900
movq 0x10(%rsp), %rsi
movq (%r12), %rdx
leaq 0x131a37(%rip), %rdi    # 0x2476d7
xorl %eax, %eax
callq 0x112080
movq %r13, %rdi
callq 0x112628
movq %r15, %rdi
callq 0x11797e
leaq 0x1(%rbp), %rax
addq $0x20, %r12
testb %bl, %bl
jne 0x115c33
cmpq $0x11, %rbp
setae %bl
leaq 0x180(%rsp), %rdi
callq 0x117994
movl %ebx, %eax
addq $0xaa8, %rsp            # imm = 0xAA8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x11736a
jmp 0x115d1f
jmp 0x115d05
movq %rax, %rbx
jmp 0x115d12
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x11797e
leaq 0x180(%rsp), %rdi
callq 0x117994
movq %rbx, %rdi
callq 0x112370
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_benchmark.cpp
// Function: void run_exprtk_benchmark<double>(double&, double&, exprtk::expression<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void run_exprtk_benchmark(T& x, T& y,
                          exprtk::expression<T>& expression,
                          const std::string& expr_string)
{
   T total = T(0);
   unsigned int count = 0;

   exprtk::timer timer;
   timer.start();

   for (x = global_lower_bound_x; x <= global_upper_bound_x; x += global_delta)
   {
      for (y = global_lower_bound_y; y <= global_upper_bound_y; y += global_delta)
      {
         total += expression.value();
         ++count;
      }
   }

   timer.stop();

   if (T(0) != total)
      printf("[exprtk] Total Time:%12.8f  Rate:%14.3fevals/sec Expression: %s\n",
             timer.time(),
             count / timer.time(),
             expr_string.c_str());
   else
      printf("run_exprtk_benchmark() - Error running benchmark for expression: %s\n",expr_string.c_str());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x18(%rsp), %rdi
movb $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
callq 0x117ace
xorl %ebp, %ebp
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x12c36d(%rip), %xmm0   # 0x2420e8
movsd %xmm0, (%r12)
movsd 0x12c367(%rip), %xmm1   # 0x2420f0
ucomisd %xmm0, %xmm1
jb 0x115de8
movsd 0x12c351(%rip), %xmm0   # 0x2420e8
movsd %xmm0, (%r15)
movsd 0x12c34c(%rip), %xmm1   # 0x2420f0
ucomisd %xmm0, %xmm1
jb 0x115dd8
movq (%r14), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incl %ebp
movsd (%r15), %xmm0
addsd 0x12c322(%rip), %xmm0   # 0x2420f8
jmp 0x115d97
movsd (%r12), %xmm0
addsd 0x12c312(%rip), %xmm0   # 0x2420f8
jmp 0x115d7b
leaq 0x18(%rsp), %rdi
callq 0x117adc
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x115e04
jnp 0x115e4f
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x117af0
movsd %xmm0, 0x8(%rsp)
movl %ebp, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0x117af0
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movq (%rbx), %rsi
leaq 0x1318cc(%rip), %rdi    # 0x24770c
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
callq 0x112080
jmp 0x115e60
movq (%rbx), %rsi
leaq 0x1318f4(%rip), %rdi    # 0x24774d
xorl %eax, %eax
callq 0x112080
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_benchmark.cpp
// Function: void run_native_benchmark<double, double (*)(double const&, double const&)>(double&, double&, double (*)(double const&, double const&), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void run_native_benchmark(T& x, T& y, NativeFunction f, const std::string& expr_string)
{
   T total = T(0);
   unsigned int count = 0;

   exprtk::timer timer;
   timer.start();

   for (x = global_lower_bound_x; x <= global_upper_bound_x; x += global_delta)
   {
      for (y = global_lower_bound_y; y <= global_upper_bound_y; y += global_delta)
      {
         total += f(x,y);
         ++count;
      }
   }

   timer.stop();

   if (T(0) != total)
      printf("[native] Total Time:%12.8f  Rate:%14.3fevals/sec Expression: %s\n",
             timer.time(),
             count / timer.time(),
             expr_string.c_str());
   else
      printf("run_native_benchmark() - Error running benchmark for expression: %s\n",expr_string.c_str());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x18(%rsp), %rdi
movb $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
callq 0x117ace
xorl %ebp, %ebp
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x12c238(%rip), %xmm0   # 0x2420e8
movsd %xmm0, (%r12)
movsd 0x12c232(%rip), %xmm1   # 0x2420f0
ucomisd %xmm0, %xmm1
jb 0x115f19
movsd 0x12c21c(%rip), %xmm0   # 0x2420e8
movsd %xmm0, (%r15)
movsd 0x12c217(%rip), %xmm1   # 0x2420f0
ucomisd %xmm0, %xmm1
jb 0x115f09
movq %r12, %rdi
movq %r15, %rsi
callq *%r14
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incl %ebp
movsd (%r15), %xmm0
addsd 0x12c1f1(%rip), %xmm0   # 0x2420f8
jmp 0x115ecc
movsd (%r12), %xmm0
addsd 0x12c1e1(%rip), %xmm0   # 0x2420f8
jmp 0x115eb0
leaq 0x18(%rsp), %rdi
callq 0x117adc
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x115f35
jnp 0x115f80
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x117af0
movsd %xmm0, 0x8(%rsp)
movl %ebp, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0x117af0
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movq (%rbx), %rsi
leaq 0x131821(%rip), %rdi    # 0x247792
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
callq 0x112080
jmp 0x115f91
movq (%rbx), %rsi
leaq 0x131849(%rip), %rdi    # 0x2477d3
xorl %eax, %eax
callq 0x112080
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_benchmark.cpp
// Function: bool run_parse_benchmark<double>(exprtk::symbol_table<double>&)
bool run_parse_benchmark(exprtk::symbol_table<T>& symbol_table)
{
   static const std::size_t rounds = 100000;
   exprtk::parser<double>     parser;
   exprtk::expression<double> expression;

   expression.register_symbol_table(symbol_table);

   for (std::size_t i = 0; i < global_expression_list_size; ++i)
   {
      exprtk::timer timer;
      timer.start();

      for (std::size_t r = 0; r < rounds; ++r)
      {
         if (!parser.compile(global_expression_list[i],expression))
         {
            printf("[run_parse_benchmark] - Parser Error: %s\tExpression: %s\n",
                   parser.error().c_str(),
                   global_expression_list[i].c_str());

            return false;
         }
      }

      timer.stop();

      printf("[parse] Total Time:%12.8f  Rate:%14.3fparse/sec Expression: %s\n",
             timer.time(),
             rounds / timer.time(),
             global_expression_list[i].c_str());
   }

   return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xac8, %rsp            # imm = 0xAC8
movq %rdi, %rbx
leaq 0x50(%rsp), %r14
pushq $0x7f
popq %rsi
movq %r14, %rdi
callq 0x116c42
leaq 0x1a0(%rsp), %rdi
movq %r14, %rsi
callq 0x116d52
leaq 0x50(%rsp), %rdi
callq 0x11736a
leaq 0x10(%rsp), %rdi
callq 0x1173c2
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x117422
leaq 0x58(%rsp), %rax
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
leaq 0x50(%rsp), %rdi
leaq 0x2c2946(%rip), %r14    # 0x3d8e40
leaq 0x1a0(%rsp), %r15
leaq 0x10(%rsp), %r12
cmpq $0x11, %rbp
je 0x1165e1
movb $0x0, 0x50(%rsp)
movupd %xmm0, 0x10(%rax)
movupd %xmm0, (%rax)
movq %rdi, %rbx
callq 0x117ace
movq %rbp, %r13
shlq $0x5, %r13
addq %r14, %r13
movl $0x186a1, %r14d         # imm = 0x186A1
decq %r14
je 0x116550
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x11747e
testb %al, %al
jne 0x116537
jmp 0x1165ad
movq %rbx, %rdi
callq 0x117adc
movq %rbx, %rdi
callq 0x117af0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x117af0
movsd 0x12bc22(%rip), %xmm1   # 0x242198
divsd %xmm0, %xmm1
movq (%r13), %rsi
leaq 0x1312cc(%rip), %rdi    # 0x247851
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
callq 0x112080
incq %rbp
leaq 0x58(%rsp), %rax
xorpd %xmm0, %xmm0
movq %rbx, %rdi
leaq 0x2c2898(%rip), %r14    # 0x3d8e40
jmp 0x116507
leaq 0x30(%rsp), %rdi
leaq 0x1a0(%rsp), %rsi
callq 0x117900
leaq 0x30(%rsp), %rbx
movq (%rbx), %rsi
movq (%r13), %rdx
leaq 0x131246(%rip), %rdi    # 0x247818
xorl %eax, %eax
callq 0x112080
movq %rbx, %rdi
callq 0x112628
cmpq $0x11, %rbp
setae %bl
leaq 0x10(%rsp), %rdi
callq 0x11797e
leaq 0x1a0(%rsp), %rdi
callq 0x117994
movl %ebx, %eax
addq $0xac8, %rsp            # imm = 0xAC8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11662d
jmp 0x11662d
movq %rax, %rbx
jmp 0x11663a
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x11736a
jmp 0x116647
jmp 0x11662d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x11797e
leaq 0x1a0(%rsp), %rdi
callq 0x117994
movq %rbx, %rdi
callq 0x112370
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_benchmark.cpp
// Function: load_expression_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::deque<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>>>>&)
inline std::size_t load_expression_file(const std::string& file_name, std::deque<std::string>& expression_list)
{
   std::ifstream stream(file_name.c_str());

   if (!stream) return 0;

   std::string buffer;
   buffer.reserve(1024);
   std::size_t line_count = 0;

   while (std::getline(stream,buffer))
   {
      if (buffer.empty())
         continue;
      else if ('#' == buffer[0])
         continue;

      ++line_count;
      expression_list.push_back(buffer);
   }

   return line_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x20(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x112050
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
je 0x116714
xorl %r14d, %r14d
jmp 0x11677f
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x112400
xorl %r14d, %r14d
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1122b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x116777
cmpq $0x0, 0x8(%rsp)
je 0x11673d
movq (%rsp), %rax
cmpb $0x23, (%rax)
je 0x11673d
incq %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1180e0
jmp 0x11673d
movq %rsp, %rdi
callq 0x112628
leaq 0x20(%rsp), %rdi
callq 0x112040
movq %r14, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x11679f
jmp 0x11679f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x112628
leaq 0x20(%rsp), %rdi
callq 0x112040
movq %rbx, %rdi
callq 0x112370
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/mshview/mshview.cpp
// Function: GLUTSpecial(int, int, int)
void GLUTSpecial(int key, int x, int y)
{
  // Invert y coordinate
  y = GLUTwindow_height - y;

  // Process keyboard button event 
  switch(key) {
  case GLUT_KEY_DOWN:
    if (current_mesh <= 1) current_mesh = 0;
    else current_mesh--;
    break;
    
  case GLUT_KEY_UP:
    if (current_mesh >= meshes.NEntries()-2) current_mesh = meshes.NEntries()-1;
    else current_mesh++;
    break;
  }
  
  // Remember mouse position 
  GLUTmouse[0] = x;
  GLUTmouse[1] = y;

  // Remember modifiers 
  GLUTmodifiers = glutGetModifiers();

  // Redraw
  glutPostRedisplay();
}

// Assembly:
movl 0x108b53(%rip), %eax    # 0x12e9dc
cmpl $0x65, %edi
je 0x25ea8
cmpl $0x67, %edi
jne 0x25ecb
movl 0x108b37(%rip), %edi    # 0x12e9d0
leal -0x1(%rdi), %r8d
xorl %ecx, %ecx
cmpl $0x2, %edi
cmovgel %r8d, %ecx
jmp 0x25ec5
movl 0x108b22(%rip), %edi    # 0x12e9d0
movl 0x10da60(%rip), %ecx    # 0x133914
leal -0x2(%rcx), %r8d
cmpl %r8d, %edi
jge 0x25ec3
incl %edi
movl %edi, %ecx
jmp 0x25ec5
decl %ecx
movl %ecx, 0x108b05(%rip)    # 0x12e9d0
pushq %rax
subl %edx, %eax
movl %esi, 0x10e17c(%rip)    # 0x134050
movl %eax, 0x10e17a(%rip)    # 0x134054
callq 0xbcafe
popq %rax
jmp 0xb8060
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/mshview/mshview.cpp
// Function: GLUTMainLoop()
void GLUTMainLoop(void)
{
  // Set world origin
  if (initial_world_origin != R3unknown_point) {
    world_origin = initial_world_origin;
  }
  else if (meshes.NEntries() > 0) {
    world_origin = meshes[0]->BBox().Centroid();
  }

  // Run main loop -- never returns 
  glutMainLoop();
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x10d47e(%rip), %rdi    # 0x1338f0
leaq 0x111087(%rip), %rsi    # 0x137500
callq 0x6b23e
testl %eax, %eax
je 0x26492
leaq 0x10d48f(%rip), %rdi    # 0x133918
leaq 0x10d460(%rip), %rsi    # 0x1338f0
jmp 0x264c8
cmpl $0x0, 0x10d47b(%rip)    # 0x133914
jle 0x264cd
movq 0x10d466(%rip), %rax    # 0x133908
movq (%rax), %rsi
movq 0xf8(%rsi), %rax
addq $0xf8, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq *0x68(%rax)
leaq 0x10d453(%rip), %rdi    # 0x133918
movq %rbx, %rsi
callq 0x6b432
callq 0xbb053
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/mshview/mshview.cpp
// Function: ReadMeshes(gaps::RNArray<char*> const&)
int
ReadMeshes(const RNArray<char *>& mesh_names)
{
  // Read each mesh
  for (int i = 0; i < mesh_names.NEntries(); i++) {
    char *mesh_name = mesh_names[i];

    // Allocate mesh
    R3Mesh *mesh = new R3Mesh();
    assert(mesh);

    // Read mesh from file
    if (!mesh->ReadFile(mesh_name)) {
      delete mesh;
      return 0;
    }

    // Add mesh to list
    meshes.Insert(mesh);

    // Print statistics
    if (print_verbose) {
      printf("Read mesh from %s ...\n", mesh_name);
      printf("  # Faces = %d\n", mesh->NFaces());
      printf("  # Edges = %d\n", mesh->NEdges());
      printf("  # Vertices = %d\n", mesh->NVertices());
      fflush(stdout);
    }
  }

  // Return number of meshes
  return meshes.NEntries();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10d41b(%rip), %r14    # 0x133908
leaq 0x9edaf(%rip), %rbp     # 0xc52a3
xorl %r13d, %r13d
movslq 0xc(%rbx), %rax
cmpq %rax, %r13
jge 0x265a1
movq (%rbx), %rax
movq (%rax,%r13,8), %r12
movl $0x138, %edi            # imm = 0x138
callq 0x218c0
movq %rax, %r15
movq %rax, %rdi
callq 0x4a2ec
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x180(%rax)
testl %eax, %eax
je 0x265a9
movq %r14, %rdi
movq %r15, %rsi
callq 0x26d1e
cmpb $0x1, 0x10db3f(%rip)    # 0x134084
jne 0x26599
leaq 0x9ed1e(%rip), %rdi     # 0xc526c
movq %r12, %rsi
xorl %eax, %eax
callq 0x21080
movl 0x34(%r15), %esi
leaq 0x9ed20(%rip), %rdi     # 0xc5283
xorl %eax, %eax
callq 0x21080
movl 0x24(%r15), %esi
leaq 0x9ed1e(%rip), %rdi     # 0xc5293
xorl %eax, %eax
callq 0x21080
movl 0x14(%r15), %esi
movq %rbp, %rdi
xorl %eax, %eax
callq 0x21080
movq 0x1079af(%rip), %rax    # 0x12df40
movq (%rax), %rdi
callq 0x21a80
incq %r13
jmp 0x264f7
movl 0x10d36d(%rip), %eax    # 0x133914
jmp 0x265b4
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x138, %esi            # imm = 0x138
movq %r15, %rdi
callq 0x218e0
movq %rbx, %rdi
callq 0x220c0
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/mshview/mshview.cpp
// Function: main
int main(int argc, char **argv)
{
  // Initialize packages
  if (!R3InitGraphics()) exit(-1);

  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Initialize GLUT
  GLUTInit(&argc, argv);

  // Read mesh
  if (!ReadMeshes(mesh_names)) exit(-1);

  // Create viewer
  viewer = CreateBirdsEyeViewer(meshes[0]);
  if (!viewer) exit(-1);

  // Run GLUT interface
  GLUTMainLoop();

  // Return success 
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, 0xc(%rsp)
callq 0x26d28
testl %eax, %eax
je 0x26bdd
movl %ebp, %edi
movq %rbx, %rsi
callq 0x265db
testl %eax, %eax
je 0x26bdd
leaq 0xc(%rsp), %rdi
movq %rbx, %rsi
callq 0x26309
leaq 0x10cde5(%rip), %rdi    # 0x133880
callq 0x264d8
testl %eax, %eax
je 0x26bdd
movq 0x10ce59(%rip), %rax    # 0x133908
movl $0xf8, %esi
addq (%rax), %rsi
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x635b6
movq %rbx, %rdi
callq 0x26ca4
movsd %xmm0, 0x10(%rsp)
cmpb $0x0, 0x10d5af(%rip)    # 0x134088
jne 0x26b34
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x63d92
movsd 0x9e57e(%rip), %xmm0    # 0xc5070
mulsd 0x10(%rsp), %xmm0
leaq 0x10cdc1(%rip), %rsi    # 0x1338c0
leaq 0x30(%rsp), %rdi
callq 0x6bffe
leaq 0x80(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x6b899
leaq 0x10cd81(%rip), %rdi    # 0x1338a8
leaq 0x80(%rsp), %rsi
callq 0x6b432
movsd 0x9e4dc(%rip), %xmm2    # 0xc5018
movsd 0x10(%rsp), %xmm3
mulsd %xmm3, %xmm2
mulsd 0x9e52a(%rip), %xmm3    # 0xc5078
leaq 0x10cd53(%rip), %rsi    # 0x1338a8
leaq 0x10cd64(%rip), %rdx    # 0x1338c0
leaq 0x10cd75(%rip), %rcx    # 0x1338d8
leaq 0x80(%rsp), %rdi
movsd 0x9e4ed(%rip), %xmm0    # 0xc5060
movapd %xmm0, %xmm1
callq 0x28666
movl 0x107e56(%rip), %ecx    # 0x12e9d8
movl 0x107e53(%rip), %r8d    # 0x12e9dc
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x29338
movl $0xa8, %edi
callq 0x218c0
movq %rax, %r14
leaq 0x80(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x26dea
leaq 0x48(%rsp), %rdi
callq 0x6426e
movq %r14, 0x10d42e(%rip)    # 0x133ff8
callq 0x26466
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $-0x1
popq %rdi
callq 0x21ae0
jmp 0x26bff
movq %rax, %rbx
movl $0xa8, %esi
movq %r14, %rdi
callq 0x218e0
jmp 0x26c02
jmp 0x26bff
jmp 0x26bff
jmp 0x26bff
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6426e
movq %rbx, %rdi
callq 0x220c0
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_06.cc
// Function: main
int main(int argc, char const *argv[])
{
	// std::array<std::string, 3> sa = {"hello", "c++", "primer"};
	std::string sa[] = {"hello", "c++", "primer"};
	std::cout << *(begin_custom(sa) + 1) << std::endl;
	std::cout << *(end_custom(sa) - 1) << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
leaq 0xe12(%rip), %rsi       # 0x2004
leaq -0x90(%rbp), %rbx
leaq -0x23(%rbp), %rdx
movq %rbx, %rdi
callq 0x1030
leaq -0x70(%rbp), %r14
leaq 0xdfa(%rip), %rsi       # 0x200a
leaq -0x22(%rbp), %rdx
movq %r14, %rdi
callq 0x1030
leaq -0x50(%rbp), %r12
leaq 0xde7(%rip), %rsi       # 0x200e
leaq -0x21(%rbp), %rdx
movq %r12, %rdi
callq 0x1030
movq 0x2d9e(%rip), %rdi      # 0x3fd8
movq %r14, %rsi
callq 0x1070
movq %rax, %rdi
callq 0x1050
movq 0x2d87(%rip), %rdi      # 0x3fd8
movq %r12, %rsi
callq 0x1070
movq %rax, %rdi
callq 0x1050
pushq $0x40
popq %rbx
leaq (%rbx,%rbp), %rdi
addq $-0x90, %rdi
callq 0x1040
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x1264
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r12, %r14
jmp 0x1298
movq %rax, %r15
addq $-0x20, %r14
movq %r14, %rdi
callq 0x1040
cmpq %rbx, %r14
jne 0x1298
jmp 0x12cb
movq %rax, %r15
pushq $0x40
popq %rbx
leaq (%rbx,%rbp), %rdi
addq $-0x90, %rdi
callq 0x1040
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x12b1
movq %r15, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Ast.hpp
// Function: to_string[abi:cxx11](AstExpr*)
string to_string(AstExpr* ast) {
    switch (ast->type) {
        case AST_TYPE_EXPR:
            return "AstExpr";
        case AST_TYPE_STMTS:
            return to_string((AstStmts*)ast);
        case AST_TYPE_STMT:
            return to_string((AstStmt*)ast);
        case AST_TYPE_ASSIGN:
            return to_string((AstAssign*)ast);
        case AST_TYPE_NUMBER:
            return to_string((AstNumber*)ast);
        case AST_TYPE_IDENT:
            return to_string((AstIdent*)ast);
        case AST_TYPE_BIN_OP:
            return to_string((AstBinaryOp*)ast);
        case AST_TYPE_FUNCTION_CALL:
            return to_string((AstFunctionCall*)ast);
        case AST_TYPE_BLOCK:
            return to_string((AstBlock*)ast);
        case AST_TYPE_IF:
            return to_string((AstIf*)ast);
    }
    return "AstExpr";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x9, %rax
ja 0x4319
leaq 0x5d51(%rip), %rcx      # 0xa004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x442d
jmp 0x4336
movq %rbx, %rdi
callq 0x3fff
jmp 0x4336
movq %rbx, %rdi
callq 0x4657
jmp 0x4336
movq %rbx, %rdi
callq 0x44b1
jmp 0x4336
leaq 0x5f88(%rip), %rsi      # 0xa273
leaq -0xa(%rbp), %rdx
jmp 0x4324
movq %rbx, %rdi
callq 0x4340
jmp 0x4336
movq %rbx, %rdi
callq 0x480f
jmp 0x4336
movq %rbx, %rdi
callq 0x40e4
jmp 0x4336
movq %rbx, %rdi
callq 0x4084
jmp 0x4336
leaq 0x5f53(%rip), %rsi      # 0xa273
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x7692
jmp 0x4336
movq %rbx, %rdi
callq 0x4584
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Ast.hpp
// Function: to_string[abi:cxx11](AstStmts*)
string to_string(AstStmts* ast) {
    int size = ast->stmts.size();
    string output = "AstStmts([";
    for (int i = 0; i < size; i++) {
        auto stmt = ast->stmts[i];
        output += to_string(stmt);
        if (i < size - 1) {
            output += ", ";
        }
    }
    output += "])";
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %r13
movq %rsi, -0x30(%rbp)
subq 0x8(%rsi), %r13
shrq $0x3, %r13
leaq 0x5d3e(%rip), %rsi      # 0xa21a
leaq -0x50(%rbp), %r15
movq %r15, %rdx
callq 0x7692
leal -0x1(%r13), %eax
movslq %eax, %r12
xorl %r14d, %r14d
testl %r13d, %r13d
cmovlel %r14d, %r13d
cmpq %r14, %r13
je 0x453e
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rsi
movq %r15, %rdi
callq 0x442d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x33b0
movq %r15, %rdi
callq 0x3110
cmpq %r12, %r14
jge 0x4539
movq %rbx, %rdi
leaq 0x5cf1(%rip), %rsi      # 0xa225
callq 0x3390
incq %r14
jmp 0x44f9
leaq 0x5ce3(%rip), %rsi      # 0xa228
movq %rbx, %rdi
callq 0x3390
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4563
jmp 0x4563
movq %rax, %r14
jmp 0x4574
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3110
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Ast.hpp
// Function: to_string[abi:cxx11](AstBlock*)
string to_string(AstBlock* ast) {
    int size = ast->stmts.size();
    string output = "AstBlock([";
    for (int i = 0; i < size; i++) {
        auto stmt = ast->stmts[i];
        output += to_string(stmt);
        if (i < size - 1) {
            output += ", ";
        }
    }
    output += "])";
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %r13
movq %rsi, -0x30(%rbp)
subq 0x8(%rsi), %r13
shrq $0x3, %r13
leaq 0x5c7c(%rip), %rsi      # 0xa22b
leaq -0x50(%rbp), %r15
movq %r15, %rdx
callq 0x7692
leal -0x1(%r13), %eax
movslq %eax, %r12
xorl %r14d, %r14d
testl %r13d, %r13d
cmovlel %r14d, %r13d
cmpq %r14, %r13
je 0x4611
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rsi
movq %r15, %rdi
callq 0x442d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x33b0
movq %r15, %rdi
callq 0x3110
cmpq %r12, %r14
jge 0x460c
movq %rbx, %rdi
leaq 0x5c1e(%rip), %rsi      # 0xa225
callq 0x3390
incq %r14
jmp 0x45cc
leaq 0x5c10(%rip), %rsi      # 0xa228
movq %rbx, %rdi
callq 0x3390
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4636
jmp 0x4636
movq %rax, %r14
jmp 0x4647
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3110
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Ast.hpp
// Function: to_expr_string[abi:cxx11](AstExpr*)
string to_expr_string(AstExpr* ast) {
    switch (ast->type) {
        case AST_TYPE_EXPR:
            return "AstExpr";
        case AST_TYPE_STMT:
            return to_expr_string((AstStmt*)ast);
        case AST_TYPE_STMTS:
            return to_expr_string((AstStmts*)ast);
        case AST_TYPE_ASSIGN:
            return to_expr_string((AstAssign*)ast);
        case AST_TYPE_NUMBER:
            return to_expr_string((AstNumber*)ast);
        case AST_TYPE_IDENT:
            return to_expr_string((AstIdent*)ast);
        case AST_TYPE_BIN_OP:
            return to_expr_string((AstBinaryOp*)ast);
        case AST_TYPE_FUNCTION_CALL:
            return to_expr_string((AstFunctionCall*)ast);
        case AST_TYPE_BLOCK:
            return to_expr_string((AstBlock*)ast);
        case AST_TYPE_IF:
            return to_expr_string((AstIf*)ast);
    }
    return "AstExpr";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x9, %rax
ja 0x497e
leaq 0x5718(%rip), %rcx      # 0xa02c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x49a5
jmp 0x499b
movq %rbx, %rdi
callq 0x4b39
jmp 0x499b
movq %rbx, %rdi
callq 0x4e35
jmp 0x499b
movq %rbx, %rdi
callq 0x49fe
jmp 0x499b
leaq 0x5927(%rip), %rsi      # 0xa273
leaq -0xa(%rbp), %rdx
jmp 0x4989
movq %rbx, %rdi
callq 0x4cbc
jmp 0x499b
movq %rbx, %rdi
callq 0x4ab7
jmp 0x499b
movq %rbx, %rdi
callq 0x4b72
jmp 0x499b
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x3290
jmp 0x499b
leaq 0x58ee(%rip), %rsi      # 0xa273
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x7692
jmp 0x499b
movq %rbx, %rdi
callq 0x4d69
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Ast.hpp
// Function: to_expr_string[abi:cxx11](AstStmts*)
string to_expr_string(AstStmts* ast) {
    string output;
    for (auto stmt : ast->stmts) {
        output += to_expr_string(stmt) + "\n";
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r13
movq 0x10(%rsi), %r15
leaq -0x48(%rbp), %r14
leaq -0x68(%rbp), %r12
cmpq %r15, %r13
je 0x4a76
movq (%r13), %rsi
movq %r14, %rdi
callq 0x49a5
movq %r12, %rdi
movq %r14, %rsi
leaq 0x5a92(%rip), %rdx      # 0xa4e2
callq 0x7442
movq %rbx, %rdi
movq %r12, %rsi
callq 0x33b0
movq %r12, %rdi
callq 0x3110
movq %r14, %rdi
callq 0x3110
addq $0x8, %r13
jmp 0x4a32
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x4aa7
movq %rax, %r14
jmp 0x4a9e
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x3110
leaq -0x48(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3110
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Ast.hpp
// Function: to_expr_string[abi:cxx11](AstBlock*)
string to_expr_string(AstBlock* ast) {
    string output = "{\n";
    for (auto stmt : ast->stmts) {
        output += to_expr_string(stmt) + "\n";
    }
    output += "\n}";
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x54f4(%rip), %rsi      # 0xa27b
leaq -0x68(%rbp), %r14
movq %r14, %rdx
callq 0x7692
movq 0x8(%r15), %r13
movq 0x10(%r15), %r12
leaq -0x48(%rbp), %r15
cmpq %r12, %r13
je 0x4de3
movq (%r13), %rsi
movq %r15, %rdi
callq 0x49a5
movq %r14, %rdi
movq %r15, %rsi
leaq 0x5725(%rip), %rdx      # 0xa4e2
callq 0x7442
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33b0
movq %r14, %rdi
callq 0x3110
movq %r15, %rdi
callq 0x3110
addq $0x8, %r13
jmp 0x4d9f
leaq 0x5494(%rip), %rsi      # 0xa27e
movq %rbx, %rdi
callq 0x3390
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4e06
movq %rax, %r14
jmp 0x4e25
movq %rax, %r14
jmp 0x4e1c
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x3110
leaq -0x48(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3110
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Ast.hpp
// Function: to_expr_string[abi:cxx11](AstBinOpType)
string to_expr_string(AstBinOpType type) {
    switch (type) {
        case AST_BIN_OP_TYPE_ADD:
            return "+";
        case AST_BIN_OP_TYPE_SUB:
            return "-";
        case AST_BIN_OP_TYPE_MUL:
            return "*";
        case AST_BIN_OP_TYPE_DIV:
            return "/";
        case AST_BIN_OP_TYPE_MOD:
            return "%";
        case AST_BIN_OP_TYPE_EXP:
            return "**";
        case AST_BIN_OP_TYPE_UNKNOWN:
            return "??";
    }
    return "AstBinOpType";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl %esi
cmpl $0x10, %esi
ja 0x4fe3
leaq 0x5087(%rip), %rax      # 0xa054
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x52c0(%rip), %rsi      # 0xa29d
leaq -0xa(%rbp), %rdx
jmp 0x503c
leaq 0x52b6(%rip), %rsi      # 0xa2a0
leaq -0x9(%rbp), %rdx
jmp 0x503c
leaq 0x52a1(%rip), %rsi      # 0xa298
leaq -0xc(%rbp), %rdx
jmp 0x503c
leaq 0x528e(%rip), %rsi      # 0xa292
leaq -0x10(%rbp), %rdx
jmp 0x503c
leaq 0x5289(%rip), %rsi      # 0xa29a
leaq -0xb(%rbp), %rdx
jmp 0x503c
leaq 0x5276(%rip), %rsi      # 0xa294
leaq -0xf(%rbp), %rdx
jmp 0x503c
leaq 0x5270(%rip), %rsi      # 0xa29b
leaq -0xe(%rbp), %rdx
jmp 0x503c
leaq 0x525e(%rip), %rsi      # 0xa296
leaq -0xd(%rbp), %rdx
movq %rbx, %rdi
callq 0x7692
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Interp.cpp
// Function: Interp::evalBinOp(AstBinaryOp*)
double Interp::evalBinOp(AstBinaryOp* bin_op) {
    double left_value = eval(bin_op->left);
    double right_value = eval(bin_op->right);

    switch (bin_op->op_type) {
        case AST_BIN_OP_TYPE_ADD:
            return left_value + right_value;
        case AST_BIN_OP_TYPE_SUB:
            return left_value - right_value;
        case AST_BIN_OP_TYPE_MUL:
            return left_value * right_value;
        case AST_BIN_OP_TYPE_DIV:
            return left_value / right_value;
        case AST_BIN_OP_TYPE_MOD:
            return fmodl(left_value, right_value);
        case AST_BIN_OP_TYPE_EXP:
            return pow(left_value, right_value);
        default:
            error("Unknown binary expression type: ");  // +
                                                        // bin_op->op_type);
            return 0.0f;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
callq 0x51b6
movsd %xmm0, -0x20(%rbp)
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x51b6
movl 0x4(%rbx), %eax
addl $-0xa, %eax
cmpl $0x5, %eax
ja 0x5182
movapd %xmm0, %xmm1
leaq 0x4f8f(%rip), %rcx      # 0xa098
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd -0x20(%rbp), %xmm0
addsd %xmm1, %xmm0
jmp 0x5167
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
fldl -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
fldl -0x30(%rbp)
fstpt 0x10(%rsp)
fstpt (%rsp)
callq 0x3050
fstpl -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
jmp 0x5167
movsd -0x20(%rbp), %xmm0
mulsd %xmm1, %xmm0
jmp 0x5167
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
jmp 0x5167
movsd -0x20(%rbp), %xmm0
subsd %xmm1, %xmm0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movsd -0x20(%rbp), %xmm0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3360
leaq 0x519a(%rip), %rsi      # 0xa323
leaq -0x58(%rbp), %rbx
leaq -0x11(%rbp), %rdx
movq %rbx, %rdi
callq 0x7692
movq %rbx, %rsi
callq 0x508c
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Interp.cpp
// Function: Interp::eval(AstExpr*)
double Interp::eval(AstExpr* expr) {
    switch (expr->type) {
        case AST_TYPE_NUMBER:
            return ((AstNumber*)expr)->value;
        case AST_TYPE_IDENT:
            return evalIdent((AstIdent*)expr);
        case AST_TYPE_BIN_OP:
            return evalBinOp((AstBinaryOp*)expr);
        case AST_TYPE_FUNCTION_CALL:
            return evalFunctionCall((AstFunctionCall*)expr);
        default:
            error(string("Unknown expression type: ") + to_string(expr->type));
            return 0.0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movl (%rsi), %eax
addl $-0x4, %eax
cmpl $0x3, %eax
ja 0x5212
leaq 0x4edd(%rip), %rcx      # 0xa0b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x8(%rbx), %xmm0
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rsi
addq $0x68, %rsp
popq %rbx
popq %rbp
jmp 0x527c
movq %rbx, %rsi
addq $0x68, %rsp
popq %rbx
popq %rbp
jmp 0x52d8
movq %rbx, %rsi
addq $0x68, %rsp
popq %rbx
popq %rbp
jmp 0x50c4
leaq 0x512b(%rip), %rsi      # 0xa344
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x7692
movl (%rbx), %esi
leaq -0x30(%rbp), %rdi
callq 0x750a
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x746b
leaq -0x70(%rbp), %rsi
callq 0x508c
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x3110
jmp 0x525c
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3110
jmp 0x526a
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Interp.cpp
// Function: Interp::evalIdent(AstIdent*)
double Interp::evalIdent(AstIdent* ast) {
    if (variables.count(ast->name)) {
        return variables.at(ast->name);
    } else if (globals.count(ast->name)) {
        return globals.at(ast->name);
    } else {
        return 0.0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x791a
testq %rax, %rax
je 0x52a7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x793e
jmp 0x52ca
leaq 0x9fba(%rip), %rdi      # 0xf268
movq %rbx, %rsi
callq 0x791a
testq %rax, %rax
je 0x52d3
leaq 0x9fa6(%rip), %rdi      # 0xf268
movq %rbx, %rsi
callq 0x798e
movsd (%rax), %xmm0
popq %rbx
popq %r14
popq %rbp
retq
xorps %xmm0, %xmm0
jmp 0x52ce
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Interp.cpp
// Function: Interp::evalFunctionCall(AstFunctionCall*)
double Interp::evalFunctionCall(AstFunctionCall* ast) {
    if (!functions.count(ast->name)) {
        // @TODO: unknown function name
        return 0.0;
    }

    auto func = functions.at(ast->name);

    return func(eval(ast->arg));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %r15
leaq 0x9fa2(%rip), %rdi      # 0xf298
movq %r15, %rsi
callq 0x79de
testq %rax, %rax
je 0x5348
leaq 0x9f8e(%rip), %rdi      # 0xf298
movq %r15, %rsi
callq 0x7a02
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x7a52
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x51b6
leaq -0x40(%rbp), %rdi
callq 0x7aa0
movsd %xmm0, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7ac6
movsd -0x20(%rbp), %xmm0
jmp 0x534b
xorps %xmm0, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x7ac6
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/philpoore[P]Math/./src/Parser.cpp
// Function: Parser::nextNonWhitespaceOffset(int)
int Parser::nextNonWhitespaceOffset(int d = 1) {
    Token t = peek(d);
    while (t.type == TOKEN_WHITESPACE) {
        d++;
        t = peek(d);
    }
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5b68
leaq -0x80(%rbp), %r12
leaq -0x88(%rbp), %r13
cmpl $0x111, -0x58(%rbp)     # imm = 0x111
jne 0x5c1f
incl %ebx
movq %r13, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5b68
movq %r15, %rdi
movq %r13, %rsi
callq 0x7cd2
movq %r12, %rdi
callq 0x3110
jmp 0x5bf2
leaq -0x50(%rbp), %rdi
callq 0x3110
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
nop