LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: WojciechMula[P]utf16utf8/include/reference.h
// Function: utf16_to_utf8(unsigned short const*, unsigned char*)
static inline uint8_t *utf16_to_utf8(const uint16_t *utf16, uint8_t *utf8)
{
	size_t i, j;
	uint32_t c;

	if (utf16==NULL)
		return NULL;

	if (utf8==NULL)
		utf8 = (uint8_t*)calloc(strlen_utf16_to_utf8(utf16) + 1, sizeof(uint8_t));

	for (i=0, j=0, c=1; c; i++)
	{
		c = utf16_to_unicode32(&utf16[i], &i);
		sprint_unicode(&utf8[j], c);
		j += codepoint_utf8_size(c);
	}

	return utf8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc814
movq $0x0, -0x8(%rbp)
jmp 0xc8a8
cmpq $0x0, -0x18(%rbp)
jne 0xc839
movq -0x10(%rbp), %rdi
callq 0xd930
movq %rax, %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x20f0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xc8a0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
shlq %rax
addq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0xd9b0
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
addq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0xda50
movl -0x2c(%rbp), %edi
callq 0xdbd0
cltq
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xc850
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate_no_surrogates()
bool validate_no_surrogates() {
    puts("Test transcoding random string (without surrogates)");
    std::random_device rd{};
    RandomUTF16 generator(rd,
        /* 1 byte */  1,
        /* 2 bytes */ 1,
        /* 3 bytes */ 1,
        /* 4 bytes */ 0
    );
    for(size_t t = 0; t < 10000; t++) {
      const auto UTF16 = generator.generate(512);
      const size_t size = UTF16.size() - 1;
      if(!validate(UTF16, size)) {
          return false;
      }
      if(!validate_hybrid(UTF16, size)) {
          return false;
      }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x27d0, %rsp           # imm = 0x27D0
leaq 0x87ac(%rip), %rdi      # 0x152fe
callq 0x2240
leaq -0x1390(%rbp), %rdi
movq %rdi, -0x27b8(%rbp)
callq 0xe130
movq -0x27b8(%rbp), %rsi
leaq -0x2770(%rbp), %rdi
movl $0x1, %r8d
xorl %r9d, %r9d
movl %r8d, %edx
movl %r8d, %ecx
callq 0x2430
jmp 0xcb8e
movq $0x0, -0x2788(%rbp)
cmpq $0x2710, -0x2788(%rbp) # imm = 0x2710
jae 0xccde
leaq -0x27a0(%rbp), %rdi
leaq -0x2770(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x2670
jmp 0xcbc4
leaq -0x27a0(%rbp), %rdi
movq %rdi, -0x27c8(%rbp)
callq 0x2a30
movq -0x27c8(%rbp), %rdi
decq %rax
movq %rax, -0x27a8(%rbp)
movq -0x27a8(%rbp), %rsi
callq 0xc570
movb %al, -0x27b9(%rbp)
jmp 0xcbfc
movb -0x27b9(%rbp), %al
testb $0x1, %al
jne 0xcc6c
jmp 0xcc08
movb $0x0, -0x1(%rbp)
movl $0x1, -0x27ac(%rbp)
jmp 0xccad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2778(%rbp)
movl %eax, -0x277c(%rbp)
jmp 0xcd1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2778(%rbp)
movl %eax, -0x277c(%rbp)
jmp 0xcd12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2778(%rbp)
movl %eax, -0x277c(%rbp)
leaq -0x27a0(%rbp), %rdi
callq 0x2af0
jmp 0xcd12
movq -0x27a8(%rbp), %rsi
leaq -0x27a0(%rbp), %rdi
callq 0xc8c0
movb %al, -0x27c9(%rbp)
jmp 0xcc87
movb -0x27c9(%rbp), %al
testb $0x1, %al
jne 0xcca3
jmp 0xcc93
movb $0x0, -0x1(%rbp)
movl $0x1, -0x27ac(%rbp)
jmp 0xccad
movl $0x0, -0x27ac(%rbp)
leaq -0x27a0(%rbp), %rdi
callq 0x2af0
movl -0x27ac(%rbp), %eax
testl %eax, %eax
jne 0xccec
jmp 0xccc5
jmp 0xccc7
movq -0x2788(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x2788(%rbp)
jmp 0xcb99
movb $0x1, -0x1(%rbp)
movl $0x1, -0x27ac(%rbp)
leaq -0x2770(%rbp), %rdi
callq 0xe1d0
leaq -0x1390(%rbp), %rdi
callq 0xe200
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x27d0, %rsp           # imm = 0x27D0
popq %rbp
retq
leaq -0x2770(%rbp), %rdi
callq 0xe1d0
leaq -0x1390(%rbp), %rdi
callq 0xe200
movq -0x2778(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate_surrogates()
bool validate_surrogates() {
    puts("Test transcoding random string (only surrogates)");
    std::random_device rd{};
    RandomUTF16 generator(rd,
        /* 1 byte */  0,
        /* 2 bytes */ 0,
        /* 3 bytes */ 0,
        /* 4 bytes */ 1
    );
    for(size_t t = 0; t < 10000; t++) {
      const long seed = 1;
      const auto UTF16 = generator.generate(512, seed);
      const size_t size = UTF16.size() - 1;

      return validate(UTF16, size) && validate_hybrid(UTF16, size);
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x27e0, %rsp           # imm = 0x27E0
leaq 0x85e0(%rip), %rdi      # 0x15332
callq 0x2240
leaq -0x1390(%rbp), %rdi
movq %rdi, -0x27c0(%rbp)
callq 0xe130
movq -0x27c0(%rbp), %rsi
leaq -0x2770(%rbp), %rdi
xorl %r8d, %r8d
movl $0x1, %r9d
movl %r8d, %edx
movl %r8d, %ecx
callq 0x2430
jmp 0xcd8e
movq $0x0, -0x2788(%rbp)
cmpq $0x2710, -0x2788(%rbp) # imm = 0x2710
jae 0xceb5
movq $0x1, -0x2790(%rbp)
leaq -0x27a8(%rbp), %rdi
leaq -0x2770(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
movl $0x1, %ecx
callq 0x2780
jmp 0xcdd4
leaq -0x27a8(%rbp), %rdi
movq %rdi, -0x27d0(%rbp)
callq 0x2a30
movq -0x27d0(%rbp), %rdi
decq %rax
movq %rax, -0x27b0(%rbp)
movq -0x27b0(%rbp), %rsi
callq 0xc570
movb %al, -0x27c1(%rbp)
jmp 0xce0c
movb -0x27c1(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x27d1(%rbp)
jne 0xce21
jmp 0xce4a
movq -0x27b0(%rbp), %rsi
leaq -0x27a8(%rbp), %rdi
callq 0xc8c0
movb %al, -0x27d2(%rbp)
jmp 0xce3c
movb -0x27d2(%rbp), %al
movb %al, -0x27d1(%rbp)
jmp 0xce4a
movb -0x27d1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x27b4(%rbp)
leaq -0x27a8(%rbp), %rdi
callq 0x2af0
jmp 0xcec3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2778(%rbp)
movl %eax, -0x277c(%rbp)
jmp 0xcef5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2778(%rbp)
movl %eax, -0x277c(%rbp)
jmp 0xcee9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2778(%rbp)
movl %eax, -0x277c(%rbp)
leaq -0x27a8(%rbp), %rdi
callq 0x2af0
jmp 0xcee9
movb $0x1, -0x1(%rbp)
movl $0x1, -0x27b4(%rbp)
leaq -0x2770(%rbp), %rdi
callq 0xe1d0
leaq -0x1390(%rbp), %rdi
callq 0xe200
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x27e0, %rsp           # imm = 0x27E0
popq %rbp
retq
leaq -0x2770(%rbp), %rdi
callq 0xe1d0
leaq -0x1390(%rbp), %rdi
callq 0xe200
movq -0x2778(%rbp), %rdi
callq 0x2280
nopl (%rax)
// File: WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate_all()
bool validate_all() {
    puts("Validate all input values");
    std::vector<uint16_t> input;
    input.resize(8 + 1);

    for (uint16_t value=1; value <= 0x0800; value++) {
        if (value >= 0xd800 && value <= 0xdfff) // skip reserved values
            continue;

        for (int i=0; i < 8; i++)
            input[i] = value;

        if (!validate(input, 8)) {
            printf("Failed for %04x\n", value);
            return false;
        }
        if (!validate_hybrid(input, 8)) {
            printf("Failed for %04x\n", value);
            return false;
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x8444(%rip), %rdi      # 0x15363
callq 0x2240
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2920
movq -0x40(%rbp), %rdi
movl $0x9, %esi
callq 0xe230
jmp 0xcf41
movw $0x1, -0x2e(%rbp)
movzwl -0x2e(%rbp), %eax
cmpl $0x800, %eax            # imm = 0x800
jg 0xd04c
movzwl -0x2e(%rbp), %eax
cmpl $0xd800, %eax           # imm = 0xD800
jl 0xcf8b
movzwl -0x2e(%rbp), %eax
cmpl $0xdfff, %eax           # imm = 0xDFFF
jg 0xcf8b
jmp 0xd03b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2af0
jmp 0xd06b
movl $0x0, -0x34(%rbp)
cmpl $0x8, -0x34(%rbp)
jge 0xcfbf
movw -0x2e(%rbp), %ax
movw %ax, -0x42(%rbp)
movslq -0x34(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xe2c0
movw -0x42(%rbp), %cx
movw %cx, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xcf92
leaq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0xc570
movb %al, -0x43(%rbp)
jmp 0xcfd2
movb -0x43(%rbp), %al
testb $0x1, %al
jne 0xcffc
jmp 0xcfdb
movzwl -0x2e(%rbp), %esi
leaq 0x8397(%rip), %rdi      # 0x1537d
xorl %eax, %eax
callq 0x2030
jmp 0xcfef
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0xd057
leaq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0xc8c0
movb %al, -0x44(%rbp)
jmp 0xd00f
movb -0x44(%rbp), %al
testb $0x1, %al
jne 0xd039
jmp 0xd018
movzwl -0x2e(%rbp), %esi
leaq 0x835a(%rip), %rdi      # 0x1537d
xorl %eax, %eax
callq 0x2030
jmp 0xd02c
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0xd057
jmp 0xd03b
movw -0x2e(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x2e(%rbp)
jmp 0xcf47
movb $0x1, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2af0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate_no_surrogates_from_utf8()
bool validate_no_surrogates_from_utf8() {
    puts("Test transcoding random string from utf8 (without surrogates)");
    std::random_device rd{};
    RandomUTF8 generator(rd,
        /* 1 byte */  1,
        /* 2 bytes */ 1,
        /* 3 bytes */ 1,
        /* 4 bytes */ 0
    );
    for(size_t t = 0; t < 10000; t++) {
      auto UTF8 = generator.generate(512);
      if(!validate_from_utf8(UTF8)) {
          return false;
      }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x27a0, %rsp           # imm = 0x27A0
leaq 0x7e36(%rip), %rdi      # 0x153a8
callq 0x2240
leaq -0x1390(%rbp), %rdi
movq %rdi, -0x2798(%rbp)
callq 0xe130
movq -0x2798(%rbp), %rsi
leaq -0x2758(%rbp), %rdi
movl $0x1, %r8d
xorl %r9d, %r9d
movl %r8d, %edx
movl %r8d, %ecx
callq 0x5b60
jmp 0xd5ae
movq $0x0, -0x2770(%rbp)
cmpq $0x2710, -0x2770(%rbp) # imm = 0x2710
jae 0xd69d
leaq -0x2788(%rbp), %rdi
leaq -0x2758(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x5ca0
jmp 0xd5e4
leaq -0x2788(%rbp), %rdi
callq 0xd080
movb %al, -0x2799(%rbp)
jmp 0xd5f8
movb -0x2799(%rbp), %al
testb $0x1, %al
jne 0xd662
jmp 0xd604
movb $0x0, -0x1(%rbp)
movl $0x1, -0x278c(%rbp)
jmp 0xd66c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2760(%rbp)
movl %eax, -0x2764(%rbp)
jmp 0xd6dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2760(%rbp)
movl %eax, -0x2764(%rbp)
jmp 0xd6d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2760(%rbp)
movl %eax, -0x2764(%rbp)
leaq -0x2788(%rbp), %rdi
callq 0x63b0
jmp 0xd6d1
movl $0x0, -0x278c(%rbp)
leaq -0x2788(%rbp), %rdi
callq 0x63b0
movl -0x278c(%rbp), %eax
testl %eax, %eax
jne 0xd6ab
jmp 0xd684
jmp 0xd686
movq -0x2770(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x2770(%rbp)
jmp 0xd5b9
movb $0x1, -0x1(%rbp)
movl $0x1, -0x278c(%rbp)
leaq -0x2758(%rbp), %rdi
callq 0xe4c0
leaq -0x1390(%rbp), %rdi
callq 0xe200
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x27a0, %rsp           # imm = 0x27A0
popq %rbp
retq
leaq -0x2758(%rbp), %rdi
callq 0xe4c0
leaq -0x1390(%rbp), %rdi
callq 0xe200
movq -0x2760(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate_with_surrogates_from_utf8()
bool validate_with_surrogates_from_utf8() {
    puts("Test transcoding random string from utf8 (with surrogates)");
    std::random_device rd{};
    RandomUTF8 generator(rd,
        /* 1 byte */  1,
        /* 2 bytes */ 1,
        /* 3 bytes */ 1,
        /* 4 bytes */ 1
    );
    for(size_t t = 0; t < 10000; t++) {
      auto UTF8 = generator.generate(512);
      if(!validate_from_utf8(UTF8)) {
          return false;
      }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x27a0, %rsp           # imm = 0x27A0
leaq 0x7cd4(%rip), %rdi      # 0x153e6
callq 0x2240
leaq -0x1390(%rbp), %rdi
movq %rdi, -0x2798(%rbp)
callq 0xe130
movq -0x2798(%rbp), %rsi
leaq -0x2758(%rbp), %rdi
movl $0x1, %r9d
movl %r9d, %edx
movl %r9d, %ecx
movl %r9d, %r8d
callq 0x5b60
jmp 0xd74e
movq $0x0, -0x2770(%rbp)
cmpq $0x2710, -0x2770(%rbp) # imm = 0x2710
jae 0xd83d
leaq -0x2788(%rbp), %rdi
leaq -0x2758(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x5ca0
jmp 0xd784
leaq -0x2788(%rbp), %rdi
callq 0xd080
movb %al, -0x2799(%rbp)
jmp 0xd798
movb -0x2799(%rbp), %al
testb $0x1, %al
jne 0xd802
jmp 0xd7a4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x278c(%rbp)
jmp 0xd80c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2760(%rbp)
movl %eax, -0x2764(%rbp)
jmp 0xd87d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2760(%rbp)
movl %eax, -0x2764(%rbp)
jmp 0xd871
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2760(%rbp)
movl %eax, -0x2764(%rbp)
leaq -0x2788(%rbp), %rdi
callq 0x63b0
jmp 0xd871
movl $0x0, -0x278c(%rbp)
leaq -0x2788(%rbp), %rdi
callq 0x63b0
movl -0x278c(%rbp), %eax
testl %eax, %eax
jne 0xd84b
jmp 0xd824
jmp 0xd826
movq -0x2770(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x2770(%rbp)
jmp 0xd759
movb $0x1, -0x1(%rbp)
movl $0x1, -0x278c(%rbp)
leaq -0x2758(%rbp), %rdi
callq 0xe4c0
leaq -0x1390(%rbp), %rdi
callq 0xe200
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x27a0, %rsp           # imm = 0x27A0
popq %rbp
retq
leaq -0x2758(%rbp), %rdi
callq 0xe4c0
leaq -0x1390(%rbp), %rdi
callq 0xe200
movq -0x2760(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: main
int main() {

    if(!validate_no_surrogates_from_utf8())
        return EXIT_FAILURE;

    if(!validate_with_surrogates_from_utf8())
        return EXIT_FAILURE;

    if (!validate_all())
        return EXIT_FAILURE;

    if (!validate_no_surrogates())
        return EXIT_FAILURE;

    if (!validate_surrogates())
        return EXIT_FAILURE;

    puts("All OK");
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0xd560
testb $0x1, %al
jne 0xd8c1
movl $0x1, -0x4(%rbp)
jmp 0xd91c
callq 0xd700
testb $0x1, %al
jne 0xd8d3
movl $0x1, -0x4(%rbp)
jmp 0xd91c
callq 0xcf10
testb $0x1, %al
jne 0xd8e5
movl $0x1, -0x4(%rbp)
jmp 0xd91c
callq 0xcb40
testb $0x1, %al
jne 0xd8f7
movl $0x1, -0x4(%rbp)
jmp 0xd91c
callq 0xcd40
testb $0x1, %al
jne 0xd909
movl $0x1, -0x4(%rbp)
jmp 0xd91c
leaq 0x7b11(%rip), %rdi      # 0x15421
callq 0x2240
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WojciechMula[P]utf16utf8/include/reference.h
// Function: strlen_utf16_to_utf8(unsigned short const*)
static inline size_t strlen_utf16_to_utf8(const uint16_t *str)
{
	size_t i, count;
	uint32_t c;

	for (i=0, count=0; ; i++)
	{
		if (str[i]==0)
			return count;

		c = utf16_to_unicode32(&str[i], &i);
		count += codepoint_utf8_size(c);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jne 0xd967
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
shlq %rax
addq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xd9b0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0xdbd0
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xd94c
nopw %cs:(%rax,%rax)
// File: WojciechMula[P]utf16utf8/include/reference.h
// Function: utf16_to_unicode32(unsigned short const*, unsigned long*)
static inline uint32_t utf16_to_unicode32(const uint16_t *c, size_t *index)
{
	uint32_t v;
	int size;

	size = utf16_char_size(c);

	if (size > 0 && index)
		*index += size-1;

	switch (size)
	{
		case 1:
			v = c[0];
			break;
		case 2:
			v = c[0] & 0x3FF;
			v = v << 10 | (c[1] & 0x3FF);
			v += 0x10000;
			break;
	}

	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdc30
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0xd9ec
cmpq $0x0, -0x10(%rbp)
je 0xd9ec
movl -0x18(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0xda03
jmp 0xd9f9
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xda0f
jmp 0xda42
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xda42
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0xa, %eax
movq -0x8(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: WojciechMula[P]utf16utf8/include/reference.h
// Function: codepoint_utf8_size(unsigned int)
static inline  int codepoint_utf8_size(uint32_t c)
{
	if (c < 0x0080) return 1;
	if (c < 0x0800) return 2;
	if (c < 0x10000) return 3;
	if (c < 0x110000) return 4;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x80, -0x8(%rbp)
jae 0xdbe9
movl $0x1, -0x4(%rbp)
jmp 0xdc26
cmpl $0x800, -0x8(%rbp)      # imm = 0x800
jae 0xdbfb
movl $0x2, -0x4(%rbp)
jmp 0xdc26
cmpl $0x10000, -0x8(%rbp)    # imm = 0x10000
jae 0xdc0d
movl $0x3, -0x4(%rbp)
jmp 0xdc26
cmpl $0x110000, -0x8(%rbp)   # imm = 0x110000
jae 0xdc1f
movl $0x4, -0x4(%rbp)
jmp 0xdc26
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: WojciechMula[P]utf16utf8/include/reference.h
// Function: utf16_char_size(unsigned short const*)
static inline int utf16_char_size(const uint16_t *c)
{
	if (c[0] <= 0xD7FF || c[0] >= 0xE000)
		return 1;
	else if (c[1] == 0)			// if there's an abrupt mid-character stream end
		return 1;
	else
		return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xd7ff, %eax           # imm = 0xD7FF
jle 0xdc54
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xe000, %eax           # imm = 0xE000
jl 0xdc5d
movl $0x1, -0x4(%rbp)
jmp 0xdc7a
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0xdc73
movl $0x1, -0x4(%rbp)
jmp 0xdc7a
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::Diagram(vot::otBBox, int)
Diagram::Diagram(const otBBox bBox, const int numBlocks) {
        mDiagram = new voro::container_poly(bBox.xMin, bBox.xMax,
                                             bBox.yMin, bBox.yMax,
                                             bBox.zMin, bBox.zMax,
                                             numBlocks, numBlocks, numBlocks,
                                             false, false, false, 8);
        mNumEmpiricals = 0;
        mNumDiracs = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x21470
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x38(%rbp)
callq 0x21490
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x28(%rbp)
callq 0x214b0
jmp 0x1eea0
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x58(%rbp)
callq 0x21500
movl $0x198, %edi            # imm = 0x198
callq 0xa4c0
movq %rax, -0x50(%rbp)
jmp 0x1eec1
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movsd 0x18(%rax), %xmm3
movsd 0x20(%rax), %xmm4
movsd 0x28(%rax), %xmm5
movl -0xc(%rbp), %ecx
movq %rsp, %rax
movl $0x8, 0x8(%rax)
movl $0x0, (%rax)
xorl %r9d, %r9d
movl %ecx, %esi
movl %ecx, %edx
movl %r9d, %r8d
callq 0x56310
jmp 0x1ef0a
movq -0x30(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, 0x3c(%rax)
movl $0x0, 0x38(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1ef71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1ef5f
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x198, %esi            # imm = 0x198
callq 0xa4d0
movq -0x58(%rbp), %rdi
callq 0x21520
movq -0x28(%rbp), %rdi
callq 0x21580
movq -0x38(%rbp), %rdi
callq 0x215a0
movq -0x40(%rbp), %rdi
callq 0x21600
movq -0x18(%rbp), %rdi
callq 0xa950
nopl (%rax)
// File: icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::add_dirac(double, double, double, double, double, double, bool)
void Diagram::add_dirac(double x, double y, double z, double d, double m, double h, bool fix) {
        mDiagram->put(mNumDiracs, x, y, z, sqrt(h)); // Add a centroid/particle in container
        mDiracs.push_back(Dirac(x,y,z,d,m,fix));
        mHs.push_back(h);
        mNumDiracs++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x38(%rbp)
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq (%rax), %rcx
movq %rcx, -0xc0(%rbp)
movl 0x38(%rax), %eax
movl %eax, -0xb4(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xa8(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0xa3d0
movq -0xc0(%rbp), %rdi
movl -0xb4(%rbp), %esi
movsd -0xb0(%rbp), %xmm1
movsd -0xa8(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0xa0(%rbp), %xmm0
callq 0x56650
movq -0x98(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x90(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
movsd -0x30(%rbp), %xmm4
movzbl -0x39(%rbp), %esi
andl $0x1, %esi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x21690
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x21660
jmp 0x1f0c8
leaq -0x70(%rbp), %rdi
callq 0x21710
movq -0x98(%rbp), %rdi
addq $0x50, %rdi
leaq -0x38(%rbp), %rsi
callq 0x21730
movq -0x98(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x21710
movq -0x78(%rbp), %rdi
callq 0xa950
nopl (%rax)
// File: icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::total_dirac_mass()
double Diagram::total_dirac_mass() {
        double total = 0;
        for (int i = 0; i < mNumDiracs; i++) {
            total += mDiracs[i].dirac();
        }
        return total;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x38(%rcx), %eax
jge 0x2016d
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movslq -0x14(%rbp), %rsi
callq 0x218b0
movq %rax, %rdi
callq 0x21970
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x20133
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::total_empirical_mass()
double Diagram::total_empirical_mass() {
        double total = 0;
        for (int i = 0; i < mNumEmpiricals; i++) {
            total += mEmpiricals[i].mass();
        }
        return total;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x3c(%rcx), %eax
jge 0x201dd
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x21ab0
movq %rax, %rdi
callq 0x21ad0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x201a3
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::update(int, double, double, int, int)
bool Diagram::update(int method, double thres, double step, int iterP, int iterH) {
        // Hessian is computed during updating the diagram
        Eigen::SparseMatrix<double> hessian(mNumDiracs, mNumDiracs);
        if (method == METHOD_NEWTON)
            mDiagram->update_diagram(mDiracs, hessian);
        else 
            mDiagram->update_diagram();

        // Return true if gradient doesn't change too much.
        if (mFlagVerbose) 
            std::cout << "iterP: " << iterP << ", iterH: " << iterH << ". ";
        
        if (compute_gradient() < thres) {
            return true;
        }

        if (method == METHOD_NEWTON)
            update_h(hessian);
        else
            update_h(step);

        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movl %edx, -0x2c(%rbp)
movl %ecx, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movslq 0x38(%rax), %rsi
movslq 0x38(%rax), %rdx
leaq -0x78(%rbp), %rdi
callq 0x21af0
cmpl $0x2, -0x14(%rbp)
jne 0x2026c
movq -0x90(%rbp), %rsi
movq (%rsi), %rdi
addq $0x20, %rsi
leaq -0x78(%rbp), %rdx
callq 0x21b80
jmp 0x2024d
jmp 0x2027f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x22480
jmp 0x20398
movq -0x90(%rbp), %rax
movq (%rax), %rdi
callq 0x223b0
jmp 0x2027d
jmp 0x2027f
movq -0x90(%rbp), %rax
testb $0x1, 0x68(%rax)
je 0x2030b
movq 0x9ed05(%rip), %rdi     # 0xbef98
leaq 0x6dbdb(%rip), %rsi     # 0x8de75
callq 0xa4a0
movq %rax, -0x98(%rbp)
jmp 0x202a8
movq -0x98(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0xa920
movq %rax, -0xa0(%rbp)
jmp 0x202c0
movq -0xa0(%rbp), %rdi
leaq 0x6dbaf(%rip), %rsi     # 0x8de7d
callq 0xa4a0
movq %rax, -0xa8(%rbp)
jmp 0x202dc
movq -0xa8(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0xa920
movq %rax, -0xb0(%rbp)
jmp 0x202f4
movq -0xb0(%rbp), %rdi
leaq 0x73c1a(%rip), %rsi     # 0x93f1c
callq 0xa4a0
jmp 0x20309
jmp 0x2030b
movq -0x90(%rbp), %rdi
callq 0x203b0
movsd %xmm0, -0xb8(%rbp)
jmp 0x20321
movsd -0xb8(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x20344
movb $0x1, -0x1(%rbp)
movl $0x1, -0x88(%rbp)
jmp 0x20381
cmpl $0x2, -0x14(%rbp)
jne 0x2035e
movq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x206f0
jmp 0x2035c
jmp 0x20373
movq -0x90(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x209b0
jmp 0x20371
jmp 0x20373
movb $0x0, -0x1(%rbp)
movl $0x1, -0x88(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x22480
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xa950
nopw %cs:(%rax,%rax)
// File: icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::update_h(double)
void Diagram::update_h(double step) {
        for (int i = 0; i < mNumDiracs; i++) {
            mHs[i] -= step * mGradient[i]; // delta h
            ASSERT_VOT(mHs[i] > 0, "Negative h not allowed");
        }
        // I haven't found a way to directly update h
        // The alternative is to clear the diagram and define a new one with new h
        mDiagram->clear();
        for (int i = 0; i < mNumDiracs; i++) {
            mDiagram->put(i, mDiracs[i].x(), mDiracs[i].y(), mDiracs[i].z(), sqrt(mHs[i]));
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x38(%rcx), %eax
jge 0x20ae6
movq -0x20(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0x40, %rdi
movslq -0x14(%rbp), %rsi
callq 0x22be0
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x50, %rdi
movslq -0x14(%rbp), %rsi
callq 0x21950
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movsd (%rax), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
movslq -0x14(%rbp), %rsi
callq 0x21950
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
ja 0x20ad4
movq 0x9e575(%rip), %rdi     # 0xbefe0
leaq 0x6d460(%rip), %rsi     # 0x8ded2
callq 0xa4a0
movq %rax, %rdi
leaq 0x6d477(%rip), %rsi     # 0x8def8
callq 0xa4a0
movq %rax, %rdi
leaq 0x6d473(%rip), %rsi     # 0x8df03
callq 0xa4a0
movq %rax, %rdi
movl $0xe4, %esi
callq 0xa920
movq %rax, %rdi
leaq 0x6c98f(%rip), %rsi     # 0x8d43b
callq 0xa4a0
movq %rax, %rdi
leaq 0x6d44f(%rip), %rsi     # 0x8df0a
callq 0xa4a0
movq %rax, %rdi
movq 0x9e45e(%rip), %rsi     # 0xbef28
callq 0xa500
callq 0xa170
jmp 0x20ad6
jmp 0x20ad8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x209d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x57810
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x38(%rcx), %eax
jge 0x20bb6
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x58(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4c(%rbp)
addq $0x20, %rdi
movslq -0x18(%rbp), %rsi
callq 0x218b0
movq %rax, %rdi
callq 0x218d0
movq -0x20(%rbp), %rdi
movsd %xmm0, -0x38(%rbp)
addq $0x20, %rdi
movslq -0x18(%rbp), %rsi
callq 0x218b0
movq %rax, %rdi
callq 0x218f0
movq -0x20(%rbp), %rdi
movsd %xmm0, -0x48(%rbp)
addq $0x20, %rdi
movslq -0x18(%rbp), %rsi
callq 0x218b0
movq %rax, %rdi
callq 0x21910
movq -0x20(%rbp), %rdi
movsd %xmm0, -0x40(%rbp)
addq $0x50, %rdi
movslq -0x18(%rbp), %rsi
callq 0x21950
movsd (%rax), %xmm0
callq 0xa3d0
movq -0x58(%rbp), %rdi
movl -0x4c(%rbp), %esi
movsd -0x48(%rbp), %xmm1
movsd -0x40(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x38(%rbp), %xmm0
callq 0x56650
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x20af9
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::compute_wasserstein()
double Diagram::compute_wasserstein() {
        double wd = 0;
        for (int i = 0; i < mNumEmpiricals; i++) {
            wd += mEmpiricals[i].costL2(mDiracs[mEmpiricals[i].cellIndex()]);
        }
        return wd;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x3c(%rcx), %eax
jge 0x21325
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x21ab0
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x21ab0
movq %rax, %rdi
callq 0x22580
movq -0x30(%rbp), %rdi
movslq %eax, %rsi
callq 0x218b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x22e60
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x212b3
movsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: icemiliang[P]vot/src/vot/./container.hh
// Function: voro::container_poly::update_diagram()
inline void update_diagram() {
            c_loop_all vl(*this);
            voronoicell_neighbor c;
            if (vl.start()) {
                do {
                    compute_cell(c, vl);
                } while (vl.inc());
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x130(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x23330
leaq -0x110(%rbp), %rdi
callq 0x48040
movq -0x128(%rbp), %rdi
callq 0x23560
movb %al, -0x11d(%rbp)
jmp 0x223fa
movb -0x11d(%rbp), %al
testb $0x1, %al
jne 0x22406
jmp 0x22452
jmp 0x22408
movq -0x130(%rbp), %rdi
leaq -0x110(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x23be0
jmp 0x22421
jmp 0x22423
leaq -0x50(%rbp), %rdi
callq 0x23630
testb $0x1, %al
jne 0x22408
jmp 0x22452
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x481e0
jmp 0x22467
leaq -0x110(%rbp), %rdi
callq 0x481e0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x118(%rbp), %rdi
callq 0xa950
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: icemiliang[P]vot/src/vot/../../include/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
// Function: Eigen::LeastSquaresConjugateGradient<Eigen::SparseMatrix<double, 0, int>, Eigen::LeastSquareDiagonalPreconditioner<double>>& Eigen::IterativeSolverBase<Eigen::LeastSquaresConjugateGradient<Eigen::SparseMatrix<double, 0, int>, Eigen::LeastSquareDiagonalPreconditioner<double>>>::compute<Eigen::SparseMatrix<double, 0, int>>(Eigen::EigenBase<Eigen::SparseMatrix<double, 0, int>> const&)
Derived& compute(const EigenBase<MatrixDerived>& A)
  {
    grab(A.derived());
    m_preconditioner.compute(matrix());
    m_isInitialized = true;
    m_analysisIsOk = true;
    m_factorizationIsOk = true;
    m_info = m_preconditioner.info();
    return derived();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x352e0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x352b0
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0xe0, %rax
movq %rax, -0x20(%rbp)
callq 0x35320
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x352f0
movq -0x18(%rbp), %rdi
movb $0x1, (%rdi)
movb $0x1, 0x11c(%rdi)
movb $0x1, 0x11d(%rdi)
addq $0xe0, %rdi
callq 0x35340
movq -0x18(%rbp), %rdi
movl %eax, 0x118(%rdi)
callq 0x35350
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: icemiliang[P]vot/src/vot/./container.hh
// Function: void voro::container_poly::draw_diagram_gnuplot<voro::c_loop_all>(voro::c_loop_all&, _IO_FILE*)
void draw_diagram_gnuplot(c_loop &vl, FILE *fp) {
            voronoicell c; double *pp;
            if (vl.start()) do if (compute_cell(c, vl)) {
                pp = p[vl.ijk] + ps*vl.q;
                c.draw_gnuplot(*pp, pp[1], pp[2], fp);
            } while (vl.inc());
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x23520
movq -0x10(%rbp), %rdi
callq 0x23560
movb %al, -0xcd(%rbp)
jmp 0x2339f
movb -0xcd(%rbp), %al
testb $0x1, %al
jne 0x233ae
jmp 0x2347d
jmp 0x233b0
movq -0xd8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0xb8(%rbp), %rsi
callq 0x235d0
movb %al, -0xd9(%rbp)
jmp 0x233cf
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x233db
jmp 0x23458
movq -0xd8(%rbp), %rcx
movq 0xb0(%rcx), %rax
movq -0x10(%rbp), %rdx
movslq 0x3c(%rdx), %rsi
movq (%rax,%rsi,8), %rax
movl 0xc8(%rcx), %ecx
movl 0x40(%rdx), %edx
imull %edx, %ecx
movslq %ecx, %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movq -0x18(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x45120
jmp 0x23436
jmp 0x23458
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x236a0
jmp 0x23492
jmp 0x2345a
movq -0x10(%rbp), %rdi
callq 0x23630
movb %al, -0xda(%rbp)
jmp 0x2346b
movb -0xda(%rbp), %al
testb $0x1, %al
jne 0x233b0
jmp 0x2347b
jmp 0x2347d
leaq -0xb8(%rbp), %rdi
callq 0x236a0
addq $0xe0, %rsp
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0xa950
nop
// File: icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseRedux.h
// Function: Eigen::SparseMatrixBase<Eigen::Block<Eigen::SparseMatrix<double, 0, int>, -1, 1, true>>::sum() const
typename internal::traits<Derived>::Scalar
SparseMatrixBase<Derived>::sum() const
{
  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
  Scalar res(0);
  internal::evaluator<Derived> thisEval(derived());
  for (Index j=0; j<outerSize(); ++j)
    for (typename internal::evaluator<Derived>::InnerIterator iter(thisEval,j); iter; ++iter)
      res += iter.value();
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x29cd0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x61(%rbp)
jle 0x23f78
movq -0x70(%rbp), %rdi
callq 0x29d00
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x61(%rbp)
jle 0x23f78
movb $0x1, %al
movb %al, -0x61(%rbp)
jmp 0x23f78
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x23f81
jmp 0x23f83
jmp 0x23fa2
leaq 0x6b3f5(%rip), %rdi     # 0x8f37f
leaq 0x6b42f(%rip), %rsi     # 0x8f3c0
movl $0x13, %edx
leaq 0x6b454(%rip), %rcx     # 0x8f3f1
callq 0xa330
movq -0x70(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
callq 0x29d30
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x29d40
movq $0x0, -0x28(%rbp)
movq -0x70(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x29d70
movq %rax, -0x78(%rbp)
jmp 0x23fde
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
cmpq %rcx, %rax
jge 0x24094
leaq -0x20(%rbp), %rdi
callq 0x29d90
movq %rax, -0x88(%rbp)
jmp 0x24001
movq -0x88(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x29db0
jmp 0x24017
jmp 0x24019
leaq -0x60(%rbp), %rdi
callq 0x29eb0
movb %al, -0x89(%rbp)
jmp 0x2402a
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x24036
jmp 0x24081
leaq -0x60(%rbp), %rdi
callq 0x29ed0
movq %rax, -0x98(%rbp)
jmp 0x24048
movq -0x98(%rbp), %rax
movsd (%rax), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x29ef0
jmp 0x24068
jmp 0x24019
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x29f10
jmp 0x240bb
jmp 0x24083
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x23fc7
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x29f10
movsd -0xa0(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xa950
nopw %cs:(%rax,%rax)
nop
// File: icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 0, int>::SparseMatrix<Eigen::Transpose<Eigen::SparseMatrix<double, 0, int>>>(Eigen::SparseMatrixBase<Eigen::Transpose<Eigen::SparseMatrix<double, 0, int>>> const&)
inline SparseMatrix(const SparseMatrixBase<OtherDerived>& other)
      : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
    {
      EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
      check_template_parameters();
      const bool needToTranspose = (Flags & RowMajorBit) != (internal::evaluator<OtherDerived>::Flags & RowMajorBit);
      if (needToTranspose)
        *this = other.derived();
      else
      {
        #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
          EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
        #endif
        internal::call_assignment_no_alias(*this, other.derived());
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x2cfd0
movq -0x30(%rbp), %rdi
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0x262a0
callq 0x2cff0
jmp 0x24345
movb $0x1, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2d000
movq %rax, -0x38(%rbp)
jmp 0x24358
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x2d010
jmp 0x24367
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x263c0
movq -0x18(%rbp), %rdi
callq 0xa950
nopl (%rax,%rax)
// File: icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 1, int>::insertBackUncompressed(long, long)
EIGEN_STRONG_INLINE Scalar& insertBackUncompressed(Index row, Index col)
    {
      const Index outer = IsRowMajor ? row : col;
      const Index inner = IsRowMajor ? col : row;

      eigen_assert(!isCompressed());
      eigen_assert(m_innerNonZeros[outer]<=(m_outerIndex[outer+1] - m_outerIndex[outer]));

      Index p = m_outerIndex[outer] + m_innerNonZeros[outer]++;
      m_data.index(p) = convert_index(inner);
      return (m_data.value(p) = 0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x27d80
xorb $-0x1, %al
testb $0x1, %al
jne 0x258b9
jmp 0x258bb
jmp 0x258da
leaq 0x69398(%rip), %rdi     # 0x8ec5a
leaq 0x687ab(%rip), %rsi     # 0x8e074
movl $0x37b, %edx            # imm = 0x37B
leaq 0x69395(%rip), %rcx     # 0x8ec6a
callq 0xa330
movq -0x38(%rbp), %rdx
movq 0x20(%rdx), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x18(%rdx), %rcx
movq -0x20(%rbp), %rsi
movl 0x4(%rcx,%rsi,4), %ecx
movq 0x18(%rdx), %rdx
movq -0x20(%rbp), %rsi
subl (%rdx,%rsi,4), %ecx
cmpl %ecx, %eax
jg 0x25906
jmp 0x25925
leaq 0x693de(%rip), %rdi     # 0x8eceb
leaq 0x68760(%rip), %rsi     # 0x8e074
movl $0x37c, %edx            # imm = 0x37C
leaq 0x6934a(%rip), %rcx     # 0x8ec6a
callq 0xa330
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %rax
movq -0x20(%rbp), %rdx
movl (%rax,%rdx,4), %eax
movq 0x20(%rcx), %rdx
movq -0x20(%rbp), %rsi
movl (%rdx,%rsi,4), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rdx,%rsi,4)
addl %ecx, %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x285e0
movq -0x38(%rbp), %rdi
movl %eax, -0x3c(%rbp)
addq $0x28, %rdi
movq -0x30(%rbp), %rsi
callq 0x27e90
movl -0x3c(%rbp), %ecx
movq -0x38(%rbp), %rdi
movl %ecx, (%rax)
addq $0x28, %rdi
movq -0x30(%rbp), %rsi
callq 0x27ec0
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 1, int>::resize(long, long)
void resize(Index rows, Index cols)
    {
      const Index outerSize = IsRowMajor ? rows : cols;
      m_innerSize = IsRowMajor ? cols : rows;
      m_data.clear();
      if (m_outerSize != outerSize || m_outerSize==0)
      {
        std::free(m_outerIndex);
        m_outerIndex = static_cast<StorageIndex*>(std::malloc((outerSize + 1) * sizeof(StorageIndex)));
        if (!m_outerIndex) internal::throw_std_bad_alloc();
        
        m_outerSize = outerSize;
      }
      if(m_innerNonZeros)
      {
        std::free(m_innerNonZeros);
        m_innerNonZeros = 0;
      }
      memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(StorageIndex));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x10(%rdi)
addq $0x28, %rdi
callq 0x26430
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x2632e
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2636f
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xa5c0
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x2, %rdi
callq 0xa6b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x18(%rax)
jne 0x26363
callq 0x26450
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x26393
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xa5c0
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rdx
addq $0x1, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0xa270
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/CompressedStorage.h
// Function: Eigen::internal::CompressedStorage<double, int>::resize(long, double)
void resize(Index size, double reserveSizeFactor = 0)
    {
      if (m_allocatedSize<size)
      {
        Index realloc_size = (std::min<Index>)(NumTraits<StorageIndex>::highest(),  size + Index(reserveSizeFactor*double(size)));
        if(realloc_size<size)
          internal::throw_std_bad_alloc();
        reallocate(realloc_size);
      }
      m_size = size;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x18(%rax), %rax
cmpq -0x10(%rbp), %rax
jge 0x27f61
callq 0x285c0
cltq
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsd -0x18(%rbp), %xmm0
cvtsi2sdq -0x10(%rbp), %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x283a0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x27f54
callq 0x26450
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x280f0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/CompressedStorage.h
// Function: Eigen::internal::CompressedStorage<double, int>::reallocate(long)
inline void reallocate(Index size)
    {
      #ifdef EIGEN_SPARSE_COMPRESSED_STORAGE_REALLOCATE_PLUGIN
        EIGEN_SPARSE_COMPRESSED_STORAGE_REALLOCATE_PLUGIN
      #endif
      eigen_internal_assert(size!=m_allocatedSize);
      internal::scoped_array<Scalar> newValues(size);
      internal::scoped_array<StorageIndex> newIndices(size);
      Index copySize = (std::min)(size, m_size);
      if (copySize>0) {
        internal::smart_copy(m_values, m_values+copySize, newValues.ptr());
        internal::smart_copy(m_indices, m_indices+copySize, newIndices.ptr());
      }
      std::swap(m_values,newValues.ptr());
      std::swap(m_indices,newIndices.ptr());
      m_allocatedSize = size;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x282a0
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x28320
jmp 0x28127
movq -0x40(%rbp), %rsi
addq $0x10, %rsi
leaq -0x10(%rbp), %rdi
callq 0x283a0
movq %rax, -0x48(%rbp)
jmp 0x2813e
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jle 0x281fa
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x28410
movq %rax, -0x50(%rbp)
jmp 0x2817a
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rax
movq (%rax), %rdx
callq 0x283e0
jmp 0x28190
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rcx
leaq (%rax,%rcx,4), %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x28450
movq %rax, -0x68(%rbp)
jmp 0x281b7
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
movq -0x68(%rbp), %rax
movq (%rax), %rdx
callq 0x28420
jmp 0x281cd
jmp 0x281fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2827f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x284a0
jmp 0x2827f
movq -0x40(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x28410
movq %rax, -0x80(%rbp)
jmp 0x28214
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x28460
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x98(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x28450
movq %rax, -0x90(%rbp)
jmp 0x28245
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdi
callq 0x27fc0
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
leaq -0x20(%rbp), %rdi
callq 0x284a0
leaq -0x18(%rbp), %rdi
callq 0x284e0
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x284e0
movq -0x28(%rbp), %rdi
callq 0xa950
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)