LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: doeclim_load_calibration(DICE*, int)
void doeclim_load_calibration(DICE *dice, int n)
{
	// Calibration file name
	const char calfile[] = "calibration_results.txt";
	
	// Open the file and read in the calibration data
	FILE * fp;
  fp = fopen(calfile, "r");

  int counter = 0;
  float this_cs, this_kv, this_alpha;
  while(!feof(fp)) {
    if (fscanf(fp, "%g %g %g", &this_cs, &this_kv, &this_alpha) != 3) {
      break;
    }
    dice->clim.cs_cal[counter] = this_cs;
    dice->clim.kv_cal[counter] = this_kv;
    dice->clim.alpha_cal[counter] = this_alpha;
    counter++;
    if (counter >= n) {
      break;
    }
  }
  fclose(fp);
  
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x126c(%rip), %rax      # 0x1c360
movq %rax, 0x20(%rsp)
movq 0x1268(%rip), %rax      # 0x1c368
movq %rax, 0x28(%rsp)
movq 0x1264(%rip), %rax      # 0x1c370
movq %rax, 0x30(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x11c3(%rip), %rsi      # 0x1c2e0
callq 0x97d0
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9aa0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1b14a
jmp 0x1b1ef
movq 0x18(%rsp), %rdi
leaq 0x11fd(%rip), %rsi      # 0x1c353
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0x8(%rsp), %r8
movb $0x0, %al
callq 0x9d20
cmpl $0x3, %eax
je 0x1b173
jmp 0x1b1ef
movss 0x10(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x40(%rsp), %rax
movq 0x178(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x40(%rsp), %rax
movq 0x180(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x40(%rsp), %rax
movq 0x188(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jl 0x1b1ea
jmp 0x1b1ef
jmp 0x1b12f
movq 0x18(%rsp), %rdi
callq 0x9670
addq $0x48, %rsp
retq
nop
// File: FreeSlave[P]def2fgd/src/main.cpp
// Function: globMatch(char const*, char const*)
static bool globMatch(const char *str, const char *wild) {
    const char *tail = 0;
    const char* afterStar = 0;

    while (*str != '\0' && *wild != '*') {
        if (*wild == *str || *wild == '?') {
            wild++;
            str++;
        } else {
            return false;
        }
    }

    while (*str != '\0') {
        if (*wild == '*') {
            ++wild;
            if (*wild == '\0') {
                return true;
            }
            afterStar = wild;
            tail = str+1;
        } else if (*wild == *str || *wild == '?') {
            wild++;
            str++;
        } else {
            wild = afterStar;
            str = tail++;
        }
    }

    while (*wild == '*') {
        wild++;
    }
    return *wild == '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x5ccd
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x5cd6
jmp 0x5d19
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x5cf4
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0x5d0e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5d17
movb $0x0, -0x1(%rbp)
jmp 0x5df6
jmp 0x5cac
jmp 0x5d1b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5dc8
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x5d6e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5d58
movb $0x1, -0x1(%rbp)
jmp 0x5df6
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5dc3
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x5d8c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0x5da6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5dc1
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x10(%rbp)
jmp 0x5dc3
jmp 0x5d1b
jmp 0x5dca
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x5de4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5dca
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: FreeSlave[P]def2fgd/src/main.cpp
// Function: printHelp(char const*)
void printHelp(const char* programName)
{
    printf( translate("Usage: %s [options] [input-file] [output-file]\n"
            "\n"
            "  -format format       specify format of input: def or ent\n"
            "\n"
            "  -offset-glob pattern add offset to entities matching given pattern;\n"
            "                       this option can be passed multiple times\n"
            "  -noauto-offset-glob  don't use default patterns when setting offset\n"
            "\n"
            "  -bob                 same as -bobparms \"180 8 0\"\n"
            "  -bobparms \"x y z\"    set bob parameters\n"
            "  -bob-glob pattern    add bobparms to entities matching given pattern;\n"
            "                       this option can be passed multiple times\n"
            "  -noauto-bob-glob     don't use default patterns when setting bobparms\n"
            "\n"
            "  -help                display this help and exit\n"
            "  -version             show version information and exit\n"
            "  -- [arguments...]    treat the rest of arguments as positional arguments\n"
            "\n"
            "When input-file is omitted or -, read standard input.\n"
            "When output-file is omitted or -, write to standard output.\n").c_str()
    , programName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xf35a(%rip), %rsi      # 0x151dd
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x140e0
movq -0x40(%rbp), %rdi
callq 0x4120
movq %rax, %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
callq 0x4060
jmp 0x5ea9
leaq -0x28(%rbp), %rdi
callq 0x41f0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x41f0
movq -0x30(%rbp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]def2fgd/src/entity.cpp
// Function: colorFromFloat(float)
unsigned colorFromFloat(float f)
{
    unsigned u = static_cast<unsigned>(ceil(f*255));
    if (u > 255)
        u = 255;
    return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
movss 0x7ad2(%rip), %xmm1     # 0x158dc
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4090
cvttsd2si %xmm0, %rax
movl %eax, -0x8(%rbp)
cmpl $0xff, -0x8(%rbp)
jbe 0xde2f
movl $0xff, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]def2fgd/src/entity.cpp
// Function: Entity::Entity()
Entity::Entity() : solid(false)
{
    for (size_t i=0; i<6; ++i)
        box[i] = 0;
    color[0] = 200;
    color[1] = 0;
    color[2] = 200;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x44c0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x44c0
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0xe380
movq -0x28(%rbp), %rax
addq $0x58, %rax
movq %rax, %rcx
addq $0x400, %rcx            # imm = 0x400
movq %rcx, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x44c0
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x18(%rbp)
jne 0xe05d
movq -0x28(%rbp), %rax
addq $0x458, %rax            # imm = 0x458
movq %rax, %rcx
addq $0x400, %rcx            # imm = 0x400
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x44c0
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0xe09b
movq -0x28(%rbp), %rdi
movb $0x0, 0x87c(%rdi)
addq $0x880, %rdi            # imm = 0x880
callq 0x44c0
movq $0x0, -0x10(%rbp)
cmpq $0x6, -0x10(%rbp)
jae 0xe104
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl $0x0, 0x864(%rax,%rcx,4)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xe0dc
movq -0x28(%rbp), %rax
movl $0xc8, 0x858(%rax)
movl $0x0, 0x85c(%rax)
movl $0xc8, 0x860(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: FreeSlave[P]def2fgd/src/entity.cpp
// Function: Entity::hasKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool Entity::hasKey(const std::string& name) const
{
    for (size_t i=0; i<keys.size(); ++i)
    {
        if (keys[i].name == name) {
            return true;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x40, %rdi
callq 0x7730
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xe1aa
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq -0x20(%rbp), %rsi
callq 0xe3a0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xdb60
testb $0x1, %al
jne 0xe194
jmp 0xe19a
movb $0x1, -0x1(%rbp)
jmp 0xe1ae
jmp 0xe19c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xe150
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: FreeSlave[P]def2fgd/src/entity.cpp
// Function: operator<<(std::ostream&, Entity const&)
std::ostream& operator<<(std::ostream& out, const Entity& entity)
{
    out << entity.name << (entity.solid ? " solid" : " point");
    for (size_t i=0;i<6;++i)
        out << " " << entity.box[i];
    out << std::endl;
    for (size_t i=0; i<entity.keys.size(); ++i)
    {
        out << entity.keys[i].name << " ";
    }
    if (!entity.model.empty())
        out << "model=" <<entity.model;
    out << std::endl;
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x87c(%rax)
je 0xe1fb
leaq 0x76fb(%rip), %rax      # 0x158f0
movq %rax, -0x30(%rbp)
jmp 0xe208
leaq 0x76f5(%rip), %rax      # 0x158f7
movq %rax, -0x30(%rbp)
jmp 0xe208
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4310
movq $0x0, -0x18(%rbp)
cmpq $0x6, -0x18(%rbp)
jae 0xe259
movq -0x8(%rbp), %rdi
leaq 0x6e9e(%rip), %rsi      # 0x150cd
callq 0x4310
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x864(%rax,%rcx,4), %esi
callq 0x45e0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xe21d
movq -0x8(%rbp), %rdi
movq 0xed3c(%rip), %rsi      # 0x1cfa0
callq 0x4370
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x7730
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xe2d4
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movq -0x20(%rbp), %rsi
callq 0xe3a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x42e0
movq %rax, %rdi
leaq 0x6e0c(%rip), %rsi      # 0x150cd
callq 0x4310
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xe271
movq -0x10(%rbp), %rdi
addq $0x880, %rdi            # imm = 0x880
callq 0x45a0
testb $0x1, %al
jne 0xe30b
movq -0x8(%rbp), %rdi
leaq 0x760b(%rip), %rsi      # 0x158fe
callq 0x4310
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x880, %rsi            # imm = 0x880
callq 0x42e0
movq -0x8(%rbp), %rdi
movq 0xec8a(%rip), %rsi      # 0x1cfa0
callq 0x4370
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: FreeSlave[P]def2fgd/src/entreader.cpp
// Function: (anonymous namespace)::readColor(char const*, unsigned long, unsigned int*)
static void readColor(const char* begin, size_t size, unsigned* color)
    {
        const char* end = begin + size;
        const char* current = begin;
        for (size_t i=0; i<3 && current != end; ++i)
        {
            while(current != end && isspace(*current))
                current++;
            const char* start = current;
            while(current != end && (isdigit(*current) || *current == '.'))
                current++;
            color[i] = colorFromFloat(static_cast<float>(strtod(start, NULL)));
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x3, -0x30(%rbp)
movb %al, -0x39(%rbp)
jae 0xfa8a
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xfa96
jmp 0xfb63
jmp 0xfa98
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x3a(%rbp)
je 0xfabc
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
callq 0x4080
cmpl $0x0, %eax
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0xfac5
jmp 0xfad3
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xfa98
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x3b(%rbp)
je 0xfb18
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
callq 0x42f0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x3c(%rbp)
jne 0xfb12
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
sete %al
movb %al, -0x3c(%rbp)
movb -0x3c(%rbp), %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
testb $0x1, %al
jne 0xfb21
jmp 0xfb2f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xfadb
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4270
cvtsd2ss %xmm0, %xmm0
callq 0xddf0
movl %eax, %edx
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xfa70
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: FreeSlave[P]def2fgd/src/entreader.cpp
// Function: (anonymous namespace)::readBox(char const*, unsigned long, int*)
static void readBox(const char* begin, size_t size, int* box)
    {
        const char* end = begin + size;
        const char* current = begin;
        for (size_t i=0; i<6 && current != end; ++i)
        {
            while(current != end && isspace(*current))
                current++;
            const char* start = current;
            while(current != end && (isdigit(*current) || *current == '-'))
                current++;
            box[i] = static_cast<int>(strtol(start, NULL, 10));
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x6, -0x30(%rbp)
movb %al, -0x39(%rbp)
jae 0xfbba
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xfbc6
jmp 0xfc8f
jmp 0xfbc8
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x3a(%rbp)
je 0xfbec
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
callq 0x4080
cmpl $0x0, %eax
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0xfbf5
jmp 0xfc03
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xfbc8
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x3b(%rbp)
je 0xfc48
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
callq 0x42f0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x3c(%rbp)
jne 0xfc42
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x3c(%rbp)
movb -0x3c(%rbp), %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
testb $0x1, %al
jne 0xfc51
jmp 0xfc5f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xfc0b
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x44e0
movl %eax, %edx
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xfba0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]def2fgd/src/entreader.cpp
// Function: (anonymous namespace)::entTypeToFgdType(char const*, unsigned long)
static const char* entTypeToFgdType(const char* type, size_t size)
    {
        if (strncmp(type, "angles", size) == 0)
            return "angle";
        if (strncmp(type, "real", size) == 0)
            return "float";
        if (strncmp(type, "integer", size) == 0)
            return "integer";
        if (strncmp(type, "sound", size) == 0)
            return "sound";
        if (strncmp(type, "model", size) == 0)
            return "studio";
        return "";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x541a(%rip), %rsi      # 0x150d9
callq 0x4190
cmpl $0x0, %eax
jne 0xfcd9
leaq 0x5403(%rip), %rax      # 0x150d3
movq %rax, -0x8(%rbp)
jmp 0xfd7c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5c64(%rip), %rsi      # 0x1594c
callq 0x4190
cmpl $0x0, %eax
jne 0xfcff
leaq 0x5c58(%rip), %rax      # 0x15951
movq %rax, -0x8(%rbp)
jmp 0xfd7c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5c49(%rip), %rsi      # 0x15957
callq 0x4190
cmpl $0x0, %eax
jne 0xfd25
leaq 0x5c38(%rip), %rax      # 0x15957
movq %rax, -0x8(%rbp)
jmp 0xfd7c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5c2b(%rip), %rsi      # 0x1595f
callq 0x4190
cmpl $0x0, %eax
jne 0xfd4b
leaq 0x5c1a(%rip), %rax      # 0x1595f
movq %rax, -0x8(%rbp)
jmp 0xfd7c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x53a1(%rip), %rsi      # 0x150fb
callq 0x4190
cmpl $0x0, %eax
jne 0xfd71
leaq 0x5bfa(%rip), %rax      # 0x15965
movq %rax, -0x8(%rbp)
jmp 0xfd7c
leaq 0x545a(%rip), %rax      # 0x151d2
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]def2fgd/src/rapidxml-1.13/rapidxml.hpp
// Function: rapidxml::xml_node<char>::last_node(char const*, unsigned long, bool) const
xml_node<Ch> *last_node(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
        {
            assert(m_first_node);  // Cannot query for last child if node has no children
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_node<Ch> *child = m_last_node; child; child = child->previous_sibling())
                    if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive))
                        return child;
                return 0;
            }
            else
                return m_last_node;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x30(%rax)
je 0x103ec
jmp 0x1040b
leaq 0x582f(%rip), %rdi      # 0x15c22
leaq 0x5577(%rip), %rsi      # 0x15971
movl $0x3c0, %edx            # imm = 0x3C0
leaq 0x5829(%rip), %rcx      # 0x15c2f
callq 0x4210
cmpq $0x0, -0x18(%rbp)
je 0x104a7
cmpq $0x0, -0x20(%rbp)
jne 0x1042a
movq -0x18(%rbp), %rdi
callq 0x12b90
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1049d
movq -0x30(%rbp), %rdi
callq 0x10250
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10290
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x13ed0
testb $0x1, %al
jne 0x10476
jmp 0x10480
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x104b3
jmp 0x10482
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x13fd0
movq %rax, -0x30(%rbp)
jmp 0x10436
movq $0x0, -0x8(%rbp)
jmp 0x104b3
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: FreeSlave[P]def2fgd/src/rapidxml-1.13/rapidxml.hpp
// Function: rapidxml::xml_node<char>::previous_sibling(char const*, unsigned long, bool) const
xml_node<Ch> *previous_sibling(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
        {
            assert(this->m_parent);     // Cannot query for siblings if node has no parent
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_node<Ch> *sibling = m_prev_sibling; sibling; sibling = sibling->m_prev_sibling)
                    if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive))
                        return sibling;
                return 0;
            }
            else
                return m_prev_sibling;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x13ffc
jmp 0x1401b
leaq 0x1bae(%rip), %rdi      # 0x15bb1
leaq 0x1967(%rip), %rsi      # 0x15971
movl $0x3d7, %edx            # imm = 0x3D7
leaq 0x1c78(%rip), %rcx      # 0x15c8e
callq 0x4210
cmpq $0x0, -0x18(%rbp)
je 0x140aa
cmpq $0x0, -0x20(%rbp)
jne 0x1403a
movq -0x18(%rbp), %rdi
callq 0x12b90
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x140a0
movq -0x30(%rbp), %rdi
callq 0x10250
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10290
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x13ed0
testb $0x1, %al
jne 0x14086
jmp 0x14090
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x140b6
jmp 0x14092
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x14046
movq $0x0, -0x8(%rbp)
jmp 0x140b6
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: FreeSlave[P]def2fgd/src/translate.cpp
// Function: translate_n[abi:cxx11](char const*, char const*, unsigned long)
std::string translate_n(const char* single, const char* mult, unsigned long int n)
{
    if (n == 1) {
        return single;
    } else {
        return mult;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jne 0x141d4
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4600
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x74f0
jmp 0x141b2
leaq -0x21(%rbp), %rdi
callq 0x4390
jmp 0x1421e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x4390
jmp 0x14228
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x35(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4600
movq -0x48(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x74f0
jmp 0x141fc
leaq -0x35(%rbp), %rdi
callq 0x4390
jmp 0x1421e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x35(%rbp), %rdi
callq 0x4390
jmp 0x14228
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x45f0
// File: carlos-urena[P]svg-gen/./vector_templates_impl.hpp
// Function: VectorTempl<float, 3u>::operator-(VectorTempl<float, 3u> const&) const
inline
VectorTempl<T,n> VectorTempl<T,n>::operator - ( const VectorTempl<T,n> & der ) const
{
   VectorTempl<T,n> res ;
   for( unsigned i = 0 ; i < n ; i++ )
      res[i] = (*this)(i)-der(i) ;
   return res ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x9470
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jae 0x8dde
movq -0x40(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x9480
movss (%rax), %xmm0
movss %xmm0, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x9480
movss -0x48(%rbp), %xmm0
subss (%rax), %xmm0
movss %xmm0, -0x44(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x93d0
movss -0x44(%rbp), %xmm0
movl -0x24(%rbp), %ecx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8d88
movl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: carlos-urena[P]svg-gen/./vector_templates_impl.hpp
// Function: VectorTempl3<float>::cross(VectorTempl3<float> const&) const
inline
VectorTempl3<T> VectorTempl3<T>::cross( const VectorTempl3<T> & v2 ) const
{
   // cuidado: no hay acceso a 'coo' tal cual, mirar:
   // http://stackoverflow.com/questions/7281072/accessing-public-members-of-base-class-fails

   return VectorTempl3<T>(  (*this)(1)*v2(2) -  (*this)(2)*v2(1),
                       (*this)(2)*v2(0) -  (*this)(0)*v2(2),
                       (*this)(0)*v2(1) -  (*this)(1)*v2(0)
                     );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl $0x1, %esi
movl %esi, -0x54(%rbp)
callq 0x9480
movss (%rax), %xmm0
movss %xmm0, -0x78(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2, %esi
movl %esi, -0x70(%rbp)
callq 0x9480
movl -0x70(%rbp), %esi
movq -0x60(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x74(%rbp)
callq 0x9480
movl -0x54(%rbp), %esi
movss (%rax), %xmm0
movss %xmm0, -0x7c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9480
movss -0x7c(%rbp), %xmm1
movss -0x78(%rbp), %xmm0
movss -0x74(%rbp), %xmm2
movl -0x70(%rbp), %esi
movq -0x60(%rbp), %rdi
movss (%rax), %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
callq 0x9480
movss (%rax), %xmm0
movss %xmm0, -0x68(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl %esi, -0x50(%rbp)
callq 0x9480
movq -0x60(%rbp), %rdi
movl -0x50(%rbp), %esi
movss (%rax), %xmm0
movss %xmm0, -0x64(%rbp)
callq 0x9480
movl -0x70(%rbp), %esi
movss (%rax), %xmm0
movss %xmm0, -0x6c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9480
movss -0x6c(%rbp), %xmm1
movss -0x68(%rbp), %xmm0
movss -0x64(%rbp), %xmm2
movq -0x60(%rbp), %rdi
movl -0x50(%rbp), %esi
movss (%rax), %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
callq 0x9480
movl -0x54(%rbp), %esi
movss (%rax), %xmm0
movss %xmm0, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9480
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %esi
movss (%rax), %xmm0
movss %xmm0, -0x44(%rbp)
callq 0x9480
movl -0x50(%rbp), %esi
movss (%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9480
movss -0x4c(%rbp), %xmm1
movss -0x48(%rbp), %xmm0
movss -0x44(%rbp), %xmm2
movss (%rax), %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
leaq -0xc(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
callq 0x8c30
movl -0x4(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: carlos-urena[P]svg-gen/./vector_templates_impl.hpp
// Function: VectorTempl<float, 3u>::operator*(float const&) const
inline
VectorTempl<T,n> VectorTempl<T,n>::operator * ( const T & a ) const
{
   VectorTempl<T,n> res ;
   for( unsigned i = 0 ; i < n ; i++ )
      res[i] = (*this)(i)*a ;
   return res ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x9470
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jae 0x944c
movq -0x40(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x9480
movss (%rax), %xmm0
movq -0x20(%rbp), %rax
mulss (%rax), %xmm0
movss %xmm0, -0x44(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x93d0
movss -0x44(%rbp), %xmm0
movl -0x24(%rbp), %ecx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9408
movl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: carlos-urena[P]svg-gen/./vector_templates_impl.hpp
// Function: VectorTempl<float, 3u>::dot(VectorTempl<float, 3u> const&) const
inline
T VectorTempl<T,n>::dot( const VectorTempl<T,n> & v2 ) const
{
   double res = 0.0 ;
   for( unsigned int i = 0 ; i < n ; i++ )
      res += double((*this)(i)) * double(v2(i)) ;
   return T(res) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jae 0x963c
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x9480
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x9480
movsd -0x30(%rbp), %xmm0
movss (%rax), %xmm1
cvtss2sd %xmm1, %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x95e7
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: carlos-urena[P]svg-gen/svgobjects.cpp
// Function: write_radial_gradient_def(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void write_radial_gradient_def( std::ostream & os, const std::string & name )
{
   using namespace std ;
   os << "<radialGradient id='" << name << "' cx='50%' cy='50%' r='50%' fx='25%' fy='75%'>" << endl
      << "   <stop offset='0%'   style='stop-color:rgb(100%,100%,100%); stop-opacity:0.2' />" << endl
      << "   <stop offset='100%' style='stop-color:rgb(20%,20%,20%);    stop-opacity:0.2' />" << endl
      << "</radialGradient>" << endl ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd385(%rip), %rsi      # 0x17270
callq 0x31a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3180
movq %rax, %rdi
leaq 0xd37f(%rip), %rsi      # 0x17285
callq 0x31a0
movq %rax, %rdi
movq 0x14093(%rip), %rsi     # 0x1dfa8
callq 0x31c0
movq %rax, %rdi
leaq 0xd390(%rip), %rsi      # 0x172b4
callq 0x31a0
movq %rax, %rdi
movq 0x14075(%rip), %rsi     # 0x1dfa8
callq 0x31c0
movq %rax, %rdi
leaq 0xd3c5(%rip), %rsi      # 0x17307
callq 0x31a0
movq %rax, %rdi
movq 0x14057(%rip), %rsi     # 0x1dfa8
callq 0x31c0
movq %rax, %rdi
leaq 0xd3fa(%rip), %rsi      # 0x1735a
callq 0x31a0
movq %rax, %rdi
movq 0x14039(%rip), %rsi     # 0x1dfa8
callq 0x31c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: carlos-urena[P]svg-gen/svgobjects.cpp
// Function: write_radial_gradient_def_blue(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void write_radial_gradient_def_blue( std::ostream & os, const std::string & name )
{
   using namespace std ;
   os << "<radialGradient id='" << name << "' cx='50%' cy='50%' r='50%' fx='50%' fy='50%'>" << endl
      << "   <stop offset='0%'   style='stop-color:rgb(100%,100%,100%); stop-opacity:0.2' />" << endl
      << "   <stop offset='100%' style='stop-color:rgb(0%,0%,50%);    stop-opacity:0.4' />" << endl
      << "</radialGradient>" << endl ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd2d5(%rip), %rsi      # 0x17270
callq 0x31a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3180
movq %rax, %rdi
leaq 0xd3b6(%rip), %rsi      # 0x1736c
callq 0x31a0
movq %rax, %rdi
movq 0x13fe3(%rip), %rsi     # 0x1dfa8
callq 0x31c0
movq %rax, %rdi
leaq 0xd2e0(%rip), %rsi      # 0x172b4
callq 0x31a0
movq %rax, %rdi
movq 0x13fc5(%rip), %rsi     # 0x1dfa8
callq 0x31c0
movq %rax, %rdi
leaq 0xd3a9(%rip), %rsi      # 0x1739b
callq 0x31a0
movq %rax, %rdi
movq 0x13fa7(%rip), %rsi     # 0x1dfa8
callq 0x31c0
movq %rax, %rdi
leaq 0xd34a(%rip), %rsi      # 0x1735a
callq 0x31a0
movq %rax, %rdi
movq 0x13f89(%rip), %rsi     # 0x1dfa8
callq 0x31c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: carlos-urena[P]svg-gen/svgobjects.cpp
// Function: write_color(std::ostream&, VectorTempl3<float> const&)
void write_color( std::ostream & os, const vec3 & col )
{

  os << "rgb("
     << col[0]*100.0 << "%,"
     << col[1]*100.0 << "%,"
     << col[2]*100.0 << "%)"  ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd3af(%rip), %rsi      # 0x173fa
callq 0x31a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f10
movq -0x28(%rbp), %rdi
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xd157(%rip), %xmm1     # 0x171c8
mulsd %xmm1, %xmm0
callq 0x32c0
movq %rax, %rdi
leaq 0xd368(%rip), %rsi      # 0x173ec
callq 0x31a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f10
movq -0x20(%rbp), %rdi
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xd11d(%rip), %xmm1     # 0x171c8
mulsd %xmm1, %xmm0
callq 0x32c0
movq %rax, %rdi
leaq 0xd32e(%rip), %rsi      # 0x173ec
callq 0x31a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f10
movq -0x18(%rbp), %rdi
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xd0e3(%rip), %xmm1     # 0x171c8
mulsd %xmm1, %xmm0
callq 0x32c0
movq %rax, %rdi
leaq 0xd2f7(%rip), %rsi      # 0x173ef
callq 0x31a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: carlos-urena[P]svg-gen/svgobjects.cpp
// Function: write_stroke_color(std::ostream&, VectorTempl3<float> const&)
void write_stroke_color( std::ostream & os, const vec3 & col )
{

  os << "stroke='rgb("
     << col[0]*100.0 << "%,"
     << col[1]*100.0 << "%,"
     << col[2]*100.0 << "%)' " << std::endl ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd2c7(%rip), %rsi      # 0x173f2
callq 0x31a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f10
movq -0x28(%rbp), %rdi
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xd077(%rip), %xmm1     # 0x171c8
mulsd %xmm1, %xmm0
callq 0x32c0
movq %rax, %rdi
leaq 0xd288(%rip), %rsi      # 0x173ec
callq 0x31a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f10
movq -0x20(%rbp), %rdi
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xd03d(%rip), %xmm1     # 0x171c8
mulsd %xmm1, %xmm0
callq 0x32c0
movq %rax, %rdi
leaq 0xd24e(%rip), %rsi      # 0x173ec
callq 0x31a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f10
movq -0x18(%rbp), %rdi
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xd003(%rip), %xmm1     # 0x171c8
mulsd %xmm1, %xmm0
callq 0x32c0
movq %rax, %rdi
leaq 0xd227(%rip), %rsi      # 0x173ff
callq 0x31a0
movq %rax, %rdi
movq 0x13dc1(%rip), %rsi     # 0x1dfa8
callq 0x31c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: carlos-urena[P]svg-gen/svgobjects.cpp
// Function: CamRefSys::CamRefSys()
CamRefSys::CamRefSys()
{
  origin = vec3( 0.0, 0.0, 0.0 );
  xAxis   = vec3( 1.0, 0.0, 0.0 );
  yAxis   = vec3( 0.0, 1.0, 0.0 );
  zAxis   = vec3( 0.0, 0.0, 1.0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x93b0
movq -0x70(%rbp), %rdi
addq $0xc, %rdi
callq 0x93b0
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
callq 0x93b0
movq -0x70(%rbp), %rdi
addq $0x24, %rdi
callq 0x93b0
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x8c30
movq -0x70(%rbp), %rax
movq -0x14(%rbp), %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movss 0xccbe(%rip), %xmm0     # 0x17004
movss %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x8c30
movq -0x70(%rbp), %rax
movq -0x2c(%rbp), %rcx
movq %rcx, 0xc(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x14(%rax)
xorps %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
movss 0xcc72(%rip), %xmm0     # 0x17004
movss %xmm0, -0x4c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x50(%rbp)
leaq -0x44(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x8c30
movq -0x70(%rbp), %rax
movq -0x44(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x3c(%rbp), %ecx
movl %ecx, 0x20(%rax)
xorps %xmm0, %xmm0
movss %xmm0, -0x60(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x64(%rbp)
movss 0xcc26(%rip), %xmm0     # 0x17004
movss %xmm0, -0x68(%rbp)
leaq -0x5c(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq 0x8c30
movq -0x70(%rbp), %rax
movq -0x5c(%rbp), %rcx
movq %rcx, 0x24(%rax)
movl -0x54(%rbp), %ecx
movl %ecx, 0x2c(%rax)
addq $0x70, %rsp
popq %rbp
retq
// File: carlos-urena[P]svg-gen/svgobjects.cpp
// Function: PathStyle::PathStyle()
PathStyle::PathStyle()
{
  draw_lines   = true ;
  draw_filled  = true ;
  close_lines  = true ;
  lines_color  = vec3(0.0,0.0,0.0);
  fill_color   = vec3(1.0,0.5,0.5);
  fill_opacity = 0.5 ;
  lines_width  = 0.05 ;
  dashed_lines = false ;

  use_grad_fill = false ;
  grad_fill_name = "no name" ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x93b0
movq -0x50(%rbp), %rdi
addq $0xc, %rdi
callq 0x93b0
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x58(%rbp)
callq 0x3220
movq -0x50(%rbp), %rax
movb $0x1, 0x18(%rax)
movb $0x1, 0x1a(%rax)
movb $0x1, 0x19(%rax)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x8c30
jmp 0xa9f3
movq -0x50(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x14(%rbp), %rcx
movq %rcx, (%rax)
movl $0x3f800000, -0x3c(%rbp) # imm = 0x3F800000
movl $0x3f000000, -0x40(%rbp) # imm = 0x3F000000
movl $0x3f000000, -0x44(%rbp) # imm = 0x3F000000
leaq -0x38(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x44(%rbp), %rcx
callq 0x8c30
jmp 0xaa30
movq -0x50(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, 0x14(%rdi)
movq -0x38(%rbp), %rax
movq %rax, 0xc(%rdi)
movl $0x3f000000, 0x20(%rdi) # imm = 0x3F000000
movl $0x3d4ccccd, 0x1c(%rdi) # imm = 0x3D4CCCCD
movb $0x0, 0x24(%rdi)
movb $0x0, 0x25(%rdi)
addq $0x28, %rdi
leaq 0xcaf8(%rip), %rsi      # 0x1755b
callq 0x31f0
jmp 0xaa6a
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x30f0
movq -0x28(%rbp), %rdi
callq 0x3280
nop
// File: carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Point::drawSVG(SVGContext&)
void Point::drawSVG( SVGContext & ctx )
{
  assert( projected );
  using namespace std ;


  PathStyle e ;
  e.draw_lines   = false ;
  e.draw_filled  = true ;
  e.fill_color   = color ;
  e.fill_opacity = 1.0;

  assert( ctx.os != nullptr );
  std::ostream & os = *(ctx.os) ;

  os << "<circle cx='" << pos2D[0] << "' cy='" << pos2D[1]
     <<       "' r='" << radius << "' " ;
  e.writeSVG( ctx );
  os << "/>" << endl ;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
testb $0x1, 0x8(%rax)
je 0xae13
jmp 0xae32
leaq 0xcd3f(%rip), %rdi      # 0x17b59
leaq 0xc64f(%rip), %rsi      # 0x17470
movl $0xf6, %edx
leaq 0xc7bf(%rip), %rcx      # 0x175ec
callq 0x3100
leaq -0x58(%rbp), %rdi
callq 0xa980
movq -0x78(%rbp), %rax
movb $0x0, -0x40(%rbp)
movb $0x1, -0x3e(%rbp)
movq 0x28(%rax), %rcx
movq %rcx, -0x4c(%rbp)
movl 0x30(%rax), %eax
movl %eax, -0x44(%rbp)
movss 0xc1a7(%rip), %xmm0     # 0x17004
movss %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xae6e
jmp 0xae8d
leaq 0xc7a1(%rip), %rdi      # 0x17616
leaq 0xc5f4(%rip), %rsi      # 0x17470
movl $0x100, %edx            # imm = 0x100
leaq 0xc764(%rip), %rcx      # 0x175ec
callq 0x3100
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
leaq 0xc785(%rip), %rsi      # 0x17628
callq 0x31a0
movq %rax, -0x80(%rbp)
jmp 0xaeae
movq -0x78(%rbp), %rdi
addq $0x34, %rdi
callq 0x13470
movq %rax, -0x88(%rbp)
jmp 0xaec4
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rax
movss (%rax), %xmm0
callq 0x3120
movq %rax, -0x90(%rbp)
jmp 0xaee1
movq -0x90(%rbp), %rdi
leaq 0xc746(%rip), %rsi      # 0x17635
callq 0x31a0
movq %rax, -0x98(%rbp)
jmp 0xaefd
movq -0x78(%rbp), %rdi
addq $0x34, %rdi
callq 0x13470
movq %rax, -0xa0(%rbp)
jmp 0xaf13
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rax
movss 0x4(%rax), %xmm0
callq 0x3120
movq %rax, -0xa8(%rbp)
jmp 0xaf34
movq -0xa8(%rbp), %rdi
leaq 0xc6fa(%rip), %rsi      # 0x1763c
callq 0x31a0
movq %rax, -0xb0(%rbp)
jmp 0xaf50
movq -0xb0(%rbp), %rdi
movq -0x78(%rbp), %rax
movss 0x3c(%rax), %xmm0
callq 0x3120
movq %rax, -0xb8(%rbp)
jmp 0xaf6e
movq -0xb8(%rbp), %rdi
leaq 0xc485(%rip), %rsi      # 0x17401
callq 0x31a0
jmp 0xaf83
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xaa90
jmp 0xaf92
movq -0x60(%rbp), %rdi
leaq 0xc3ba(%rip), %rsi      # 0x17357
callq 0x31a0
movq %rax, -0xc0(%rbp)
jmp 0xafab
movq -0xc0(%rbp), %rdi
movq 0x12fef(%rip), %rsi     # 0x1dfa8
callq 0x31c0
jmp 0xafc0
leaq -0x58(%rbp), %rdi
callq 0x13480
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x13480
movq -0x68(%rbp), %rdi
callq 0x3280
// File: carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Point::project(Camera const&)
void Point::project( const Camera & cam )
{
  pos2D     = cam.project( pos3D );
  min       = pos2D ;
  max       = pos2D ;
  projected = true ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1c, %rsi
callq 0xa930
movq -0x20(%rbp), %rax
movlpd %xmm0, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x34(%rax)
movq 0x34(%rax), %rcx
movq %rcx, 0xc(%rax)
movq 0x34(%rax), %rcx
movq %rcx, 0x14(%rax)
movb $0x1, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Polygon::project(Camera const&)
void Polygon::project( const Camera & cam )
{
  bool primero = true ;
  points2D.clear() ;

  for( const vec3 & p3 : points3D )
  {
    const vec2 p2 = cam.project( p3 );
    if ( primero )
    { min = p2 ;
      max = p2 ;
      primero = false ;
    }
    else
    { min[0] = std::min( min[0], p2[0] );
      min[1] = std::min( min[1], p2[1] );
      max[0] = std::max( max[0], p2[0] );
      max[1] = std::max( max[1], p2[1] );
    }
    points2D.push_back( p2 );
    //using namespace std ;
    //cout << "min ==" << min << ", max == " << max << endl ;
  }
  projected = true ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movb $0x1, -0x11(%rbp)
addq $0x80, %rdi
callq 0x134e0
movq -0x48(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x13500
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x13530
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13560
testb $0x1, %al
jne 0xb127
jmp 0xb2b7
leaq -0x28(%rbp), %rdi
callq 0x135a0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xa930
movlpd %xmm0, -0x40(%rbp)
testb $0x1, -0x11(%rbp)
je 0xb169
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0xc(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x14(%rax)
movb $0x0, -0x11(%rbp)
jmp 0xb295
movq -0x48(%rbp), %rdi
addq $0xc, %rdi
callq 0x13470
movq %rax, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x13300
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x135c0
movq -0x48(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x7c(%rbp)
addq $0xc, %rdi
callq 0x13470
movss -0x7c(%rbp), %xmm0
movq -0x48(%rbp), %rdi
movss %xmm0, (%rax)
addq $0xc, %rdi
callq 0x13470
addq $0x4, %rax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x13300
movq -0x78(%rbp), %rdi
movq %rax, %rsi
addq $0x4, %rsi
callq 0x135c0
movq -0x48(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x6c(%rbp)
addq $0xc, %rdi
callq 0x13470
movss -0x6c(%rbp), %xmm0
movq -0x48(%rbp), %rdi
movss %xmm0, 0x4(%rax)
addq $0x14, %rdi
callq 0x13470
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x13300
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x13600
movq -0x48(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x5c(%rbp)
addq $0x14, %rdi
callq 0x13470
movss -0x5c(%rbp), %xmm0
movq -0x48(%rbp), %rdi
movss %xmm0, (%rax)
addq $0x14, %rdi
callq 0x13470
addq $0x4, %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x13300
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x4, %rsi
callq 0x13600
movq -0x48(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
addq $0x14, %rdi
callq 0x13470
movss -0x4c(%rbp), %xmm0
movss %xmm0, 0x4(%rax)
movq -0x48(%rbp), %rdi
addq $0x80, %rdi
leaq -0x40(%rbp), %rsi
callq 0x13640
leaq -0x28(%rbp), %rdi
callq 0x136b0
jmp 0xb111
movq -0x48(%rbp), %rax
movb $0x1, 0x8(%rax)
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: carlos-urena[P]svg-gen/svgobjects.cpp
// Function: Sphere::project(Camera const&)
void Sphere::project( const Camera & cam )
{
  center2D = cam.project( center3D );
  radius2D  = radius3D ; // this works fine only assuming parallel projection

  projected = true ;
  min = center2D-vec2(radius2D,radius2D);
  max = center2D+vec2(radius2D,radius2D);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x24, %rsi
callq 0xa930
movq -0x40(%rbp), %rax
movlpd %xmm0, -0x18(%rbp)
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, -0x50(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x30(%rax)
movss 0x1c(%rax), %xmm0
movq %rax, %rdx
addq $0x20, %rdx
movq %rdx, -0x58(%rbp)
movss %xmm0, 0x20(%rax)
movb $0x1, 0x8(%rax)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq %rdx, %rsi
callq 0x133b0
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x139d0
movq -0x40(%rbp), %rdi
movlpd %xmm0, -0x20(%rbp)
addq $0xc, %rdi
leaq -0x20(%rbp), %rsi
callq 0x13a60
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdx, %rsi
callq 0x133b0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x13ad0
movq -0x40(%rbp), %rdi
movlpd %xmm0, -0x30(%rbp)
addq $0x14, %rdi
leaq -0x30(%rbp), %rsi
callq 0x13a60
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)