LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: DBN::DBN(Dataset, Conf)
DBN::DBN(Dataset data, Conf conf)
{
    n_samples = data.N;
    n_features = data.n_f;
    n_layers = conf.n_layers;
    n_labels = conf.n_labels;
    lamda = conf.lamda;
    alpha = conf.learning_rate;

    rbm_layers = new RBM*[n_layers];
    hidden_layer_size = new int[n_layers];
    for(int i=0; i<n_layers; i++)
    {
        hidden_layer_size[i] = conf.hidden_layer_size[i];
        if(i == 0)
        {
            rbm_layers[i] = new RBM(n_samples, n_features, hidden_layer_size[i], NULL, NULL, NULL, conf.lamda, 0.5);
        }
        else
        {
            rbm_layers[i] = new RBM(n_samples, hidden_layer_size[i-1], hidden_layer_size[i],  NULL, NULL, NULL, conf.lamda, 0.5);
        }
    }

    //logistic layer
    lr_layer = new LR(n_samples, hidden_layer_size[n_layers-1], n_labels, conf.lamda);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
movl 0x4(%rsi), %eax
movl %eax, 0x4(%rdi)
movslq 0xa0(%rdx), %rax
movl %eax, 0x8(%rdi)
movl 0xa4(%rdx), %ecx
movl %ecx, 0xc(%rdi)
movsd 0xa8(%rdx), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x98(%rdx), %xmm0
movsd %xmm0, 0x20(%rdi)
leaq (,%rax,8), %rdi
testq %rax, %rax
movq $-0x1, %rcx
cmovsq %rcx, %rdi
leaq (,%rax,4), %r15
cmovsq %rcx, %r15
callq 0x2030
movq %rax, 0x28(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x10(%rbx)
movl 0x8(%rbx), %r13d
testl %r13d, %r13d
jle 0x4f09
xorl %r12d, %r12d
movq 0x88(%r14), %rax
movl (%rax,%r12,4), %eax
movq 0x10(%rbx), %r13
movl %eax, (%r13,%r12,4)
movl $0x40, %edi
callq 0x21b0
movq %rax, %r15
movl (%rbx), %esi
testq %r12, %r12
je 0x4ec2
movl -0x4(%r13,%r12,4), %edx
movl (%r13,%r12,4), %ecx
movsd 0xa8(%r14), %xmm0
movq $0x0, (%rsp)
movq %r15, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
movsd 0x2235(%rip), %xmm1     # 0x70f0
callq 0x437c
jmp 0x4ef1
movl 0x4(%rbx), %edx
movl (%r13,%r12,4), %ecx
movsd 0xa8(%r14), %xmm0
movq $0x0, (%rsp)
movq %r15, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
movsd 0x2204(%rip), %xmm1     # 0x70f0
callq 0x437c
movq 0x28(%rbx), %rax
movq %r15, (%rax,%r12,8)
incq %r12
movslq 0x8(%rbx), %r13
cmpq %r13, %r12
jl 0x4e67
movl $0x28, %edi
callq 0x21b0
movq %rax, %r15
movq 0x10(%rbx), %rax
movslq %r13d, %rcx
movl -0x4(%rax,%rcx,4), %edx
movl (%rbx), %esi
movl 0xc(%rbx), %ecx
movsd 0xa8(%r14), %xmm0
movq %r15, %rdi
callq 0x4a40
movq %r15, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x28, %esi
jmp 0x4f5d
jmp 0x4f55
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: DBN::~DBN()
DBN::~DBN()
{
    for(int i=0; i<n_layers; i++)
        delete rbm_layers[i];
    delete[] rbm_layers;
    delete lr_layer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x644d
xorl %r15d, %r15d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x6441
movq %r14, %rdi
callq 0x4906
movl $0x40, %esi
movq %r14, %rdi
callq 0x21c0
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x641f
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x645b
callq 0x2210
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
je 0x647e
movq %rbx, %rdi
callq 0x4b12
movl $0x28, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x21c0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/main.cpp
// Function: adapteInput(MiniSat::JinkelaSat&, DIMACS::CNF::Input const&)
void adapteInput(MiniSat::JinkelaSat &Solver, const DIMACS::CNF::Input &Input) {
  for (auto &ClauseRaw : Input.getClauses()) {
    std::vector<MiniSat::Literal> Clause;
    for (int RawLit : ClauseRaw) {
      Clause.emplace_back(std::abs(RawLit) - 1, RawLit < 0);
    }
    Solver.addClause(std::move(Clause));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x8(%rsi), %r13
movq 0x10(%rsi), %rax
movq %rax, 0x28(%rsp)
cmpq %rax, %r13
je 0x24fb
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0xb(%rsp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq (%r13), %rbx
movq 0x8(%r13), %rbp
cmpq %rbp, %rbx
je 0x24cc
movl (%rbx), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
decl %ecx
movl %ecx, 0xc(%rsp)
shrl $0x1f, %eax
movb %al, 0xb(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x27e4
addq $0x4, %rbx
jmp 0x249d
movq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x281e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x24f0
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
addq $0x18, %r13
cmpq 0x28(%rsp), %r13
jne 0x2484
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x250c
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2526
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/main.cpp
// Function: to_ostream(MiniSat::JinkelaSat&, MiniSat::Status, std::ostream&)
void to_ostream(MiniSat::JinkelaSat &Solver, const MiniSat::Status Result,
                std::ostream &Out) {
  if (Result == MiniSat::Status::True) {
    Out << "SAT\n";
    size_t VarCnt = 1;
    for (auto VarStatus : Solver.getModel()) {
      Out << (VarStatus == MiniSat::Status::False ? "-" : "") << VarCnt++
          << ' ';
    }
    Out << "0\n";
  } else {
    Out << "UNSAT\n";
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpb $0x1, %sil
jne 0x25ed
movq %rdi, %r14
leaq 0x5b1f(%rip), %rsi      # 0x806f
movl $0x4, %edx
movq %rbx, %rdi
callq 0x21a0
movq 0x158(%r14), %r12
movq 0x160(%r14), %r13
cmpq %r13, %r12
je 0x25ca
xorl %r14d, %r14d
leaq 0x7(%rsp), %r15
xorl %edx, %edx
leaq (%r12,%r14), %rbp
incq %rbp
incq %r14
cmpb $0x0, -0x1(%rbp)
sete %dl
leaq 0x5ada(%rip), %rsi      # 0x806c
leaq 0x5acf(%rip), %rax      # 0x8068
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x21a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2100
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
cmpq %r13, %rbp
jne 0x2578
leaq 0x5a99(%rip), %rsi      # 0x806a
movl $0x2, %edx
movq %rbx, %rdi
callq 0x21a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5a79(%rip), %rsi      # 0x806d
movl $0x6, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/main.cpp
// Function: main
int main() {
  DIMACS::CNF::Parser Parser;
  auto Input = std::move(Parser.parse(std::cin));

  MiniSat::JinkelaSat Solver;
  adapteInput(Solver, Input);

  auto Result = Solver.solve();
  to_ostream(Solver, Result, std::cout);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq 0x99bc(%rip), %rdx      # 0xbfe0
leaq 0x28(%rsp), %rbx
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0x2a0c
movq (%rbx), %rax
leaq 0x10(%rsp), %rbx
movq %rax, -0x8(%rbx)
leaq 0x30(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x557c
movq %r15, %rdi
callq 0x50b0
xorl %r15d, %r15d
leaq 0x120(%rsp), %r12
movq %r15, -0x38(%r12)
movl %r15d, -0x30(%r12)
movl %r15d, (%r12)
movq %r15, 0x8(%r12)
leaq 0x28(%rsp), %r14
movl $0xbc, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x20c0
xorps %xmm0, %xmm0
movups %xmm0, -0x28(%r12)
movups %xmm0, -0x18(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
movq %r15, 0x20(%r12)
leaq 0x178(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movups %xmm0, 0x8(%rax)
movq %r15, 0x18(%rax)
movabsq $0x3fd5555555555555, %rcx # imm = 0x3FD5555555555555
movq %rcx, 0x20(%rax)
movabsq $0x4000000000000000, %rcx # imm = 0x4000000000000000
movq %rcx, 0x28(%rax)
movl $0x64, %ecx
movq %rcx, 0x30(%rax)
movq %rcx, 0x38(%rax)
movabsq $0x3ff8000000000000, %rcx # imm = 0x3FF8000000000000
movq %rcx, 0x40(%rax)
movabsq $0x3ff199999999999a, %rcx # imm = 0x3FF199999999999A
movq %rcx, 0x48(%rax)
movabsq $0x3fee666666666666, %rcx # imm = 0x3FEE666666666666
movq %rcx, 0x50(%rax)
movabsq $0x3feff7ced916872b, %rcx # imm = 0x3FEFF7CED916872B
movq %rcx, 0x58(%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x60(%rax)
movq %rcx, 0x68(%rax)
movl $0xffffffff, 0x88(%rax) # imm = 0xFFFFFFFF
movq %r15, 0xb0(%rax)
movups %xmm0, 0xa0(%rax)
movups %xmm0, 0x90(%rax)
movb $0x1, 0xb8(%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x244c
leaq 0x28(%rsp), %rdi
callq 0x2de4
movsbl %al, %esi
movq 0x9841(%rip), %rdx      # 0xbfd0
leaq 0x28(%rsp), %rdi
callq 0x252e
leaq 0x28(%rsp), %rdi
callq 0x2f14
movq %rbx, %rdi
callq 0x50b0
xorl %eax, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x27c6
movq %rax, %r14
movq %r15, %rdi
jmp 0x27d6
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x2f14
movq %rbx, %rdi
callq 0x50b0
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::solve()
Status solve() {
    if (!ok)
      return Status::False;
    max_learnts = nClauses() * learntsize_factor;
    learntsize_adjust_confl = learntsize_adjust_start_confl;
    learntsize_adjust_cnt = learntsize_adjust_start_confl;
    Status status = Status::Undef;
    int curr_restarts = 0;
    do {
      double rest_base = luby(restart_inc, curr_restarts);
      status = search(rest_base * restart_first);
      ++curr_restarts;
    } while (status == Status::Undef);
    model = assigns;
    cancelUntil(0);
    return status;
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %ebp, %ebp
cmpb $0x1, 0x208(%rdi)
jne 0x2f0c
movq %rdi, %rbx
movsd 0x1f0(%rdi), %xmm0
movsd 0x5216(%rip), %xmm3     # 0x8020
unpcklps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x521b(%rip), %xmm1     # 0x8030
subpd %xmm1, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
mulsd 0x170(%rdi), %xmm2
movsd %xmm2, 0x1c0(%rdi)
movq 0x188(%rdi), %rax
movq %rax, %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
subpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd %xmm1, 0x1c8(%rdi)
movq %rax, 0x1d0(%rdi)
testl %ebp, %ebp
je 0x2e82
movl $0x1, %eax
xorl %ecx, %ecx
incl %ecx
movl %eax, %esi
addl %eax, %esi
leal 0x1(,%rax,2), %eax
cmpl %ebp, %esi
jl 0x2e6f
jmp 0x2e86
xorl %esi, %esi
xorl %ecx, %ecx
movsd 0x178(%rbx), %xmm0
movl %ebp, %edx
cmpl %ebp, %esi
je 0x2ea3
sarl %esi
decl %ecx
movl %edx, %eax
cltd
idivl %esi
decl %esi
cmpl %edx, %esi
jne 0x2e94
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
callq 0x2230
movsd 0x180(%rbx), %xmm1
unpcklps 0x5162(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x516a(%rip), %xmm1     # 0x8030
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %esi
movq %rbx, %rdi
callq 0x570c
incl %ebp
cmpb $0x2, %al
je 0x2e64
movl %eax, %r14d
leaq 0x68(%rbx), %rsi
leaq 0x158(%rbx), %rdi
callq 0x59ba
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a70
movl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::newVar()
int newVar() {
    int v = next_var++;
    assigns.emplace_back(Status::Undef);
    vardata.emplace_back(nullptr, 0);
    activity.emplace_back(0);
    seen.emplace_back(0);
    polarity.emplace_back(true);
    insertVarOrder(v);
    return v;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x1e8(%rdi), %rbx
leaq 0x1(%rbx), %rax
movq %rax, 0x1e8(%rdi)
movb $0x2, 0x8(%rsp)
movq 0x70(%rdi), %rsi
cmpq 0x78(%rdi), %rsi
je 0x303e
movb $0x2, (%rsi)
incq %rsi
movq %rsi, 0x70(%r14)
jmp 0x304c
leaq 0x68(%r14), %rdi
leaq 0x8(%rsp), %rdx
callq 0x3616
leaq 0x80(%r14), %rdi
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
xorl %ebp, %ebp
leaq 0x14(%rsp), %rdx
movl %ebp, (%rdx)
movq %r15, %rsi
callq 0x350e
leaq 0x98(%r14), %rdi
movl %ebp, (%r15)
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x354c
leaq 0xd8(%r14), %rdi
movl %ebp, (%r15)
leaq 0x8(%rsp), %rsi
callq 0x3582
leaq 0xb0(%r14), %rdi
movl $0x1, %esi
callq 0x3a8e
movq %r14, %rdi
movl %ebx, %esi
callq 0x35ae
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::attachClause(MiniSat::Clause*)
void attachClause(Clause *cr) {
    const Clause &c = *cr;
    watches[~c[0]].emplace_back(cr, c[1]);
    watches[~c[1]].emplace_back(cr, c[0]);
    if (c.learnt())
      learnts_literals += c.size();
    else
      num_clauses++, clauses_literals += c.size();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
leaq 0x120(%rdi), %r12
movq (%rsi), %rax
movl (%rax), %eax
xorl $0x1, %eax
leaq 0x4(%rsp), %r13
movl %eax, (%r13)
movq %r12, %rdi
movq %r13, %rsi
callq 0x47b4
movq (%r14), %rdx
addq $0x4, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4eaa
movq (%r14), %rax
movl 0x4(%rax), %eax
xorl $0x1, %eax
movl %eax, (%r13)
leaq 0x4(%rsp), %rsi
movq %r12, %rdi
callq 0x47b4
movq (%r14), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4eaa
movl $0x200, %eax            # imm = 0x200
cmpb $0x0, 0x18(%r14)
jne 0x34f0
incq 0x1f0(%rbx)
movl $0x1f8, %eax            # imm = 0x1F8
movq 0x8(%r14), %rcx
subq (%r14), %rcx
sarq $0x2, %rcx
addq %rcx, (%rbx,%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::claBumpActivity(MiniSat::Clause&)
void claBumpActivity(Clause &c) {
    if ((c.activity() += cla_inc) > 1e20) {
      for (auto &l : learnts)
        l->activity() *= 1e-20;
      cla_inc *= 1e-20;
    }
  }

// Assembly:
movsd 0x1b0(%rdi), %xmm0
cvtss2sd 0x1c(%rsi), %xmm1
addsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, 0x1c(%rsi)
cvtss2sd %xmm1, %xmm1
ucomisd 0x215c(%rip), %xmm1     # 0x8048
jbe 0x5f34
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
cmpq %rcx, %rax
je 0x5f24
movsd 0x214d(%rip), %xmm1     # 0x8050
movq (%rax), %rdx
xorps %xmm2, %xmm2
cvtss2sd 0x1c(%rdx), %xmm2
mulsd %xmm1, %xmm2
cvtsd2ss %xmm2, %xmm2
movss %xmm2, 0x1c(%rdx)
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x5f03
mulsd 0x2124(%rip), %xmm0     # 0x8050
movsd %xmm0, 0x1b0(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::simplify()
bool simplify() {
    if (propagate() != nullptr)
      return false;
    if (int(nAssigns()) == simpDB_assigns || (simpDB_props > 0))
      return true;
    removeSatisfied(learnts);
    rebuildOrderHeap();
    simpDB_assigns = nAssigns();
    simpDB_props = clauses_literals + learnts_literals;
    return true;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x315a
movq %rax, %r14
testq %rax, %rax
jne 0x5fa3
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x2, %rax
cmpl %eax, 0x1d8(%rbx)
je 0x5fa3
cmpq $0x0, 0x1e0(%rbx)
jg 0x5fa3
leaq 0x38(%rbx), %rsi
movq %rbx, %rdi
callq 0x6c7c
movq %rbx, %rdi
callq 0x66c8
movq 0x10(%rbx), %rax
movq 0x200(%rbx), %rcx
subq 0x8(%rbx), %rax
shrq $0x2, %rax
movl %eax, 0x1d8(%rbx)
addq 0x1f8(%rbx), %rcx
movq %rcx, 0x1e0(%rbx)
testq %r14, %r14
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::reduceDB()
void reduceDB() {
    size_t j = 0;
    double extra_lim = cla_inc / learnts.size();
    std::sort(learnts.begin(), learnts.end(), reduceDB_cmp);
    for (size_t i = 0; i < learnts.size(); i++) {
      auto &c = learnts[i];
      if (c->size() > 2 && !locked(c.get()) &&
          (i < learnts.size() / 2 || c->activity() < extra_lim)) {
        removeClause(c);
      } else
        learnts[j++] = std::move(c);
    }
    learnts.resize(j);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %r15
movq 0x40(%rdi), %r14
movq %r14, %r13
subq %r15, %r13
sarq $0x3, %r13
movsd 0x1b0(%rdi), %xmm0
movsd %xmm0, (%rsp)
cmpq %r15, %r14
je 0x6014
bsrq %r13, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq 0x1120(%rip), %r12      # 0x7118
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x714a
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x72a7
leaq 0x38(%rbx), %r14
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rax
subq %rsi, %rax
je 0x611f
movq %r13, %xmm0
punpckldq 0x1fea(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1ff2(%rip), %xmm0     # 0x8030
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
sarq $0x3, %rax
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %r13d, %r13d
movq (%rsi,%r13,8), %rcx
movq (%rcx), %rdx
movq 0x8(%rcx), %rdi
subq %rdx, %rdi
cmpq $0x9, %rdi
jb 0x60d6
movl (%rdx), %edi
movl %edi, %edx
sarl %edx
movslq %edx, %rdx
movq 0x68(%rbx), %r8
movb (%r8,%rdx), %r8b
cmpb $0x2, %r8b
je 0x60ae
andb $0x1, %dil
xorb %dil, %r8b
cmpb $0x1, %r8b
jne 0x60ae
movq 0x80(%rbx), %rdi
shlq $0x4, %rdx
cmpq %rcx, (%rdi,%rdx)
je 0x60d6
shrq %rax
cmpq %rax, %r13
jb 0x60c9
xorps %xmm0, %xmm0
cvtss2sd 0x1c(%rcx), %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x60d6
addq %r12, %rsi
movq %rbx, %rdi
callq 0x6dde
jmp 0x60fe
leaq 0x1(%r15), %rbp
movq $0x0, (%rsi,%r13,8)
movq (%rsi,%r15,8), %rax
movq %rcx, (%rsi,%r15,8)
testq %rax, %rax
je 0x60fb
leaq (%rsi,%r15,8), %rdi
movq %rax, %rsi
callq 0x4e7e
movq %rbp, %r15
incq %r13
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rax
subq %rsi, %rax
sarq $0x3, %rax
addq $0x8, %r12
cmpq %rax, %r13
jb 0x6065
jmp 0x6122
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6e3a
nop
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::pickBranchLit()
Literal pickBranchLit() {
    const int VarUndef = -1;
    int next = VarUndef;
    while (next == VarUndef || value(next) != Status::Undef)
      if (order_heap.empty()) {
        next = VarUndef;
        break;
      } else {
        next = (*--order_heap.end()).second;
        order_heap.erase(--order_heap.end());
      }
    if (next == VarUndef)
      return Literal();
    return Literal(next, polarity[next]);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xf0(%rdi), %r14
leaq 0xf8(%rdi), %r15
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r12d
je 0x616e
movslq %r12d, %rax
movq 0x68(%rbx), %rcx
cmpb $0x2, (%rcx,%rax)
je 0x6197
cmpq $0x0, 0x118(%rbx)
je 0x6191
movq %r15, %rdi
callq 0x20e0
movl 0x28(%rax), %r12d
movq %r14, %rdi
movq %rax, %rsi
callq 0x793a
jmp 0x615b
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r12d
je 0x61e7
movslq %r12d, %rax
leaq 0x3f(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
sarq $0x6, %rcx
shlq $0x3, %rcx
addq 0xb0(%rbx), %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
leaq 0x3f(%rdx), %rsi
andq %rax, %rsi
xorl %eax, %eax
cmpq %rdx, %rsi
setbe %al
movq -0x8(%rcx,%rax,8), %rax
xorl %ecx, %ecx
btq %r12, %rax
setb %cl
leal (%rcx,%r12,2), %eax
jmp 0x61ec
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::varBumpActivity(int)
void varBumpActivity(int v) {
    auto ori = activity[v];
    if ((activity[v] += var_inc) > 1e100) {
      for (auto &act : activity)
        act *= 1e-100;
      var_inc *= 1e-100;
      rebuildOrderHeap();
    } else {
      if (order_heap.count({ori, v})) {
        order_heap.erase({ori, v});
        order_heap.emplace(activity[v], v);
      }
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movslq %esi, %rcx
movq 0x98(%rdi), %rax
movsd (%rax,%rcx,8), %xmm1
movsd 0x1b8(%rdi), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
ucomisd 0x1df2(%rip), %xmm0     # 0x8058
jbe 0x62ba
movq 0xa0(%rbx), %rcx
cmpq %rcx, %rax
je 0x6291
movsd 0x1de4(%rip), %xmm0     # 0x8060
movsd (%rax), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rax)
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x627c
movsd 0x1b8(%rbx), %xmm0
mulsd 0x1dbf(%rip), %xmm0     # 0x8060
movsd %xmm0, 0x1b8(%rbx)
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x66c8
leaq 0xf0(%rbx), %r14
leaq 0x10(%rsp), %rax
movsd %xmm1, 0x8(%rsp)
movsd %xmm1, (%rax)
movl %esi, 0x8(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x3e96
leaq 0xf8(%rbx), %rcx
cmpq %rcx, %rax
je 0x6330
leaq 0x10(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsi)
leaq 0x4(%rsp), %r15
movl (%r15), %eax
movl %eax, 0x8(%rsi)
movq %r14, %rdi
callq 0x6854
movq %r14, %rdi
movq %rax, %rsi
callq 0x694c
movslq (%r15), %rsi
shlq $0x3, %rsi
addq 0x98(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3f10
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::rebuildOrderHeap()
void rebuildOrderHeap() {
    order_heap.clear();
    for (size_t v = 0; v < nVars(); ++v)
      if (value(v) == Status::Undef)
        order_heap.emplace(activity[v], v);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf0(%rdi), %r14
movq %r14, %rdi
callq 0x6740
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x1e8(%rbx)
je 0x6736
xorl %esi, %esi
leaq 0x8(%rsp), %r15
movslq %esi, %rax
movq 0x68(%rbx), %rcx
cmpb $0x2, (%rcx,%rax)
jne 0x6720
shlq $0x3, %rsi
addq 0x98(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x67aa
movq 0x8(%rsp), %rsi
incq %rsi
movq %rsi, 0x8(%rsp)
cmpq 0x1e8(%rbx), %rsi
jb 0x66fd
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::removeSatisfied(std::vector<std::unique_ptr<MiniSat::Clause, std::default_delete<MiniSat::Clause>>, std::allocator<std::unique_ptr<MiniSat::Clause, std::default_delete<MiniSat::Clause>>>>&)
void removeSatisfied(std::vector<Clause::Ptr> &cs) {
    size_t j = 0;
    for (auto &c : cs) {
      if (satisfied(*c))
        removeClause(c);
      else {
        for (size_t k = 2; k < c->size(); ++k)
          if (value(c->at(k)) == Status::False) {
            c->at(k--) = c->back();
            c->pop_back();
          }
        cs[j++] = std::move(c);
      }
    }
    cs.resize(j);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r13
cmpq %r13, %r15
je 0x6dc2
movq %rdi, %r14
xorl %r12d, %r12d
movq (%r15), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
setne %sil
je 0x6d0a
movq 0x68(%r14), %rdx
movl (%rax), %esi
movl %esi, %edi
sarl %edi
movslq %edi, %rdi
movb (%rdx,%rdi), %dil
cmpb $0x2, %dil
je 0x6cd7
andb $0x1, %sil
xorb %dil, %sil
cmpb $0x1, %sil
je 0x6d0f
addq $0x4, %rax
cmpq %rcx, %rax
setne %sil
je 0x6d0a
movl (%rax), %edi
movl %edi, %r8d
sarl %r8d
movslq %r8d, %r8
movb (%rdx,%r8), %r8b
addq $0x4, %rax
cmpb $0x2, %r8b
je 0x6cdb
andb $0x1, %dil
xorb %r8b, %dil
cmpb $0x1, %dil
jne 0x6cdb
testb %sil, %sil
je 0x6d1f
movq %r14, %rdi
movq %r15, %rsi
callq 0x6dde
jmp 0x6db3
movq (%r15), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq %rdx, %rax
subq %rsi, %rax
cmpq $0x9, %rax
jb 0x6d8b
addq $0x8, %rdi
movq 0x68(%r14), %rax
movl $0x2, %ecx
movq %rdi, %r8
movl (%rsi,%rcx,4), %edi
movl %edi, %r9d
sarl %r9d
movslq %r9d, %r9
andb $0x1, %dil
cmpb %dil, (%rax,%r9)
jne 0x6d6b
movl -0x4(%rdx), %edi
addq $-0x4, %rdx
movl %edi, (%rsi,%rcx,4)
decq %rcx
movq %rdx, (%r8)
incq %rcx
movq (%r15), %rdi
leaq 0x8(%rdi), %r8
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq %rdx, %r9
subq %rsi, %r9
sarq $0x2, %r9
cmpq %r9, %rcx
jb 0x6d45
leaq 0x1(%r12), %rbp
movq (%rbx), %rax
movq $0x0, (%r15)
movq (%rax,%r12,8), %rsi
movq %rdi, (%rax,%r12,8)
testq %rsi, %rsi
je 0x6db0
leaq (%rax,%r12,8), %rdi
callq 0x4e7e
movq %rbp, %r12
addq $0x8, %r15
cmpq %r13, %r15
jne 0x6ca0
jmp 0x6dc5
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6e3a
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::removeClause(std::unique_ptr<MiniSat::Clause, std::default_delete<MiniSat::Clause>>&)
void removeClause(Clause::Ptr &cr) {
    Clause &c = *cr;
    detachClause(&c);
    if (locked(&c))
      vardata[c[0].var()].reason = nullptr;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %rsi
callq 0x6e64
movq (%r14), %rax
movl (%rax), %ecx
movl %ecx, %eax
sarl %eax
cltq
movq 0x68(%rbx), %rdx
movb (%rdx,%rax), %dl
cmpb $0x2, %dl
je 0x6e31
andb $0x1, %cl
xorb %cl, %dl
cmpb $0x1, %dl
jne 0x6e31
movq 0x80(%rbx), %rcx
shlq $0x4, %rax
cmpq %r14, (%rcx,%rax)
jne 0x6e31
movq 0x80(%rbx), %rcx
movq $0x0, (%rcx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::detachClause(MiniSat::Clause*)
void detachClause(Clause *cr) {
    const Clause &c = *cr;
    watcheErase(watches[~c[0]], cr);
    watcheErase(watches[~c[1]], cr);
    if (c.learnt())
      learnts_literals -= c.size();
    else
      num_clauses++, clauses_literals -= c.size();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x120(%rdi), %r15
movq (%rsi), %rax
movl (%rax), %eax
xorl $0x1, %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0x47b4
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x6ef6
movq (%r14), %rax
movl 0x4(%rax), %eax
xorl $0x1, %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0x47b4
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x6ef6
movl $0x200, %eax            # imm = 0x200
cmpb $0x0, 0x18(%r14)
jne 0x6edd
incq 0x1f0(%rbx)
movl $0x1f8, %eax            # imm = 0x1F8
movq 0x8(%r14), %rcx
subq (%r14), %rcx
sarq $0x2, %rcx
subq %rcx, (%rbx,%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::watcheErase(std::vector<MiniSat::JinkelaSat::Watcher, std::allocator<MiniSat::JinkelaSat::Watcher>>&, MiniSat::Clause*)
void watcheErase(std::vector<Watcher> &watche, Clause *cr) {
    auto it = std::find(watche.begin(), watche.end(), cr);
    if (it == watche.end())
      return;
    watche.erase(it);
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
movq %rax, %rdx
callq 0x6f3d
movq 0x8(%rbx), %rdx
cmpq %rdx, %rax
je 0x6f37
leaq 0x10(%rax), %rsi
cmpq %rdx, %rsi
je 0x6f32
subq %rsi, %rdx
movq %rax, %rdi
callq 0x2210
addq $-0x10, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/bauerj4[P]Riemann1D/src/Context.cpp
// Function: delimitString(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int delimitString(vector<string> &tokens, string line, string delimiter)
{
  int pos = 0;
  int newpos = 0;
  string token;
  while(1)
    {
      newpos = line.find(' ');
      token = line.substr(0,newpos);
      line.erase(0,newpos+1);

      tokens.push_back(token);
      if (newpos == string::npos)
        {
          break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movabsq $0x100000000, %rbp      # imm = 0x100000000
movq %rbx, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x2250
movq %rax, %r13
movslq %r13d, %rcx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x21e0
movq %r12, %rdi
movq %r15, %rsi
callq 0x2230
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x25f1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21d0
shlq $0x20, %r13
addq %rbp, %r13
sarq $0x20, %r13
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x2050
movq %r14, %rdi
movq %r12, %rsi
callq 0x2c04
jmp 0x25a8
jmp 0x2618
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2637
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/bauerj4[P]Riemann1D/src/Context.cpp
// Function: printContext(context_t&)
int printContext(context_t &context)
{
  printf("THE CONTEXT IS: \n");
  printf("MESH_RESOLUTION = %d\n",context.MESH_RESOLUTION);
  printf("X0 = %10.10f\n", context.X0);
  printf("X1 = %10.10f\n", context.X1);
  printf("INITIAL_DISCONTINUITY = %10.10f\n", context.INITIAL_DISCONTINUITY);
  printf("RHO_L = %10.10f\n", context.RHO_L);
  printf("P_L = %10.10f\n", context.P_L);
  printf("U_L = %10.10f\n", context.U_L);
  printf("RHO_R = %10.10f\n", context.RHO_R);
  printf("P_R = %10.10f\n", context.P_R);
  printf("U_R = %10.10f\n", context.U_R);

  printf("EVOLVE_TIME = %10.10f\n", context.EVOLVE_TIME);
  printf("CFL_NUMBER = %10.10f\n", context.CFL_NUMBER);

  cout << "SNAPSHOT_PATH = " << context.SNAPSHOT_PATH << '\n';
  cout << "SOLUTION_METHOD = " << context.SOLUTION_METHOD << '\n';

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8706(%rip), %rdi      # 0xb1c7
callq 0x2290
movl (%rbx), %esi
leaq 0x85b2(%rip), %rdi      # 0xb081
xorl %eax, %eax
callq 0x2030
movsd 0x8(%rbx), %xmm0
leaq 0x85b5(%rip), %rdi      # 0xb097
movb $0x1, %al
callq 0x2030
movsd 0x10(%rbx), %xmm0
leaq 0x85b0(%rip), %rdi      # 0xb0a5
movb $0x1, %al
callq 0x2030
movsd 0x48(%rbx), %xmm0
leaq 0x85ab(%rip), %rdi      # 0xb0b3
movb $0x1, %al
callq 0x2030
movsd 0x18(%rbx), %xmm0
leaq 0x85b9(%rip), %rdi      # 0xb0d4
movb $0x1, %al
callq 0x2030
movsd 0x38(%rbx), %xmm0
leaq 0x85b7(%rip), %rdi      # 0xb0e5
movb $0x1, %al
callq 0x2030
movsd 0x28(%rbx), %xmm0
leaq 0x85b3(%rip), %rdi      # 0xb0f4
movb $0x1, %al
callq 0x2030
movsd 0x20(%rbx), %xmm0
leaq 0x85af(%rip), %rdi      # 0xb103
movb $0x1, %al
callq 0x2030
movsd 0x40(%rbx), %xmm0
leaq 0x85ad(%rip), %rdi      # 0xb114
movb $0x1, %al
callq 0x2030
movsd 0x30(%rbx), %xmm0
leaq 0x85a9(%rip), %rdi      # 0xb123
movb $0x1, %al
callq 0x2030
movsd 0x58(%rbx), %xmm0
leaq 0x85a5(%rip), %rdi      # 0xb132
movb $0x1, %al
callq 0x2030
movsd 0x50(%rbx), %xmm0
leaq 0x85a9(%rip), %rdi      # 0xb149
movb $0x1, %al
callq 0x2030
movq 0xb42a(%rip), %r14      # 0xdfd8
leaq 0x85aa(%rip), %rsi      # 0xb15f
movq %r14, %rdi
callq 0x21a0
leaq 0x80(%rbx), %rsi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
movl $0xa, %esi
callq 0x2210
leaq 0x8590(%rip), %rsi      # 0xb170
movq %r14, %rdi
callq 0x21a0
addq $0x60, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
movq %rax, %rdi
movl $0xa, %esi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/bauerj4[P]Riemann1D/src/Fluxes.cpp
// Function: SUPERBEE(double, double)
double SUPERBEE(double r, double c)
{
  if (r <= 0 )
    {
      return 1.0;
    }
  else if(r > 0 && r <= 0.5)
    {
      return (1. - (2.*(1. - c) * r));
    }
  else if (r > 0.5 && r <= 1.0)
    {
      return c;
    }
  else if (r > 1.0 && r <= 2.0)
    {
      return (1. - ((1. - c)*r));
    }
  else if (r > 2.0)
    {
      return ((2. * c) - 1.);
    }
  /*
  else if (r!=r)
    {
      return 0;
      }*/
  
}

// Assembly:
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x3405
ucomisd %xmm2, %xmm0
jbe 0x3412
movsd 0x7eee(%rip), %xmm2     # 0xb2c8
ucomisd %xmm0, %xmm2
jb 0x3412
movsd 0x7ed8(%rip), %xmm3     # 0xb2c0
movapd %xmm3, %xmm2
subsd %xmm1, %xmm2
mulsd 0x7ee8(%rip), %xmm2     # 0xb2e0
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
movapd %xmm2, %xmm0
retq
movsd 0x7eb3(%rip), %xmm1     # 0xb2c0
movapd %xmm1, %xmm0
retq
ucomisd 0x7eae(%rip), %xmm0     # 0xb2c8
jbe 0x342a
movsd 0x7e9c(%rip), %xmm2     # 0xb2c0
ucomisd %xmm0, %xmm2
jae 0x340d
ucomisd 0x7e8e(%rip), %xmm0     # 0xb2c0
jbe 0x345c
movsd 0x7e94(%rip), %xmm2     # 0xb2d0
ucomisd %xmm0, %xmm2
jb 0x345c
movsd 0x7e76(%rip), %xmm2     # 0xb2c0
movapd %xmm2, %xmm3
subsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
subsd %xmm3, %xmm2
jmp 0x3400
addsd %xmm1, %xmm1
addsd 0x7e70(%rip), %xmm1     # 0xb2d8
jmp 0x340d
// File: /workspace/github_cpp_makefile_star2_O1/bauerj4[P]Riemann1D/src/Fluxes.cpp
// Function: MINBEE(double, double)
double MINBEE(double r, double c)
{
  if (r <= 0.)
    {
      return 1.0;
    }
  else if(r > 0. && r <= 1.) 
    {
      return (1 - (1 - c)*r);
    }
  else if(r > 1)
    {
      return c;
    }
}

// Assembly:
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x349d
ucomisd %xmm2, %xmm0
jbe 0x34a5
movsd 0x7e3e(%rip), %xmm2     # 0xb2c0
ucomisd %xmm0, %xmm2
jb 0x34a5
movapd %xmm2, %xmm3
subsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
subsd %xmm3, %xmm2
movapd %xmm2, %xmm0
retq
movsd 0x7e1b(%rip), %xmm1     # 0xb2c0
movaps %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/bauerj4[P]Riemann1D/src/Fluxes.cpp
// Function: primativeTo1DConservative(std::vector<double, std::allocator<double>>)
vector<double> primativeTo1DConservative(vector<double> primative)
{
  if (primative.size()!=3)
    {
      printf("INCORRECT PRIMATIVE VARIABLE SIZE!\n");
      return primative;
    }
  double gamma = 1.4;
  double density = primative[0];
  double velocity = primative[1];
  double pressure = primative[2];
  double conservative_2 = density * velocity;
  //primative[1] *= primative[0];
  // Compute energy from pressure
  double int_energy = pressure / (density * (gamma - 1.));
  double kinetic_energy = 0.5 * velocity * velocity;

  double conservative_3 = density * (int_energy + kinetic_energy);
  vector<double> conservative(3,0.0);
  conservative[0] = density;
  conservative[1] = conservative_2;
  conservative[2] = conservative_3;
  //primative[2] = energy * primative[0] + pow(primative[1]/primative[0],2.0);
  return conservative;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x18, %rcx
jne 0x356c
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x20(%rsp)
movl $0x18, %edi
callq 0x21c0
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, 0x10(%rax)
movq %rcx, 0x8(%rbx)
movsd 0x7dc9(%rip), %xmm0     # 0xb2e8
movapd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm2
divsd %xmm0, %xmm2
movapd %xmm1, %xmm0
movapd %xmm1, %xmm3
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
movsd 0x7d81(%rip), %xmm1     # 0xb2c8
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movapd %xmm3, %xmm0
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
mulpd 0x20(%rsp), %xmm0
movlpd %xmm3, (%rax)
movupd %xmm0, 0x8(%rax)
jmp 0x359d
movq %rsi, %r14
leaq 0x7ee5(%rip), %rdi      # 0xb45b
callq 0x2290
movupd (%r14), %xmm0
movupd %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/bauerj4[P]Riemann1D/src/Fluxes.cpp
// Function: conservativeTo1DPrimative(std::vector<double, std::allocator<double>>)
vector<double> conservativeTo1DPrimative(vector<double> conservative)
{
  double gamma = 1.4;

  if (conservative.size()!=3)
    {
      printf("INCORRECT CONSERVATIVE VARIABLE SIZE!\n");
      return conservative;
    }


  double density = conservative[0]; 
  double velocity = conservative[1] / density;
  double spec_energy = conservative[2] / density;
  //from eq of state
  double int_energy = spec_energy - 0.5 * velocity * velocity;
  double pressure = int_energy * density*(gamma -1.);

  vector<double> primative(3,0.0);
  primative[0] = density;
  primative[1] = velocity;
  primative[2] = pressure;

  return primative;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x18, %rcx
jne 0x3662
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl $0x18, %edi
callq 0x21c0
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, 0x10(%rax)
movq %rcx, 0x8(%rbx)
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
divsd %xmm1, %xmm2
movsd 0x7cc0(%rip), %xmm0     # 0xb2f0
mulsd %xmm2, %xmm0
movsd 0x10(%rsp), %xmm3
divsd %xmm1, %xmm3
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
mulsd %xmm1, %xmm0
mulsd 0x7c96(%rip), %xmm0     # 0xb2e8
movsd %xmm1, (%rax)
movsd %xmm2, 0x8(%rax)
movsd %xmm0, 0x10(%rax)
jmp 0x3693
movq %rsi, %r14
leaq 0x7e12(%rip), %rdi      # 0xb47e
callq 0x2290
movupd (%r14), %xmm0
movupd %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/bauerj4[P]Riemann1D/src/Mesh.cpp
// Function: PrintMeshData(mesh_t&)
int PrintMeshData(mesh_t &mesh)
{
  for (int k = 0; k < mesh.NCells; k++)
    {
      printf("%10.10f, %10.10f, %10.10f, %10.10f\n", mesh.FirstMeshElement[k], mesh.FirstDensityElement[k],
             mesh.FirstPressureElement[k], mesh.FirstVelocityElement[k]);
    }
  return 0;
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x9c95
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x199b(%rip), %r14      # 0xb5ee
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsd (%rax,%r15,8), %xmm0
movsd (%rcx,%r15,8), %xmm1
movq 0x18(%rbx), %rax
movsd (%rax,%r15,8), %xmm2
movq 0x20(%rbx), %rax
movsd (%rax,%r15,8), %xmm3
movq %r14, %rdi
movb $0x4, %al
callq 0x2030
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x9c53
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/bauerj4[P]Riemann1D/src/Mesh.cpp
// Function: PrintDataToFile(mesh_t&, context_t&, int)
int PrintDataToFile(mesh_t &mesh, context_t &RiemannContext, int snapno)
{
  stringstream cppPath;
  cppPath <<  RiemannContext.SNAPSHOT_PATH << snapno;
  const char * PATH = (cppPath.str()).c_str();
  FILE * f = fopen(PATH, "w");
  
  for (int i = 0; i < mesh.NCells; i++)
    {
      fprintf(f,"%10.5f %10.5f %10.5f %10.5f\n", mesh.FirstMeshElement[i], 
	      mesh.FirstDensityElement[i], mesh.FirstPressureElement[i], mesh.FirstVelocityElement[i]);
    }
  fclose(f);
  
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2120
leaq 0x38(%rsp), %rdi
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
callq 0x2200
movq %rax, %rdi
movl %ebp, %esi
callq 0x22e0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x22b0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %r14
cmpq %rax, %r14
je 0x9d08
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x21d0
leaq 0x1903(%rip), %rsi      # 0xb612
movq %r14, %rdi
callq 0x2220
movq %rax, %r14
cmpl $0x0, (%rbx)
jle 0x9d69
xorl %r12d, %r12d
leaq 0x18eb(%rip), %r15      # 0xb614
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsd (%rax,%r12,8), %xmm0
movsd (%rcx,%r12,8), %xmm1
movq 0x18(%rbx), %rax
movsd (%rax,%r12,8), %xmm2
movq 0x20(%rbx), %rax
movsd (%rax,%r12,8), %xmm3
movq %r14, %rdi
movq %r15, %rsi
movb $0x4, %al
callq 0x2260
incq %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jl 0x9d29
movq %r14, %rdi
callq 0x21b0
movq 0x4248(%rip), %rsi      # 0xdfc0
leaq 0x28(%rsp), %rdi
callq 0x2140
leaq 0xa8(%rsp), %rdi
callq 0x20a0
xorl %eax, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9da3
movq %rax, %rbx
movq 0x4213(%rip), %rsi      # 0xdfc0
leaq 0x28(%rsp), %rdi
callq 0x2140
leaq 0xa8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: GMessage(char const*, ...)
void GMessage(const char* format,...){
  #ifdef _WIN32
    char msg[4096];
    va_list arguments;
    va_start(arguments,format);
    vfprintf(stderr, format , arguments); // if a console is available
    _vsnprintf(msg, 4095, format, arguments);
    msg[4095]=0;
    va_end(arguments);
    fflush(stderr);
    //OutputDebugString(msg);
  #else
    va_list arguments;
    va_start(arguments,format);
    vfprintf(stderr,format,arguments);
    va_end(arguments);
    fflush(stderr);
  #endif
  }

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x24cf
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x11ae2(%rip), %rbx     # 0x13fd8
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x2340
movq (%rbx), %rdi
callq 0x22c0
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: GAssert(char const*, char const*, unsigned int)
void GAssert(const char* expression, const char* filename, unsigned int lineno){
  char msg[4096];
  sprintf(msg,"%s(%d): ASSERT(%s) failed.\n",filename,lineno,expression);
  fprintf(stderr,"%s",msg);
  #ifdef DEBUG
  // modify here if you [don't] want a core dump
    abort();
  #endif
  exit(1);
}

// Assembly:
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %r8
leaq 0xb791(%rip), %rsi      # 0xe004
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2080
movq 0x11751(%rip), %rax     # 0x13fd8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x22b0
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: GError(char const*, ...)
void GError(const char* format,...){
  #ifdef _WIN32
    char msg[4096];
    va_list arguments;
    va_start(arguments,format);
    _vsnprintf(msg, 4095, format, arguments);
    vfprintf(stderr, format, arguments); // if a console is available
    msg[4095]=0;
    va_end(arguments);
    OutputDebugString(msg);
    MessageBox(NULL,msg,NULL,MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL);
  #else
    va_list arguments;
    va_start(arguments,format);
    vfprintf(stderr,format,arguments);
    va_end(arguments);
    #ifdef DEBUG
     // comment this if you do NOT want a core dump
     //abort();
    #endif
  #endif
    exit(1);
  }

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x28fa
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x116b7(%rip), %rax     # 0x13fd8
movq (%rax), %rdi
movq %r10, %rsi
callq 0x2340
movl $0x1, %edi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: Gstrdup(char const*, int)
char* Gstrdup(const char* str, int xtracap) {
  if (str==NULL) return NULL;
  char *copy=NULL;
  GMALLOC(copy, strlen(str)+1+xtracap);
  strcpy(copy,str);
  return copy;
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x295d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x2140
movslq %ebp, %rdi
addq %rax, %rdi
incq %rdi
je 0x2966
callq 0x2330
movq %rax, %rdi
jmp 0x2968
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %edi, %edi
testq %rdi, %rdi
je 0x297b
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2220
leaq 0xb69e(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x289c
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: newEmptyStr()
char* newEmptyStr() {
  char* zs=NULL;
  GMALLOC(zs,1);
  zs[0]=0;
  return zs;
}

// Assembly:
pushq %rax
movl $0x1, %edi
callq 0x2330
testq %rax, %rax
je 0x299e
movb $0x0, (%rax)
popq %rcx
retq
leaq 0xb67b(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x289c
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: Gstrdup(char const*, char const*)
char* Gstrdup(const char* sfrom, const char* sto) {
  if (sfrom==NULL || sto==NULL) return NULL;
  char *copy=NULL;
  if (sfrom[0]==0 || sto<sfrom) return newEmptyStr();
  GMALLOC(copy, sto-sfrom+2);
  strncpy(copy, sfrom, sto-sfrom+1);
  copy[sto-sfrom+1]=0;
  return copy;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x29c6
xorl %r15d, %r15d
jmp 0x2a11
movq %rsi, %rbx
movq %rdi, %r14
subq %rdi, %rbx
jb 0x29ea
cmpb $0x0, (%r14)
je 0x29ea
movq %rbx, %rdi
addq $0x2, %rdi
je 0x29f4
callq 0x2330
movq %rax, %r15
jmp 0x29f7
popq %rbx
popq %r14
popq %r15
jmp 0x2989
xorl %r15d, %r15d
testq %r15, %r15
je 0x2a1a
leaq 0x1(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2180
movb $0x0, 0x1(%r15,%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb5ff(%rip), %rdi      # 0xe020
xorl %eax, %eax
callq 0x289c
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: Gstrcmp(char const*, char const*, int)
int Gstrcmp(const char* a, const char* b, int n) {
 if (a==NULL || b==NULL) {
   return a==NULL ? -1 : 1;
   }
 else {
   if (n<0) return strcmp(a,b);
       else return strncmp(a,b,n);
 }
}

// Assembly:
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x2a44
xorl %eax, %eax
cmpq $0x1, %rdi
sbbl %eax, %eax
orl $0x1, %eax
retq
testl %edx, %edx
js 0x2350
movl %edx, %edx
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/gpertea[P]gclib/GBase.cpp
// Function: to_unix_path(char*)
char *to_unix_path(char *p) {
    if (p != NULL) {
        char *pp = p;
        while (*pp != 0) {
            if (*pp == '\\')
                *pp = '/';
            ++pp;
        }
    }
    return p;
}

// Assembly:
movq %rdi, %rax
testq %rdi, %rdi
je 0x2aae
movq %rax, %rcx
movzbl (%rcx), %edx
cmpl $0x5c, %edx
je 0x2aa6
testl %edx, %edx
jne 0x2aa9
jmp 0x2aae
movb $0x2f, (%rcx)
incq %rcx
jmp 0x2a98
retq