LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
movabsq $0x3200000003, %rax     # imm = 0x3200000003
movq %rax, 0x18(%rdi)
andl $0x0, 0x20(%rdi)
movl %esi, %ebp
movl %esi, 0x24(%rdi)
movl $0x1, 0x28(%rdi)
movaps 0x58b9(%rip), %xmm0     # 0x9040
movups %xmm0, 0x40(%rdi)
xorl %r14d, %r14d
pushq $0x32
popq %rcx
pushq $0x4
popq %r13
movq %rsp, %r12
cmpl %ecx, %r14d
jge 0x386a
movl %ecx, %eax
cltd
idivl %r13d
cmpl %eax, %r14d
jge 0x37ce
movl $0x90, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x3928
jmp 0x384c
movl %ecx, %eax
cltd
pushq $0x2
popq %rsi
idivl %esi
cmpl %eax, %r14d
jge 0x37fd
movl $0x90, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
pushq $0x2
popq %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x3928
jmp 0x384c
leal (%rcx,%rcx,2), %eax
cltd
idivl %r13d
cmpl %eax, %r14d
jge 0x382b
movl $0x90, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
pushq $0x1
popq %rcx
movl %ecx, %edx
movl %ebp, %r8d
callq 0x3928
jmp 0x384c
movl $0x90, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
pushq $0x2
popq %rdx
pushq $0x1
popq %rcx
movl %ebp, %r8d
callq 0x3928
movq %r15, (%rsp)
movl %r14d, 0x30(%r15)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3ab2
incl %r14d
movl 0x1c(%rbx), %ecx
jmp 0x3798
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x387f
jmp 0x387f
jmp 0x387f
movq %rax, %r14
movl $0x90, %esi
movq %r15, %rdi
callq 0x2200
jmp 0x3894
movq %rax, %r14
movq %rbx, %rdi
callq 0x4054
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/pgrouchy[P]NoiseWorld/./mathNet.h
// Function: Genome::Genome(int, int, bool, int)
Genome(int myID, int maxDepth, bool isGrow, int isl_id) {
        Tree *new_tree;
        int i;
        pop_id = myID;
        num_trees = 0;
        fitness = 0;
        age = 0.0;
        isNan = false;

        is_alive = true;

        generateRandomPosition();
        mainGridLocation[0] = (int)((myPosition[0] + ((double)ISLAND_SIZE / 2.0)) / NN_BLOCK_SIZE);
        mainGridLocation[1] = (int)((myPosition[1] + ((double)ISLAND_SIZE / 2.0)) / NN_BLOCK_SIZE);

        for (i = 0; i < NUM_OUTPUTS; i++) {
            new_tree = new Tree(false, 0, maxDepth, isGrow, NUM_OUTPUTS, isl_id, i);

            trees.push_back(new_tree);
            tree_id_lookup.push_back(new TreeID(new_tree->tree_id));
            num_trees++;
        }

        myData = new double[num_trees];
        initialVal = new double[num_trees];
        for (i = 0; i < NUM_OUTPUTS; i++) {
            initialVal[i] = (2.0 * randfloat()) - 1.0;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rax, (%rsp)
movq %rax, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movl %esi, 0x30(%rdi)
andq $0x0, 0x34(%rdi)
movl %r8d, %r15d
andq $0x0, 0x40(%rdi)
movl %ecx, %r12d
movl %edx, %ebp
movb $0x0, 0x88(%rdi)
movb $0x1, 0x58(%rdi)
callq 0x7af8
movupd 0x68(%rbx), %xmm0
addpd 0x56c4(%rip), %xmm0     # 0x9050
mulpd 0x56cc(%rip), %xmm0     # 0x9060
cvttpd2dq %xmm0, %xmm0
movlpd %xmm0, 0x48(%rbx)
xorl %r14d, %r14d
movzbl %r12b, %r13d
cmpl $0x2, %r14d
je 0x3a14
pushq $0x38
popq %rdi
callq 0x21f0
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %ebp, %ecx
movl %r13d, %r8d
pushq $0x2
popq %r9
pushq %r14
pushq %r15
callq 0x3abe
popq %rax
popq %rcx
movq %r12, 0x8(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x3da0
pushq $0x8
popq %rdi
callq 0x21f0
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rsp)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3dac
incl 0x34(%rbx)
incl %r14d
jmp 0x39a4
movslq 0x34(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
pushq $-0x1
popq %r15
cmovnsq %rcx, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, 0x78(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x80(%rbx)
xorl %r14d, %r14d
cmpq $0x2, %r14
je 0x3a72
callq 0x3db7
addsd %xmm0, %xmm0
addsd 0x55b0(%rip), %xmm0     # 0x9010
movq 0x80(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
jmp 0x3a49
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a95
movq %rax, %r15
pushq $0x38
popq %rsi
movq %r12, %rdi
callq 0x2200
jmp 0x3a98
jmp 0x3a95
movq %rax, %r15
movq (%rsp), %rdi
callq 0x3f44
movq %rbx, %rdi
callq 0x3f6e
movq %r15, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/gkalsi[P]barbecue/test.cc
// Function: main
int main(int argc, char* argv[]) {
	BoundedBlockingQueue<int> bbq;

	vector<thread> producerThreads;
	thread consumerThread(consumer, &bbq, kNumEntries * kNumProducerThreads);

	for (int i = 0; i < kNumProducerThreads; i++) {
		producerThreads.emplace_back(producer, &bbq, kNumEntries);
	}

	consumerThread.join();
	for (int i = 0; i < kNumProducerThreads; i++) {
		producerThreads[i].join();
	}

	int nerrors = 0;
	for (const auto& result : results) {
		// Each producer thread contributes one entry.
		if (result.second != kNumProducerThreads) {
			cout << "Error. Element " << result.first << " appears " 
				 << result.second << " times, expected " << kNumProducerThreads
				 << endl;
			nerrors++;
		}
	}

	cout << "test finished with " << nerrors << " error(s)." << endl;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x2616
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x2c(%rsp), %rcx
movl $0xb71b0, (%rcx)        # imm = 0xB71B0
leaq 0x18f(%rip), %rsi       # 0x2561
movq %rsp, %rdi
callq 0x263c
pushq $0x32
popq %rbp
leaq 0x1f1(%rip), %r14       # 0x25d5
leaq 0x1c19(%rip), %r15      # 0x4004
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
subl $0x1, %ebp
jb 0x2412
movq %rbx, 0x8(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x26bc
jmp 0x23f5
movq %rsp, %rdi
callq 0x21d0
xorl %ebx, %ebx
cmpq $0x190, %rbx            # imm = 0x190
je 0x2438
movq 0x10(%rsp), %rdi
addq %rbx, %rdi
callq 0x21d0
addq $0x8, %rbx
jmp 0x241c
xorl %ebx, %ebx
movq 0x4d07(%rip), %r15      # 0x7148
leaq 0x4cf0(%rip), %r12      # 0x7138
leaq 0x1bca(%rip), %r13      # 0x4019
leaq 0x1bcd(%rip), %rbp      # 0x4023
pushq $0x32
popq %r14
cmpq %r12, %r15
je 0x24c9
cmpl $0x32, 0x24(%r15)
je 0x24bc
movq 0x4b6b(%rip), %rdi      # 0x6fd8
leaq 0x1b95(%rip), %rsi      # 0x4009
callq 0x2140
movl 0x20(%r15), %esi
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
movq %r13, %rsi
callq 0x2140
movl 0x24(%r15), %esi
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2140
movq %rax, %rdi
movl %r14d, %esi
callq 0x21e0
movq %rax, %rdi
callq 0x2090
incl %ebx
movq %r15, %rdi
callq 0x20e0
movq %rax, %r15
jmp 0x245a
movq 0x4b08(%rip), %rdi      # 0x6fd8
leaq 0x1b5e(%rip), %rsi      # 0x4035
callq 0x2140
movq %rax, %rdi
movl %ebx, %esi
callq 0x21e0
leaq 0x1b5c(%rip), %rsi      # 0x4049
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
movq %rsp, %rdi
callq 0x26f4
leaq 0x10(%rsp), %rdi
callq 0x2702
leaq 0x30(%rsp), %rdi
callq 0x2724
xorl %eax, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x253a
movq %rax, %rbx
jmp 0x2545
jmp 0x253a
jmp 0x253a
jmp 0x253a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x26f4
leaq 0x10(%rsp), %rdi
callq 0x2702
leaq 0x30(%rsp), %rdi
callq 0x2724
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
testl %esi, %esi
cmovgl %esi, %ebp
leaq 0x4bb3(%rip), %r14      # 0x7130
leaq 0x4(%rsp), %r15
pushq $0x1
popq %r13
subl $0x1, %ebp
jb 0x25c6
movq %rbx, %rdi
callq 0x2794
movl %eax, 0x4(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x308a
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x27ee
movl (%rax), %ecx
incl %ecx
leaq 0x4b7d(%rip), %rdx      # 0x7138
cmpq %rdx, %r12
cmovel %r13d, %ecx
movl %ecx, (%rax)
jmp 0x2586
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2d82
leaq 0x78(%rbx), %r15
movq 0x10(%rbx), %rax
cmpq %rax, 0x30(%rbx)
jne 0x27cd
movq %r15, %rdi
movq %r14, %rsi
callq 0x2050
jmp 0x27b6
movl (%rax), %ebp
movq %rbx, %rdi
callq 0x303a
leaq 0x8(%rsp), %rdi
callq 0x2d98
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kmichel[P]bf0x/main.cpp
// Function: main
int main(int, char*[]) {
    auto multiply = bf0x::interpreter<bf0x::bstack<bf0x::interpreter>,
         ',','>',',','>','+','+','+','+','+','+','+','+','[','<','-','-',
         '-','-','-','-','<','-','-','-','-','-','-','>','>','-',']','<',
         '<','[','>','[','>','+','>','+','<','<','-',']','>','>','[',
         '<','<','+','>','>','-',']','<','<','<','-',']','>','>','>',
         '+','+','+','+','+','+','[','<','+','+','+','+',
         '+','+','+','+','>','-',']',',','<','.','>','.'>();

    bf0x::state st;
    multiply.exec(st);

    std::cout << std::endl;
    return 0;
}

// Assembly:
pushq %rbx
subq $0x10010, %rsp          # imm = 0x10010
leaq 0xc(%rsp), %rbx
movl $0x10004, %edx          # imm = 0x10004
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1050
movq %rbx, %rdi
callq 0x11f8
movq 0x2de9(%rip), %rdi      # 0x3fd0
callq 0x1040
xorl %eax, %eax
addq $0x10010, %rsp          # imm = 0x10010
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kmichel[P]bf0x/./bf0x.hpp
// Function: bf0x::interpreter<bf0x::bstack<bf0x::loop_interpreter, bf0x::interpreter>, (char)91, (char)60, (char)60, (char)43, (char)62, (char)62, (char)45, (char)93, (char)60, (char)60, (char)60, (char)45, (char)93, (char)62, (char)62, (char)62, (char)43, (char)43, (char)43, (char)43, (char)43, (char)43, (char)91, (char)60, (char)43, (char)43, (char)43, (char)43, (char)43, (char)43, (char)43, (char)43, (char)62, (char)45, (char)93, (char)44, (char)60, (char)46, (char)62, (char)46>::exec(bf0x::state&)
static void exec(state& st) {
        BF0X_TRACE("[\n");
        while (st.data[st.pos]) {
            for (int i=0; i<bstack::size; ++i) BF0X_TRACE("  ");

            top<typename bstack::template push<loop_interpreter>::type
                , tail...>::type::exec(st);
        }
        for (int i=0; i<bstack::size-1; ++i) BF0X_TRACE("  ");
        BF0X_TRACE("]");

        top<typename bstack::template push<tail_interpreter>::type
            , tail...>::type::exec(st);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x10000(%rbx), %eax
cmpb $0x0, (%rbx,%rax)
je 0x1496
movq %rbx, %rdi
callq 0x14a4
jmp 0x1480
addl $-0x3, %eax
movl %eax, 0x10000(%rbx)
decb (%rbx,%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1acec
callq 0x1b2cf
callq 0x1b615
callq 0x1b95b
callq 0x1bf1b
callq 0x1c59d
callq 0x1cd5a
callq 0x1d630
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x26ec0
movl %eax, %ebx
testb %al, %al
je 0x1e83c
pushq $0x10
popq %rdi
callq 0x1a230
movl $0x8, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x25328
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1e38e
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x253e6
movq %r14, %rdi
movq %r15, %rsi
callq 0x27eb8
leaq 0x20(%rsp), %rdi
callq 0x2541a
leaq 0x10(%rsp), %rdi
callq 0x2541a
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2541a
jmp 0x1e85c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2541a
movq %rbx, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x26ec0
movl %eax, %ebx
testb %al, %al
je 0x1e8ea
pushq $0x10
popq %rdi
callq 0x1a230
movl $0x8, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x25328
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1e3c0
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x253e6
movq %r14, %rdi
movq %r15, %rsi
callq 0x27eb8
leaq 0x20(%rsp), %rdi
callq 0x2541a
leaq 0x10(%rsp), %rdi
callq 0x2541a
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2541a
jmp 0x1e90a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2541a
movq %rbx, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x26ec0
movl %eax, %ebx
testb %al, %al
je 0x1e998
pushq $0x10
popq %rdi
callq 0x1a230
movl $0x8, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x25328
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1e41a
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x253e6
movq %r14, %rdi
movq %r15, %rsi
callq 0x27eb8
leaq 0x20(%rsp), %rdi
callq 0x2541a
leaq 0x10(%rsp), %rdi
callq 0x2541a
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2541a
jmp 0x1e9b8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2541a
movq %rbx, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x26ec0
movl %eax, %ebx
testb %al, %al
je 0x1ecfe
pushq $0x10
popq %rdi
callq 0x1a230
movl $0x8, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x25328
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1e530
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x253e6
movq %r14, %rdi
movq %r15, %rsi
callq 0x27eb8
leaq 0x20(%rsp), %rdi
callq 0x2541a
leaq 0x10(%rsp), %rdi
callq 0x2541a
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2541a
jmp 0x1ed1e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2541a
movq %rbx, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x26ec0
movl %eax, %ebx
testb %al, %al
je 0x1ee5a
pushq $0x10
popq %rdi
callq 0x1a230
movl $0x8, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x25328
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1e59c
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x253e6
movq %r14, %rdi
movq %r15, %rsi
callq 0x27eb8
leaq 0x20(%rsp), %rdi
callq 0x2541a
leaq 0x10(%rsp), %rdi
callq 0x2541a
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2541a
jmp 0x1ee7a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2541a
movq %rbx, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x26ec0
movl %eax, %ebx
testb %al, %al
je 0x1f112
pushq $0x10
popq %rdi
callq 0x1a230
movl $0x8, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x25328
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1e6de
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x253e6
movq %r14, %rdi
movq %r15, %rsi
callq 0x27eb8
leaq 0x20(%rsp), %rdi
callq 0x2541a
leaq 0x10(%rsp), %rdi
callq 0x2541a
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2541a
jmp 0x1f132
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2541a
movq %rbx, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x26ec0
movl %eax, %ebp
testb %al, %al
je 0x1f1d3
xorl %r15d, %r15d
cmpq $0x10, %r15
je 0x1f1d3
movl (%rbx,%r15), %esi
movq %r14, %rdi
callq 0x25024
addq $0x4, %r15
jmp 0x1f1bb
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x26ec0
movl %eax, %ebp
testb %al, %al
je 0x1f237
movq 0x10(%r14), %r15
movq 0x20(%r14), %r13
movq 0x28(%r14), %r12
movq 0x30(%r14), %r14
cmpq %r14, %r15
je 0x1f237
movl (%r15), %esi
movq %rbx, %rdi
callq 0x25024
addq $0x4, %r15
cmpq %r13, %r15
jne 0x1f20c
movq 0x8(%r12), %r15
addq $0x8, %r12
leaq 0x200(%r15), %r13
jmp 0x1f20c
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_O2/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
callq 0x26ec0
movl %eax, %ebp
testb %al, %al
je 0x1f291
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movl 0x18(%rbx), %ecx
subq (%rbx), %rax
leaq (%rcx,%rax,8), %rax
cmpq %rax, %r15
jae 0x1f291
movq %rbx, %rdi
movq %r15, %rsi
callq 0x269e0
movzbl %al, %esi
movq %r14, %rdi
callq 0x26a02
incq %r15
jmp 0x1f263
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<std::vector, double, std::allocator<double>>(std::vector<double, std::allocator<double>> 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
callq 0x26ec0
movl %eax, %ebp
testb %al, %al
je 0x1f317
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x1f317
movsd (%r15), %xmm0
movq %rbx, %rdi
callq 0x256be
addq $0x8, %r15
jmp 0x1f2ff
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x26ec0
movl %eax, %ebp
testb %al, %al
je 0x1f3e2
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x1f3e2
movl 0x20(%r15), %esi
movq %r14, %rdi
callq 0x25024
movq %r15, %rdi
callq 0x1a270
movq %rax, %r15
jmp 0x1f3c4
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
callq 0x26ec0
movl %eax, %ebp
testb %al, %al
je 0x1f41e
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1f41e
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x25024
jmp 0x1f409
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x26efc
testb %al, %al
je 0x1f59e
movq 0x18(%rbx), %r15
addq $0x8, %rbx
leaq 0x8(%rsp), %r12
cmpq %rbx, %r15
sete %bpl
je 0x1f5a0
leaq 0x20(%r15), %r13
leaq 0x40(%r15), %rsi
movq %r12, %rdi
callq 0x1a2d0
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x26e14
movl %eax, %r13d
movq %r12, %rdi
callq 0x1a0d0
testb %r13b, %r13b
je 0x1f5a0
movq %r15, %rdi
callq 0x1a270
movq %rax, %r15
jmp 0x1f55a
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a0d0
movq %rbx, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x26efc
testb %al, %al
je 0x1f5fe
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
sete %bpl
je 0x1f600
leaq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
movq %r14, %rdi
callq 0x26cb0
testb %al, %al
jne 0x1f5dd
jmp 0x1f600
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1e7c0
testb %al, %al
je 0x1f726
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xecbf(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xec80(%rip), %rsi      # 0x2e3d1
leaq 0xec9a(%rip), %rdx      # 0x2e3f2
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x1e9, %ecx            # imm = 0x1E9
callq 0x26f18
xorl %ebp, %ebp
leaq 0x1b555(%rip), %rsi     # 0x3acc8
leaq 0x7804(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x1f799
jmp 0x1f7a6
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x1f7a6
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1e86e
testb %al, %al
je 0x1f7fe
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xebe7(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xeba8(%rip), %rsi      # 0x2e3d1
leaq 0xebc2(%rip), %rdx      # 0x2e3f2
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x1f3, %ecx            # imm = 0x1F3
callq 0x26f18
xorl %ebp, %ebp
leaq 0x1b47d(%rip), %rsi     # 0x3acc8
leaq 0x772c(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x1f871
jmp 0x1f87e
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x1f87e
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1e91c
testb %al, %al
je 0x1f8d6
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xeb0f(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xead0(%rip), %rsi      # 0x2e3d1
leaq 0xeaea(%rip), %rdx      # 0x2e3f2
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x1ff, %ecx            # imm = 0x1FF
callq 0x26f18
xorl %ebp, %ebp
leaq 0x1b3a5(%rip), %rsi     # 0x3acc8
leaq 0x7654(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x1f949
jmp 0x1f956
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x1f956
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1ec82
testb %al, %al
je 0x1fd0e
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xe6d7(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xe698(%rip), %rsi      # 0x2e3d1
leaq 0xe6b2(%rip), %rdx      # 0x2e3f2
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x209, %ecx            # imm = 0x209
callq 0x26f18
xorl %ebp, %ebp
leaq 0x1af6d(%rip), %rsi     # 0x3acc8
leaq 0x721c(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x1fd81
jmp 0x1fd8e
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x1fd8e
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1ed30
testb %al, %al
je 0x1fde6
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xe5ff(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xe5c0(%rip), %rsi      # 0x2e3d1
leaq 0xe5da(%rip), %rdx      # 0x2e3f2
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x213, %ecx            # imm = 0x213
callq 0x26f18
xorl %ebp, %ebp
leaq 0x1ae95(%rip), %rsi     # 0x3acc8
leaq 0x7144(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x1fe59
jmp 0x1fe66
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x1fe66
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool push(const std::string& path, const std::map<std::string, T, Compare, Alloc>& theMap, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->push(theMap))
			return true;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1edde
testb %al, %al
je 0x1febe
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xe527(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xe4e8(%rip), %rsi      # 0x2e3d1
leaq 0xe502(%rip), %rdx      # 0x2e3f2
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x21d, %ecx            # imm = 0x21D
callq 0x26f18
xorl %ebp, %ebp
leaq 0x1adbd(%rip), %rsi     # 0x3acc8
leaq 0x706c(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x1ff31
jmp 0x1ff3e
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x1ff3e
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool push(const std::string& path, const std::unordered_map<std::string, T, Hash, Pred, Alloc>& theMap, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->push(theMap))
			return true;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1f096
testb %al, %al
je 0x2021e
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xe1c7(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xe188(%rip), %rsi      # 0x2e3d1
leaq 0xe1a2(%rip), %rdx      # 0x2e3f2
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x227, %ecx            # imm = 0x227
callq 0x26f18
xorl %ebp, %ebp
leaq 0x1aa5d(%rip), %rsi     # 0x3acc8
leaq 0x6d0c(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x20291
jmp 0x2029e
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x2029e
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<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 add(const std::string& path, const std::array<T, N>& arr, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setArray(arr);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x27700
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x203d1
movq %rbx, %rsi
callq 0x1e38e
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xe032(%rip), %rsi      # 0x2e415
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xdfd5(%rip), %rsi      # 0x2e3d1
leaq 0xe00e(%rip), %rdx      # 0x2e411
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x246, %ecx            # imm = 0x246
callq 0x26f64
xorl %ebp, %ebp
leaq 0x1a912(%rip), %rsi     # 0x3ad30
leaq 0x6b59(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x20444
jmp 0x20451
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x20451
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<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 add(const std::string& path, const std::deque<T, Alloc>& deq, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setArray(deq);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x27700
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x204ab
movq %rbx, %rsi
callq 0x1e3c0
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xdf58(%rip), %rsi      # 0x2e415
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xdefb(%rip), %rsi      # 0x2e3d1
leaq 0xdf34(%rip), %rdx      # 0x2e411
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x253, %ecx            # imm = 0x253
callq 0x26f64
xorl %ebp, %ebp
leaq 0x1a838(%rip), %rsi     # 0x3ad30
leaq 0x6a7f(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x2051e
jmp 0x2052b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x2052b
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<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 add(const std::string& path, const Container<T, Alloc>& container, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setArray(container);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x27700
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x20585
movq %rbx, %rsi
callq 0x1e41a
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xde7e(%rip), %rsi      # 0x2e415
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xde21(%rip), %rsi      # 0x2e3d1
leaq 0xde5a(%rip), %rdx      # 0x2e411
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x262, %ecx            # imm = 0x262
callq 0x26f64
xorl %ebp, %ebp
leaq 0x1a75e(%rip), %rsi     # 0x3ad30
leaq 0x69a5(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x205f8
jmp 0x20605
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x20605
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380