LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/image.cpp
// Function: Image::MapX(MapFunction&, double, double)
void Image::MapX (MapFunction& f, double xoff, double yoff)
{
  double hh = height/2;
  double hw = width/2;
  double scale = f.Scale(width,height);
  //fprintf(stderr, "%f %f %f\n", xoff, yoff, scale);
  for (long y = 0; y < height; y++) {
    double y0 = (hh-y)*scale+yoff;
    f.InitY(y0);
    for (long x = 0; x < width; x++) {
      double x0 = (x-hw)*scale+xoff;
      //fprintf (stderr, "%d %d %f %f\n", x,y,x0,y0);
      SetRgb((long) y*width+x, f(x0,y0));
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %r12
movq (%rsi), %rax
movq %rsi, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *(%rax)
cmpq $0x0, 0x8(%r14)
jle 0xc1a4
movapd %xmm0, %xmm1
movq %r12, %rax
shrq $0x3f, %rax
addq %r12, %rax
sarq %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r15, %rax
shrq $0x3f, %rax
addq %r15, %rax
sarq %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
xorl %eax, %eax
movsd %xmm1, (%rsp)
movq %rax, 0x28(%rsp)
xorps %xmm2, %xmm2
cvtsi2sd %rax, %xmm2
movsd 0x18(%rsp), %xmm0
subsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
addsd 0x20(%rsp), %xmm0
movq (%r13), %rax
movq %r13, %rdi
movsd %xmm0, 0x30(%rsp)
callq *0x8(%rax)
movq (%r14), %rbp
testq %rbp, %rbp
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
jle 0xc189
movl $0x2, %ebx
xorl %r12d, %r12d
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
subsd %xmm2, %xmm0
mulsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movq (%r13), %rax
movq %r13, %rdi
movsd 0x30(%rsp), %xmm1
callq *0x10(%rax)
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
imulq %r15, %rbp
addq 0x10(%r14), %rbp
movb %al, -0x2(%rbx,%rbp)
movb %ah, -0x1(%rbx,%rbp)
shrl $0x10, %eax
movb %al, (%rbx,%rbp)
incq %r12
movq (%r14), %rbp
addq $0x3, %rbx
cmpq %rbp, %r12
jl 0xc133
movq 0x28(%rsp), %rax
incq %rax
addq $0x3, %r15
cmpq 0x8(%r14), %rax
movsd (%rsp), %xmm1
jl 0xc0e6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/image.cpp
// Function: Image::PlotPoint(double, double, int, Rgb const&)
void Image::PlotPoint(double x, double y, int r, const Rgb &rgb)
{
  //fprintf(stderr,"%g %g %g\n",x,y,r);
  for (int j = -r; j <= r; j ++) {
    for (int i = -r; i <= r; i++) {
      CheckSetRgb(long(ROUND(x+i)),long(ROUND(y+j)),rgb);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rsi, 0x10(%rsp)
testl %esi, %esi
js 0xc5a9
movq %rdx, %rbx
movq %rdi, %r15
movq 0x10(%rsp), %rax
movl %eax, %ecx
negl %ecx
leal 0x1(,%rax,2), %eax
movl %eax, 0x8(%rsp)
movl %ecx, 0xc(%rsp)
movl %ecx, %r13d
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
addsd 0x18(%rsp), %xmm0
addsd 0xf06(%rip), %xmm0      # 0xd428
callq 0x4310
cvttsd2si %xmm0, %r12
movl 0x8(%rsp), %r14d
movl 0xc(%rsp), %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
addsd 0x20(%rsp), %xmm0
addsd 0xede(%rip), %xmm0      # 0xd428
callq 0x4310
cvttsd2si %xmm0, %rcx
testq %rcx, %rcx
js 0xc590
testq %r12, %r12
js 0xc590
movq (%r15), %rax
cmpq %rcx, %rax
jle 0xc590
cmpq %r12, 0x8(%r15)
jle 0xc590
imulq %r12, %rax
addq %rcx, %rax
movq 0x10(%r15), %rcx
addq %rax, %rcx
addq %rax, %rcx
movb (%rbx), %dl
movb %dl, (%rcx,%rax)
movb 0x1(%rbx), %dl
movb %dl, 0x1(%rcx,%rax)
movb 0x2(%rbx), %dl
movb %dl, 0x2(%rcx,%rax)
incl %ebp
decl %r14d
jne 0xc535
leal 0x1(%r13), %eax
cmpl 0x10(%rsp), %r13d
movl %eax, %r13d
jne 0xc50c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/image.cpp
// Function: Image::PlotLine(double, double, LinePlotter const&, Rgb const&, int)
void Image::PlotLine(double t0, double t1, 
		     const LinePlotter& lineplotter,
		     const Rgb& color,
		     int numinitialpoints)
{
  double inc = (t1-t0)/numinitialpoints;
  for (int i = 0; i < numinitialpoints; i++) {
    PlotLineAux(t0 + i * inc, t0 + (i+1) * inc,
		lineplotter, color, 10);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
testl %ecx, %ecx
jle 0xc663
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
subsd 0x8(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
negl %ebx
xorpd %xmm1, %xmm1
movl $0x1, %r13d
movapd %xmm1, %xmm0
movsd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm3
addsd %xmm3, %xmm0
addsd 0xa27(%rip), %xmm1      # 0xd048
movsd %xmm1, 0x18(%rsp)
xorps %xmm1, %xmm1
cvtsi2sd %r13d, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0xa, %ecx
callq 0xc672
movsd 0x18(%rsp), %xmm1
leal (%rbx,%r13), %eax
incl %eax
movl %r13d, %ecx
incl %ecx
movl %ecx, %r13d
cmpl $0x1, %eax
jne 0xc601
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/shutow[P]shared_mutex/./test_util.h
// Function: rand_wait()
inline void rand_wait()
{
	//return; // no wait

	static std::random_device rd;
	static std::mt19937 gen(rd());
	static std::uniform_int_distribution<> dis(0, 1);

	std::this_thread::sleep_for(std::chrono::milliseconds(dis(gen)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movb 0x690c(%rip), %al       # 0x9500
testb %al, %al
je 0x2c7e
movb 0x7c8e(%rip), %al       # 0xa890
testb %al, %al
je 0x2ccc
movb 0x7c90(%rip), %al       # 0xa8a0
testb %al, %al
je 0x2d41
leaq 0x68e9(%rip), %rsi      # 0x9508
leaq 0x7c72(%rip), %rdi      # 0xa898
movq %rdi, %rdx
callq 0x30ac
testl %eax, %eax
jle 0x2c75
movl %eax, %eax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
shrq $0x26, %rcx
imulq $-0x3e8, %rcx, %rdx     # imm = 0xFC18
addq %rax, %rdx
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
leaq -0x20(%rbp), %rbx
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x20a0
cmpl $-0x1, %eax
jne 0x2c75
callq 0x2040
cmpl $0x4, (%rax)
je 0x2c5b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x687b(%rip), %rbx      # 0x9500
movq %rbx, %rdi
callq 0x22a0
testl %eax, %eax
je 0x2bfc
leaq 0x54dc(%rip), %rdi      # 0x8178
callq 0x2f8a
leaq 0x352(%rip), %rdi       # 0x2ffa
leaq 0x54c9(%rip), %rsi      # 0x8178
leaq 0x54aa(%rip), %rdx      # 0x8160
callq 0x2160
leaq 0x683e(%rip), %rdi      # 0x9500
callq 0x2110
jmp 0x2bfc
leaq 0x7bbd(%rip), %rbx      # 0xa890
movq %rbx, %rdi
callq 0x22a0
testl %eax, %eax
je 0x2c0a
leaq 0x548e(%rip), %rdi      # 0x8178
callq 0x21f0
movl %eax, %eax
movq %rax, 0x6810(%rip)      # 0x9508
movl $0x1, %ecx
leaq 0x6804(%rip), %rdx      # 0x9508
movq %rax, %rsi
shrq $0x1e, %rsi
xorl %eax, %esi
imull $0x6c078965, %esi, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, (%rdx,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x2d04
movq $0x270, 0x7b58(%rip) # imm = 0x270
leaq 0x7b59(%rip), %rdi      # 0xa890
callq 0x2110
jmp 0x2c0a
callq 0x22c0
jmp 0x2c18
jmp 0x2d4d
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/shutow[P]shared_mutex/./test_util.h
// Function: my_rand()
inline int my_rand()
{
	static std::random_device rd;
	static std::mt19937 gen(rd());
	static std::uniform_int_distribution<> dis(1, 1000000000);
	return dis(gen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movb 0x8ec3(%rip), %al       # 0xbc30
testb %al, %al
je 0x2da3
movb 0xa249(%rip), %al       # 0xcfc0
testb %al, %al
je 0x2dea
movb 0xa24f(%rip), %al       # 0xcfd0
testb %al, %al
je 0x2e5f
leaq 0x8ea8(%rip), %rsi      # 0xbc38
leaq 0xa231(%rip), %rdi      # 0xcfc8
movq %rdi, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x30ac
leaq 0x8e86(%rip), %rbx      # 0xbc30
movq %rbx, %rdi
callq 0x22a0
testl %eax, %eax
je 0x2d71
leaq 0x7aeb(%rip), %rdi      # 0xa8a8
callq 0x2f8a
leaq 0x231(%rip), %rdi       # 0x2ffa
leaq 0x7ad8(%rip), %rsi      # 0xa8a8
leaq 0x5389(%rip), %rdx      # 0x8160
callq 0x2160
leaq 0x8e4d(%rip), %rdi      # 0xbc30
callq 0x2110
jmp 0x2d71
leaq 0xa1cf(%rip), %rbx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
testl %eax, %eax
je 0x2d7b
leaq 0x7aa0(%rip), %rdi      # 0xa8a8
callq 0x21f0
movl %eax, %eax
movq %rax, 0x8e22(%rip)      # 0xbc38
movl $0x1, %ecx
leaq 0x8e16(%rip), %rdx      # 0xbc38
movq %rax, %rsi
shrq $0x1e, %rsi
xorl %eax, %esi
imull $0x6c078965, %esi, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, (%rdx,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x2e22
movq $0x270, 0xa16a(%rip) # imm = 0x270
leaq 0xa16b(%rip), %rdi      # 0xcfc0
callq 0x2110
jmp 0x2d7b
callq 0x22f4
jmp 0x2d89
jmp 0x2e6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/shutow[P]shared_mutex/./shared_mutex.h
// Function: gx::shared_mutex::delay()
void delay()
		{
			if (m_strategy == yield)
				std::this_thread::yield();
			else if (m_strategy == wait)
				std::this_thread::sleep_for(std::chrono::duration<uint64_t, std::micro>(m_wait_microseconds));
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x2edb
testl %eax, %eax
jne 0x2f2e
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x2210
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x2f2e
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
movq %rcx, %rax
mulq %rdx
shrq $0x12, %rdx
imulq $-0xf4240, %rdx, %rax   # imm = 0xFFF0BDC0
addq %rcx, %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
leaq -0x18(%rbp), %rbx
movq %rdx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x20a0
cmpl $-0x1, %eax
jne 0x2f2e
callq 0x2040
cmpl $0x4, (%rax)
je 0x2f14
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/shutow[P]shared_mutex/./shared_mutex.h
// Function: gx::shared_mutex::unlock_shared_and_lock()
void unlock_shared_and_lock()
		{
			bool expected = false;
			if (m_exclusive.compare_exchange_weak(expected, true, std::memory_order_acq_rel, std::memory_order_acquire))
			{
				m_counter.fetch_sub(1, std::memory_order_acq_rel);
				while (m_counter.load(std::memory_order_acquire) > 0) delay();
			}
			else // if some thread is claimed m_exclusive already and waits for m_counter == 0
			{
				int64_t num = m_priority_exclusive.fetch_add(1, std::memory_order_acq_rel) + 1;
				while (m_counter.load(std::memory_order_acquire) > num) delay();
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, %cl
xorl %eax, %eax
lock
cmpxchgb %cl, 0x18(%rdi)
jne 0x2f63
lock
decq 0x20(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
jle 0x2f85
movq %rbx, %rdi
callq 0x2ebc
jmp 0x2f50
movl $0x1, %r14d
lock
xaddq %r14, 0x10(%rbx)
incq %r14
movq 0x20(%rbx), %rax
cmpq %r14, %rax
jle 0x2f85
movq %rbx, %rdi
callq 0x2ebc
jmp 0x2f72
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/shutow[P]shared_mutex/./shared_mutex.h
// Function: gx::shared_mutex::lock()
void lock()
		{
			bool expected = false;
			while (!m_exclusive.compare_exchange_weak(expected, true, std::memory_order_acq_rel, std::memory_order_acquire))
			{
				delay();
				expected = false;
			}
			while (m_counter.load(std::memory_order_acquire) > 0) delay();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, %r14b
xorl %eax, %eax
lock
cmpxchgb %r14b, 0x18(%rdi)
je 0x3333
movq %rbx, %rdi
callq 0x2ebc
xorl %eax, %eax
lock
cmpxchgb %r14b, 0x18(%rbx)
jne 0x3317
jmp 0x3333
movq %rbx, %rdi
callq 0x2ebc
movq 0x20(%rbx), %rax
testq %rax, %rax
jg 0x332b
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/pgrouchy[P]NoiseWorld/./mathNet.h
// Function: Population::Population(int)
Population(int isl_id) {
        numInputs = NUM_INPUTS;
        pop_size = ISLAND_POP;
        bestFitSoFar = DBL_MAX;
        gen = 0;
        my_isl_id = isl_id;
        max_tree_id = NUM_OUTPUTS - 1;
        beta = 1.0;

        int counter = 0;
        Genome *new_genome;

        for (int i = 0; i < pop_size; i++) {
            // ramped half-and-half (depth 1 to 2, half grow half full)
            if (i < (pop_size/4)) {
                new_genome = new Genome(i, 1, false, isl_id);
            } else if ((i >= (pop_size/4)) && (i < (pop_size/2))) {
                new_genome = new Genome(i, 2, false, isl_id);
            } else if ((i >= (pop_size/2)) && (i < (3*pop_size/4))) {
                new_genome = new Genome(i, 1, true, isl_id);
            } else {
                new_genome = new Genome(i, 2, true, isl_id);
            }
            new_genome->pop_id = counter;
            counter++;

            genomes.push_back(new_genome);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
movabsq $0x3200000003, %rax     # imm = 0x3200000003
movq %rax, 0x18(%rdi)
movl $0x0, 0x20(%rdi)
movl %esi, 0x24(%rdi)
movl $0x1, 0x28(%rdi)
movaps 0x5db7(%rip), %xmm0     # 0xa040
movups %xmm0, 0x40(%rdi)
xorl %r14d, %r14d
movl $0x32, %eax
leal 0x3(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x2, %ecx
cmpl %ecx, %r14d
jge 0x42cc
movl $0x90, %edi
callq 0x2200
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
movl $0x1, %edx
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x447c
jmp 0x4360
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, %r14d
jge 0x42fe
movl $0x90, %edi
callq 0x2200
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
movl $0x2, %edx
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x447c
jmp 0x4360
leal (%rax,%rax,2), %ecx
leal (%rax,%rax,2), %eax
addl $0x3, %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x2, %eax
cmpl %eax, %r14d
jge 0x433b
movl $0x90, %edi
callq 0x2200
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
movl $0x1, %edx
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x447c
jmp 0x4360
movl $0x90, %edi
callq 0x2200
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
movl $0x2, %edx
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x447c
movl %r14d, 0x30(%r15)
movl $0x18, %edi
callq 0x2200
movq %r15, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2060
incq 0x10(%rbx)
incl %r14d
movl 0x1c(%rbx), %eax
cmpl %eax, %r14d
jl 0x4295
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43a1
jmp 0x43a1
jmp 0x43a1
movq %rax, %r14
movl $0x90, %esi
movq %r15, %rdi
callq 0x2210
jmp 0x43b6
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x43d3
movq (%rdi), %r15
movl $0x18, %esi
callq 0x2210
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x43be
movq %r14, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O3/gkalsi[P]barbecue/test.cc
// Function: consumer(BoundedBlockingQueue<int>*, int)
void consumer(BoundedBlockingQueue<int>* bbq, const int n) {
	for (int i = 0; i < n; ++i) {
		auto val = bbq->pop();
		if (results.find(val) == results.end()) {
			results[val] = 1;
		} else {
			results[val]++;
		}
	}
}

// Assembly:
testl %esi, %esi
jle 0x2704
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x3aba(%rip), %r15      # 0x6140
leaq 0x4(%rsp), %r12
leaq 0x3ab6(%rip), %r13      # 0x6148
movq %r14, %rdi
callq 0x28c6
movl %eax, 0x4(%rsp)
movq 0x3aab(%rip), %rcx      # 0x6150
testq %rcx, %rcx
je 0x26ce
movq %r13, %rdx
xorl %esi, %esi
cmpl %eax, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rdx
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x26ad
cmpq %r13, %rdx
je 0x26ce
cmpl 0x20(%rdx), %eax
jge 0x26e7
movq %r15, %rdi
movq %r12, %rsi
callq 0x293a
movl $0x1, (%rax)
incl %ebp
cmpl %ebx, %ebp
jne 0x2692
jmp 0x26f6
movq %r15, %rdi
movq %r12, %rsi
callq 0x293a
incl (%rax)
jmp 0x26df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gkalsi[P]barbecue/./bbq.h
// Function: BoundedBlockingQueue<int>::pop()
T pop() {
    std::unique_lock<std::mutex> lock(mutex_);
    while (queue_.empty()) {
      cv_.wait(lock);
    }
    auto result = queue_.front();
    queue_.pop();
    return result;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x50(%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x2e0a
movb $0x1, 0x8(%r14)
movq 0x10(%rbx), %rax
cmpq %rax, 0x30(%rbx)
jne 0x2919
leaq 0x78(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2060
movq 0x10(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x2904
movl (%rax), %ebp
movq %rbx, %rdi
callq 0x3066
leaq 0x8(%rsp), %rdi
callq 0x2df4
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/swxJsonAdvancedTest_modify.cpp
// Function: main
int main()
{
	advancedSetTest();
	advancedAssignTest();
	advancedPushTest();
	advancedMergeTest();
	advancedPathPushTest();
	advancedPathAddTest();
	advancedPathMergeTest();
	specialMergeAndPushTest();

	return 0;
}

// Assembly:
pushq %rax
callq 0x13e6c
callq 0x1481f
callq 0x14e32
callq 0x1543d
callq 0x15d6e
callq 0x168f4
callq 0x17762
callq 0x18698
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, 4ul>(std::array<int, 4ul> const&)
bool push(const std::array<T, N>& arr)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setArray(arr);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x19d8b
cmpl $0x8, %eax
jne 0x19dec
movq %rbx, %rdi
callq 0x249be
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x18(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x21698
movq -0x8(%r15), %rdi
movq %r14, %rsi
callq 0x19892
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x19df4
movq 0x1c1ee(%rip), %rcx     # 0x35fd0
cmpb $0x0, (%rcx)
je 0x19df0
incl 0x8(%rax)
jmp 0x19df4
xorl %eax, %eax
jmp 0x19e1f
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x24a12
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19e0e
callq 0x21762
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x19e1d
callq 0x21762
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19e40
callq 0x21762
jmp 0x19e40
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x19e4f
callq 0x21762
movq %rbx, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, std::allocator<int>>(std::deque<int, std::allocator<int>> const&)
bool push(const std::deque<T, Alloc>& deq)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setArray(deq);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x19e7b
cmpl $0x8, %eax
jne 0x19edc
movq %rbx, %rdi
callq 0x249be
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x18(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x21698
movq -0x8(%r15), %rdi
movq %r14, %rsi
callq 0x198c2
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x19ee4
movq 0x1c0fe(%rip), %rcx     # 0x35fd0
cmpb $0x0, (%rcx)
je 0x19ee0
incl 0x8(%rax)
jmp 0x19ee4
xorl %eax, %eax
jmp 0x19f0f
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x24a12
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19efe
callq 0x21762
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x19f0d
callq 0x21762
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19f30
callq 0x21762
jmp 0x19f30
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x19f3f
callq 0x21762
movq %rbx, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<std::vector, bool, std::allocator<bool>>(std::vector<bool, std::allocator<bool>> const&)
bool push(const Container<T, Alloc>& container)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setArray(container);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x19f6b
cmpl $0x8, %eax
jne 0x19fcc
movq %rbx, %rdi
callq 0x249be
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x18(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x21698
movq -0x8(%r15), %rdi
movq %r14, %rsi
callq 0x19920
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x19fd4
movq 0x1c00e(%rip), %rcx     # 0x35fd0
cmpb $0x0, (%rcx)
je 0x19fd0
incl 0x8(%rax)
jmp 0x19fd4
xorl %eax, %eax
jmp 0x19fff
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x24a12
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19fee
callq 0x21762
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x19ffd
callq 0x21762
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a020
callq 0x21762
jmp 0x1a020
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1a02f
callq 0x21762
movq %rbx, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, std::less<int>, std::allocator<int>>(std::set<int, std::less<int>, std::allocator<int>> const&)
bool push(const std::set<T, Compare, Alloc>& collections)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setArray(collections);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1a41b
cmpl $0x8, %eax
jne 0x1a47c
movq %rbx, %rdi
callq 0x249be
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x18(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x21698
movq -0x8(%r15), %rdi
movq %r14, %rsi
callq 0x19a46
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1a484
movq 0x1bb5e(%rip), %rcx     # 0x35fd0
cmpb $0x0, (%rcx)
je 0x1a480
incl 0x8(%rax)
jmp 0x1a484
xorl %eax, %eax
jmp 0x1a4af
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x24a12
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a49e
callq 0x21762
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1a4ad
callq 0x21762
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a4d0
callq 0x21762
jmp 0x1a4d0
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1a4df
callq 0x21762
movq %rbx, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>(std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>> const&)
bool push(const std::unordered_set<Key, Hash, Pred, Alloc>& collections)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setArray(collections);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1a50b
cmpl $0x8, %eax
jne 0x1a56c
movq %rbx, %rdi
callq 0x249be
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x18(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x21698
movq -0x8(%r15), %rdi
movq %r14, %rsi
callq 0x19a86
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1a574
movq 0x1ba6e(%rip), %rcx     # 0x35fd0
cmpb $0x0, (%rcx)
je 0x1a570
incl 0x8(%rax)
jmp 0x1a574
xorl %eax, %eax
jmp 0x1a59f
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x24a12
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a58e
callq 0x21762
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1a59d
callq 0x21762
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a5c0
callq 0x21762
jmp 0x1a5c0
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1a5cf
callq 0x21762
movq %rbx, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>> const&)
bool push(const std::map<std::string, T, Compare, Alloc>& theMap)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setDict(theMap);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1a5fb
cmpl $0x8, %eax
jne 0x1a65c
movq %rbx, %rdi
callq 0x249be
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x18(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x21698
movq -0x8(%r15), %rdi
movq %r14, %rsi
callq 0x19ab8
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1a664
movq 0x1b97e(%rip), %rcx     # 0x35fd0
cmpb $0x0, (%rcx)
je 0x1a660
incl 0x8(%rax)
jmp 0x1a664
xorl %eax, %eax
jmp 0x1a68f
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x24a12
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a67e
callq 0x21762
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1a68d
callq 0x21762
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a6b0
callq 0x21762
jmp 0x1a6b0
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1a6bf
callq 0x21762
movq %rbx, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>> const&)
bool push(const std::unordered_map<std::string, T, Hash, Pred, Alloc>& theMap)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setDict(theMap);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1a9bb
cmpl $0x8, %eax
jne 0x1aa1c
movq %rbx, %rdi
callq 0x249be
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x18(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x21698
movq -0x8(%r15), %rdi
movq %r14, %rsi
callq 0x19c38
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1aa24
movq 0x1b5be(%rip), %rcx     # 0x35fd0
cmpb $0x0, (%rcx)
je 0x1aa20
incl 0x8(%rax)
jmp 0x1aa24
xorl %eax, %eax
jmp 0x1aa4f
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x24a12
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1aa3e
callq 0x21762
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1aa4d
callq 0x21762
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1aa70
callq 0x21762
jmp 0x1aa70
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1aa7f
callq 0x21762
movq %rbx, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<int, 4ul>(std::array<int, 4ul> const&)
bool merge(const std::array<T, N>& arr)
	{
		bool res = canBeArray();
		if (res)
		{
			for (auto& data: arr)
				push(data);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1ab21
cmpl $0x8, %eax
jne 0x1ab3e
movq %r14, %rdi
callq 0x249be
xorl %r15d, %r15d
movslq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0x215b4
addq $0x4, %r15
cmpq $0x10, %r15
jne 0x1ab24
movb $0x1, %al
jmp 0x1ab40
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<int, std::allocator<int>>(std::deque<int, std::allocator<int>> const&)
bool merge(const std::deque<T, Alloc>& deq)
	{
		bool res = canBeArray();
		if (res)
		{
			for (auto& data: deq)
			 push(data);
		}
		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1ab6b
cmpl $0x8, %eax
jne 0x1abaf
movq %rbx, %rdi
callq 0x249be
movq 0x10(%r14), %r12
movq 0x30(%r14), %r15
movb $0x1, %bpl
cmpq %r15, %r12
je 0x1abb1
movq 0x20(%r14), %r13
movq 0x28(%r14), %r14
movslq (%r12), %rsi
movq %rbx, %rdi
callq 0x215b4
addq $0x4, %r12
cmpq %r13, %r12
jne 0x1aba8
movq 0x8(%r14), %r12
addq $0x8, %r14
leaq 0x200(%r12), %r13
cmpq %r15, %r12
jne 0x1ab83
jmp 0x1abb1
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<std::allocator<bool>>(std::vector<bool, std::allocator<bool>> const&)
bool merge(const std::vector<bool, Alloc>& container)
	{
		bool res = canBeArray();
		if (res)
		{
			for (size_t i = 0; i < container.size(); i++)
				push(container.at(i));
		}
		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1abe3
cmpl $0x8, %eax
jne 0x1ac2a
movq %r14, %rdi
callq 0x249be
movq 0x10(%rbx), %rax
subq (%rbx), %rax
movl 0x18(%rbx), %ecx
shlq $0x3, %rax
movb $0x1, %bpl
addq %rcx, %rax
je 0x1ac2c
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x23094
movzbl %al, %esi
movq %r14, %rdi
callq 0x230f4
incq %r15
movq 0x10(%rbx), %rax
movl 0x18(%rbx), %ecx
subq (%rbx), %rax
leaq (%rcx,%rax,8), %rax
cmpq %rax, %r15
jb 0x1abfc
jmp 0x1ac2c
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<std::vector, int, std::allocator<int>>(std::vector<int, std::allocator<int>> const&)
bool merge(const Container<T, Alloc>& container)
	{
		bool res = canBeArray();
		if (res)
		{
			for (auto& data: container)
				push(data);
		}
		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1ac5b
cmpl $0x8, %eax
jne 0x1ac7b
movq %rbx, %rdi
callq 0x249be
movq (%r14), %r15
movq 0x8(%r14), %r14
movb $0x1, %bpl
cmpq %r14, %r15
je 0x1ac7d
movslq (%r15), %rsi
movq %rbx, %rdi
callq 0x215b4
addq $0x4, %r15
jmp 0x1ac65
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<int, std::less<int>, std::allocator<int>>(std::set<int, std::less<int>, std::allocator<int>> const&)
bool merge(const std::set<T, Compare, Alloc>& collections)
	{
		bool res = canBeArray();
		if (res)
		{
			for (auto& data: collections)
				push(data);
		}
		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1ad99
cmpl $0x8, %eax
jne 0x1adc7
movq %r14, %rdi
callq 0x249be
movq 0x18(%rbx), %r15
addq $0x8, %rbx
movb $0x1, %bpl
cmpq %rbx, %r15
je 0x1adc9
movslq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x215b4
movq %r15, %rdi
callq 0x13270
movq %rax, %r15
cmpq %rbx, %rax
jne 0x1ada9
jmp 0x1adc9
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>(std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>> const&)
bool merge(const std::unordered_set<Key, Hash, Pred, Alloc>& collections)
	{
		bool res = canBeArray();
		if (res)
		{
			for (auto& data: collections)
				push(data);
		}
		return res;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x1adf4
cmpl $0x8, %eax
jne 0x1ae11
movq %rbx, %rdi
callq 0x249be
movq 0x10(%r14), %r14
movb $0x1, %bpl
testq %r14, %r14
je 0x1ae13
movslq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x215b4
movq (%r14), %r14
jmp 0x1adfb
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::map<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::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
bool merge(const std::map<std::string, T, Compare, Alloc>& theMap)
	{
		bool res = canBeObject();
		if (!res) return false;
		
		for (auto& dataPair: theMap)
		{
			if (addBasicValue(dataPair.first, dataPair.second) == false)
				return false;
		}
		return true;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
testl %eax, %eax
je 0x1af81
cmpl $0x8, %eax
jne 0x1aff8
movq %r14, %rdi
callq 0x24504
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x1affc
leaq 0x18(%rsp), %r13
leaq 0x20(%r15), %r12
movq %r13, 0x8(%rsp)
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x1ef32
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x23594
movl %eax, %ebp
movq 0x8(%rsp), %rdi
movq %r13, %r12
cmpq %r13, %rdi
je 0x1afde
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
je 0x1afff
movq %r15, %rdi
callq 0x13270
movq %rax, %r15
cmpq %rbx, %rax
movq %r12, %r13
jne 0x1af93
jmp 0x1afff
xorl %ebp, %ebp
jmp 0x1afff
movb $0x1, %bpl
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b02a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x13220
movq %rbx, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>> const&)
bool merge(const std::unordered_map<std::string, T, Hash, Pred, Alloc>& theMap)
	{
		bool res = canBeObject();
		if (!res) return false;
		for (auto& dataPair: theMap)
		{
			if (addBasicValue(dataPair.first, dataPair.second) == false)
				return false;
		}
		return true;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
testl %eax, %eax
je 0x1b04f
cmpl $0x8, %eax
jne 0x1b074
movq %r14, %rdi
callq 0x24504
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
sete %bpl
je 0x1b076
leaq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
movq %r14, %rdi
callq 0x233c8
testb %al, %al
jne 0x1b053
jmp 0x1b076
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, 4ul>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::array<int, 4ul> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool push(const std::string& path, const std::array<T, N>& arr, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->push(arr))
			return true;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x19d68
testb %al, %al
je 0x1b1df
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b1d2
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10206(%rip), %rsi     # 0x2b402
leaq 0x10218(%rip), %rdx     # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0x101c5(%rip), %rsi     # 0x2b3dc
leaq 0x101df(%rip), %rdx     # 0x2b3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x1e9, %ecx            # imm = 0x1E9
callq 0x2ac94
leaq 0x1aa99(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1aa71(%rip), %rsi     # 0x35cb8
leaq 0x8464(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b270
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1b27a
jmp 0x1b287
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1b287
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b296
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, std::allocator<int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::deque<int, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool push(const std::string& path, const std::deque<T, Alloc>& deq, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->push(deq))
			return true;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x19e58
testb %al, %al
je 0x1b2ef
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b2e2
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x100f6(%rip), %rsi     # 0x2b402
leaq 0x10108(%rip), %rdx     # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0x100b5(%rip), %rsi     # 0x2b3dc
leaq 0x100cf(%rip), %rdx     # 0x2b3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x1f3, %ecx            # imm = 0x1F3
callq 0x2ac94
leaq 0x1a989(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1a961(%rip), %rsi     # 0x35cb8
leaq 0x8354(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b380
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1b38a
jmp 0x1b397
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1b397
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b3a6
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<std::vector, bool, std::allocator<bool>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<bool, std::allocator<bool>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool push(const std::string& path, const Container<T, Alloc>& container, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->push(container))
			return true;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x19f48
testb %al, %al
je 0x1b3ff
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b3f2
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xffe6(%rip), %rsi      # 0x2b402
leaq 0xfff8(%rip), %rdx      # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xffa5(%rip), %rsi      # 0x2b3dc
leaq 0xffbf(%rip), %rdx      # 0x2b3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x1ff, %ecx            # imm = 0x1FF
callq 0x2ac94
leaq 0x1a879(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1a851(%rip), %rsi     # 0x35cb8
leaq 0x8244(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b490
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1b49a
jmp 0x1b4a7
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1b4a7
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b4b6
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, std::less<int>, std::allocator<int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::set<int, std::less<int>, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool push(const std::string& path, const std::set<T, Compare, Alloc>& collections, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->push(collections))
			return true;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1a3f8
testb %al, %al
je 0x1b94f
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b942
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xfa96(%rip), %rsi      # 0x2b402
leaq 0xfaa8(%rip), %rdx      # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xfa55(%rip), %rsi      # 0x2b3dc
leaq 0xfa6f(%rip), %rdx      # 0x2b3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x209, %ecx            # imm = 0x209
callq 0x2ac94
leaq 0x1a329(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1a301(%rip), %rsi     # 0x35cb8
leaq 0x7cf4(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b9e0
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1b9ea
jmp 0x1b9f7
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1b9f7
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ba06
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool push(const std::string& path, const std::unordered_set<Key, Hash, Pred, Alloc>& collections, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->push(collections))
			return true;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1a4e8
testb %al, %al
je 0x1ba5f
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ba52
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf986(%rip), %rsi      # 0x2b402
leaq 0xf998(%rip), %rdx      # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xf945(%rip), %rsi      # 0x2b3dc
leaq 0xf95f(%rip), %rdx      # 0x2b3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x213, %ecx            # imm = 0x213
callq 0x2ac94
leaq 0x1a219(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1a1f1(%rip), %rsi     # 0x35cb8
leaq 0x7be4(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1baf0
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1bafa
jmp 0x1bb07
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1bb07
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bb16
callq 0x21762
movq %r14, %rdi
callq 0x13380