LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: doeclim_hindcast(DICE*)
void doeclim_hindcast(DICE *dice)
{
  Clim *clim = &dice->clim;
  Config *config = &dice->config;
  
  for(int t=0; t<config->hind_ns; t++) {
    
    doeclim_ts(t, config->dt, config->ns, clim->forc, 
            clim->flnd, clim->powtoheat, clim->cal, clim->cas,
            clim->taucfl, clim->taukls, clim->taucfs, clim->tauksl,
            clim->bsi, clim->IB, clim->A, clim->fso,
            clim->taudif, clim->Ker, clim->temp, clim->temp_landair, clim->temp_sst, 
            clim->heat_mixed, clim->heat_interior, 
            clim->heatflux_mixed, clim->heatflux_interior);
  }
		
  // Index (config->hind_ns - 1) should now contain the initial values
  // of temperature and for running CDICE.

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl 0x20(%rbx), %ebp
jge 0x70db
movl 0x24(%rbx), %esi
movl 0x28(%rbx), %edx
movq 0xb0(%rbx), %rcx
movsd 0xb8(%rbx), %xmm0
movsd 0xc0(%rbx), %xmm1
movsd 0xc8(%rbx), %xmm2
movsd 0xd0(%rbx), %xmm3
movsd 0xd8(%rbx), %xmm4
movsd 0xe0(%rbx), %xmm5
movsd 0xe8(%rbx), %xmm6
movsd 0xf0(%rbx), %xmm7
movsd 0xf8(%rbx), %xmm8
movq 0x100(%rbx), %r8
movq 0x108(%rbx), %r9
movsd 0x110(%rbx), %xmm9
movsd 0x118(%rbx), %xmm10
movq 0x120(%rbx), %rax
movq 0x140(%rbx), %rdi
movq 0x148(%rbx), %r10
movq 0x150(%rbx), %r11
movq 0x158(%rbx), %r14
movq 0x160(%rbx), %r15
movq 0x168(%rbx), %r12
movq 0x170(%rbx), %r13
movq %r13, 0x50(%rsp)
movq %r12, 0x48(%rsp)
movq %r15, 0x40(%rsp)
movq %r14, 0x38(%rsp)
movq %r11, 0x30(%rsp)
movq %r10, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x8(%rsp)
movsd %xmm8, (%rsp)
movl %ebp, %edi
callq 0x59df
incl %ebp
jmp 0x6fda
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: doeclim_dice_ts(DICE*, int)
void doeclim_dice_ts(DICE *dice, int ts)
{

  Clim *clim = &dice->clim;
  Carb *carb = &dice->carb;
  Config *config = &dice->config;

  // Get the range of doeclim time steps associated with this
  // DICE time step.
  int start = config->hind_ns + ((ts-1) * config->tstep);
  int finish = config->hind_ns + (ts * config->tstep);

  // Get a linear interpolation of the forcing for this time step
  double dforc = (carb->forc[ts] - carb->forc[ts-1]) / double(config->tstep);

  for(int i=start; i<finish; i++) {
    
    // Calculate the forcing needed for this doeclim time step
    clim->forc[i] = carb->forc[ts-1] + (double(i-start+1) * dforc);
    
    // Run doeclim for this doeclim time step using the interpolated forcing.
    doeclim_ts(i, config->dt, config->ns, clim->forc, 
	       clim->flnd, clim->powtoheat, clim->cal, clim->cas,
	       clim->taucfl, clim->taukls, clim->taucfs, clim->tauksl,
	       clim->bsi, clim->IB, clim->A, clim->fso,
	       clim->taudif, clim->Ker, clim->temp, clim->temp_landair, clim->temp_sst, 
	       clim->heat_mixed, clim->heat_interior, 
	       clim->heatflux_mixed, clim->heatflux_interior);
  }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
cvtsi2sdl 0x20(%rdi), %xmm0
movslq %esi, %rax
leal -0x1(%rax), %ecx
cvtsi2sd %ecx, %xmm1
leaq -0x1(%rax), %rcx
movq %rcx, 0x68(%rsp)
movsd 0x8(%rdi), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %ecx
cvtsi2sd %eax, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movq 0x470(%rdi), %rsi
movsd (%rsi,%rax,8), %xmm0
subsd -0x8(%rsi,%rax,8), %xmm0
divsd %xmm2, %xmm0
movsd %xmm0, 0x60(%rsp)
movslq %ecx, %r14
movslq %edx, %rax
movq %rax, 0x70(%rsp)
pushq $0x1
popq %rcx
cmpq 0x70(%rsp), %r14
jge 0x728e
movq 0x470(%rbx), %rax
cvtsi2sd %ecx, %xmm0
mulsd 0x60(%rsp), %xmm0
movl %ecx, 0x5c(%rsp)
movq 0x68(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq 0xb0(%rbx), %rcx
movsd %xmm0, (%rcx,%r14,8)
movl 0x24(%rbx), %esi
movl 0x28(%rbx), %edx
movsd 0xb8(%rbx), %xmm0
movsd 0xc0(%rbx), %xmm1
movsd 0xc8(%rbx), %xmm2
movsd 0xd0(%rbx), %xmm3
movsd 0xd8(%rbx), %xmm4
movsd 0xe0(%rbx), %xmm5
movsd 0xe8(%rbx), %xmm6
movsd 0xf0(%rbx), %xmm7
movsd 0xf8(%rbx), %xmm8
movq 0x100(%rbx), %r8
movq 0x108(%rbx), %r9
movsd 0x110(%rbx), %xmm9
movsd 0x118(%rbx), %xmm10
movq 0x120(%rbx), %rax
movq 0x140(%rbx), %rdi
movq 0x148(%rbx), %r10
movq 0x150(%rbx), %r11
movq 0x158(%rbx), %r13
movq 0x160(%rbx), %r15
movq 0x168(%rbx), %r12
movq 0x170(%rbx), %rbp
movq %rbp, 0x50(%rsp)
movq %r12, 0x48(%rsp)
movq %r15, 0x40(%rsp)
movq %r13, 0x38(%rsp)
movq %r11, 0x30(%rsp)
movq %r10, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x8(%rsp)
movsd %xmm8, (%rsp)
movl %r14d, %edi
callq 0x59df
movl 0x5c(%rsp), %ecx
incq %r14
incl %ecx
jmp 0x715e
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: doeclim_load_hind_forc(DICE*)
void doeclim_load_hind_forc(DICE *dice)
{

  FILE * fp;
  fp = fopen("./giss_forc_component_1900_2015_extrap.txt", "r");

  int counter = 0;
  float temp_forc;
	float yr, ghg, o3, sh2o, refa, aie, bc, snow, stra, solar, land;
  while(!feof(fp)) {
    if (fscanf(fp, "%g %g %g %g %g %g %g %g %g %g %g", &yr, &ghg, &o3, &sh2o, &refa, &aie, &bc, &snow, &stra, &solar, &land) != 11) { break; }

    temp_forc = ghg + o3 + sh2o + stra + solar + land + (dice->clim.alpha * (refa + aie + bc + snow));

    dice->clim.forc[counter] = double(temp_forc);
    counter++;
    if (counter >= dice->config.hind_ns) {
      break;
    }
  }
  fclose(fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x100b(%rip), %rdi      # 0x82c0
leaq 0xfd4(%rip), %rsi       # 0x8290
callq 0x21f0
movq %rax, %r14
leaq 0x30(%rsp), %r13
leaq 0x2c(%rsp), %rbp
leaq 0x28(%rsp), %r15
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x22a0
testl %eax, %eax
jne 0x73b8
subq $0x8, %rsp
movq %r14, %rdi
leaq 0xff7(%rip), %rsi       # 0x82eb
leaq 0x3c(%rsp), %rdx
movq %r13, %rcx
movq %rbp, %r8
movq %r15, %r9
xorl %eax, %eax
leaq 0x14(%rsp), %r10
pushq %r10
leaq 0x20(%rsp), %r10
pushq %r10
leaq 0x2c(%rsp), %r10
pushq %r10
leaq 0x38(%rsp), %r10
pushq %r10
leaq 0x44(%rsp), %r10
pushq %r10
leaq 0x50(%rsp), %r10
pushq %r10
leaq 0x5c(%rsp), %r10
pushq %r10
callq 0x2370
addq $0x40, %rsp
cmpl $0xb, %eax
jne 0x73b8
movss 0x30(%rsp), %xmm0
addss 0x2c(%rsp), %xmm0
addss 0x28(%rsp), %xmm0
addss 0x14(%rsp), %xmm0
addss 0x10(%rsp), %xmm0
addss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movss 0x24(%rsp), %xmm1
addss 0x20(%rsp), %xmm1
addss 0x1c(%rsp), %xmm1
addss 0x18(%rsp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd 0xa8(%rbx), %xmm1
addsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movq 0xb0(%rbx), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movslq 0x20(%rbx), %rax
cmpq %rax, %r12
jl 0x72d6
movq %r14, %rdi
callq 0x21a0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xf27(%rip), %rdi       # 0x8310
leaq 0xea0(%rip), %rsi       # 0x8290
callq 0x21f0
movq %rax, %r14
movslq %ebp, %r15
leaq 0x10(%rsp), %r13
leaq 0xc(%rsp), %rbp
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x22a0
testl %eax, %eax
jne 0x7476
movq %r14, %rdi
leaq 0xee5(%rip), %rsi       # 0x8303
leaq 0x14(%rsp), %rdx
movq %r13, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x2370
cmpl $0x3, %eax
jne 0x7476
cvtss2sd 0x14(%rsp), %xmm0
movq 0x178(%rbx), %rax
movsd %xmm0, (%rax,%r12,8)
cvtss2sd 0x10(%rsp), %xmm0
movq 0x180(%rbx), %rax
movsd %xmm0, (%rax,%r12,8)
cvtss2sd 0xc(%rsp), %xmm0
movq 0x188(%rbx), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpq %r15, %r12
jl 0x7408
movq %r14, %rdi
callq 0x21a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: apply_calibration(DICE*, double)
void apply_calibration(DICE *dice, double this_cs)
{
	// Loop iterator
	int i;
	
	// Setup variables to find the bounds around a particular cs
	int ihigh = 0;
	int ilow = 0;
	double diffh = 999.9;
	double diffl = -999.9;
	double this_diff = 0.0;
	double cs_range = 0.0;
	double cs_diff = 0.0;
		
	// Loop through the calibration data
	for(i=0; i<dice->config.n_calpoints; i++) {

		// Find the difference between this_cs and the calibration point
		this_diff = dice->clim.cs_cal[i] - this_cs;
		
		// If this is an exact match, set the kv and alpha values and return
		if(this_diff == 0.0) {
			ilow = i;
			ihigh = i;
			break;
		}
		
		// Otherwise, test this index as a bound
		if(this_diff >= 0.0 && this_diff < diffh) {
			ihigh = i;
			diffh = this_diff;
			}
		else if(this_diff <= 0.0 && this_diff > diffl) {
			ilow = i;
			diffl = this_diff;
		}	
	}
	
	// Now that we have the bounds, calculate the kv and alpha values
	// through a simple linear-interpolation between the bound points
	if(ilow == ihigh) {
		dice->clim.kappa = dice->clim.kv_cal[ilow];
		dice->clim.alpha = dice->clim.alpha_cal[ilow];
	}
	else {
		cs_range = dice->clim.cs_cal[ihigh] - dice->clim.cs_cal[ilow];
		cs_diff = this_cs - dice->clim.cs_cal[ilow];
		dice->clim.kappa = ((cs_diff/cs_range) * (dice->clim.kv_cal[ihigh] - dice->clim.kv_cal[ilow])) + dice->clim.kv_cal[ilow];
		dice->clim.alpha = ((cs_diff/cs_range) * (dice->clim.alpha_cal[ihigh] - dice->clim.alpha_cal[ilow])) + dice->clim.alpha_cal[ilow];
	}

	return;
}

// Assembly:
movl 0x30(%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
movsd 0xd81(%rip), %xmm3      # 0x8220
movsd 0xd81(%rip), %xmm2      # 0x8228
xorpd %xmm1, %xmm1
xorl %edx, %edx
xorl %esi, %esi
cmpq %rax, %rcx
je 0x74f8
movq 0x178(%rdi), %r8
movsd (%r8,%rax,8), %xmm4
subsd %xmm0, %xmm4
ucomisd %xmm1, %xmm4
jne 0x74d1
jnp 0x7563
jb 0x74e1
ucomisd %xmm4, %xmm2
jbe 0x74e1
movl %eax, %edx
movapd %xmm4, %xmm2
jmp 0x74f3
ucomisd %xmm4, %xmm1
jb 0x74f3
ucomisd %xmm3, %xmm4
jbe 0x74f3
movl %eax, %esi
movapd %xmm4, %xmm3
incq %rax
jmp 0x74af
cmpl %edx, %esi
je 0x7565
movslq %edx, %rax
movq 0x178(%rdi), %rcx
movq 0x180(%rdi), %rdx
movsd (%rcx,%rax,8), %xmm1
movslq %esi, %rsi
movsd (%rcx,%rsi,8), %xmm2
subsd %xmm2, %xmm1
subsd %xmm2, %xmm0
divsd %xmm1, %xmm0
movsd (%rdx,%rax,8), %xmm1
movsd (%rdx,%rsi,8), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0xa0(%rdi)
movq 0x188(%rdi), %rcx
movsd (%rcx,%rax,8), %xmm1
movsd (%rcx,%rsi,8), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
jmp 0x7588
movl %eax, %edx
movslq %edx, %rax
movq 0x180(%rdi), %rcx
movq 0x188(%rdi), %rdx
movsd (%rcx,%rax,8), %xmm0
movsd %xmm0, 0xa0(%rdi)
movsd (%rdx,%rax,8), %xmm1
movsd %xmm1, 0xa8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movb (%rdi), %dl
testb %dl, %dl
je 0x40f2
movb (%rsi), %al
cmpb $0x2a, %al
je 0x40f2
cmpb %dl, %al
setne %cl
cmpb $0x3f, %al
setne %al
testb %al, %cl
jne 0x414c
incq %rsi
incq %rdi
jmp 0x40d0
xorl %eax, %eax
xorl %ecx, %ecx
testb %dl, %dl
je 0x413d
movb (%rsi), %r8b
cmpb $0x2a, %r8b
jne 0x4115
cmpb $0x0, 0x1(%rsi)
je 0x414f
incq %rsi
leaq 0x1(%rdi), %rax
movq %rsi, %rcx
jmp 0x4139
cmpb %dl, %r8b
setne %dl
cmpb $0x3f, %r8b
setne %r8b
testb %r8b, %dl
jne 0x4130
incq %rsi
incq %rdi
jmp 0x4139
movq %rax, %rdi
incq %rax
movq %rcx, %rsi
movb (%rdi), %dl
jmp 0x40f6
movb (%rsi), %al
incq %rsi
cmpb $0x2a, %al
je 0x413d
testb %al, %al
sete %al
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %r12
xorl %r13d, %r13d
pushq $0x60
popq %rbp
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rax
subq %rdi, %rax
cqto
idivq %rbp
movq %rax, %r15
incq %r12
cmpq %rax, %r12
jae 0x6ed5
addq %r13, %rdi
addq $0x60, %r13
movq %rbx, %rsi
callq 0x6c69
testb %al, %al
je 0x6ea7
cmpq %r15, %r12
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3240
leaq 0x39dd(%rip), %rcx      # 0xa8e4
leaq 0x39dd(%rip), %rsi      # 0xa8eb
cmpb $0x0, 0x87c(%r14)
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x3250
xorl %r12d, %r12d
leaq 0x31bd(%rip), %r15      # 0xa0e9
movq %rbx, %rdi
cmpq $0x6, %r12
je 0x6f52
movq %r15, %rsi
callq 0x3250
movl 0x864(%r14,%r12,4), %esi
movq %rax, %rdi
callq 0x3450
incq %r12
jmp 0x6f2c
callq 0x3140
xorl %r12d, %r12d
pushq $0x60
popq %r13
leaq 0x3184(%rip), %r15      # 0xa0e9
xorl %ebp, %ebp
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rax
subq %rsi, %rax
cqto
idivq %r13
cmpq %rax, %rbp
jae 0x6f9b
addq %r12, %rsi
movq %rbx, %rdi
callq 0x3240
movq %rax, %rdi
movq %r15, %rsi
callq 0x3250
incq %rbp
addq $0x60, %r12
jmp 0x6f67
cmpq $0x0, 0x888(%r14)
je 0x6fc6
addq $0x880, %r14            # imm = 0x880
leaq 0x393f(%rip), %rsi      # 0xa8f2
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
movq %r14, %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3140
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]def2fgd/src/entreader.cpp
// Function: descriptionLines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string descriptionLines(const std::string& description)
{
    std::string toReturn;
    std::istringstream stream(description);

    std::string line;
    while(getline(stream, line))
    {
        bool sectionName = true;
        if (line.size() > 8) {
            for (size_t i=0; i<8; ++i) {
                sectionName = sectionName && line[i] == '-';
            }
        }

        if (sectionName) { //probably something like -------- KEYS --------. Just skip.
            continue;
        }

        if (toReturn.empty()) {
            toReturn = withoutQuotes(line);
        } else {
            toReturn += "\\n\\n";
            toReturn += withoutQuotes(line);
        }
    }

    return toReturn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x88(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x3420
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x88(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x48(%rsp), %r12
leaq 0x68(%rsp), %r13
leaq 0x28(%rsp), %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x3080
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x71d9
cmpq $0x9, 0x10(%rsp)
jb 0x7109
movb $0x1, %cl
movq 0x8(%rsp), %rax
xorl %edx, %edx
cmpq $0x8, %rdx
je 0x7152
testb $0x1, %cl
je 0x714b
cmpb $0x2d, (%rax,%rdx)
sete %cl
jmp 0x714d
xorl %ecx, %ecx
incq %rdx
jmp 0x7137
testb $0x1, %cl
jne 0x7109
cmpq $0x0, 0x8(%rbx)
je 0x71a3
movq %rbx, %rdi
leaq 0x3738(%rip), %rsi      # 0xa8a0
callq 0x3490
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3340
movq %r13, %rdi
movq %rbp, %rsi
callq 0x6cdf
movq %rbx, %rdi
movq %r13, %rsi
callq 0x34a0
movq %r13, %rdi
callq 0x3110
movq %rbp, %rdi
callq 0x3110
jmp 0x7109
movq %r12, %rdi
movq %r15, %rsi
callq 0x3340
movq %r13, %rdi
movq %r12, %rsi
callq 0x6cdf
movq %rbx, %rdi
movq %r13, %rsi
callq 0x32f0
movq %r13, %rdi
callq 0x3110
movq %r12, %rdi
callq 0x3110
jmp 0x7109
leaq 0x8(%rsp), %rdi
callq 0x3110
leaq 0x88(%rsp), %rdi
callq 0x3120
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x7252
movq %rax, %r14
leaq 0x48(%rsp), %rdi
jmp 0x722d
jmp 0x7238
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x3110
jmp 0x7228
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3110
jmp 0x723b
jmp 0x7238
jmp 0x7238
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3110
leaq 0x88(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3110
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x30(%rdi)
je 0x7ef5
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0x7eda
movl %ecx, %ebp
movq %rdx, %r14
testq %rdx, %rdx
jne 0x7e88
movq %rbx, %rdi
callq 0x8c5a
movq %rax, %r14
movq 0x38(%r15), %r15
leaq 0x73f7(%rip), %r13      # 0xf28a
movzbl %bpl, %ebp
pushq $0x1
popq %r12
testq %r15, %r15
je 0x7ee0
movq (%r15), %rsi
testq %rsi, %rsi
je 0x7eb1
movq %rsi, %rdi
movq 0x10(%r15), %rsi
jmp 0x7eb4
movq %r13, %rdi
movq %rbx, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x94ff
testb %al, %al
jne 0x7ee3
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %r12d, %ecx
callq 0x954e
movq %rax, %r15
jmp 0x7e9b
movq 0x38(%r15), %r15
jmp 0x7ee3
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d1a(%rip), %rdi      # 0xac16
leaq 0x2a62(%rip), %rsi      # 0xa965
leaq 0x2d19(%rip), %rcx      # 0xac23
movl $0x3c0, %edx            # imm = 0x3C0
callq 0x31b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x0, 0x20(%rdi)
je 0x95cd
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x95b9
movl %ecx, %ebp
movq %rdx, %r15
testq %rdx, %rdx
jne 0x957d
movq %r14, %rdi
callq 0x8c5a
movq %rax, %r15
leaq 0x5d06(%rip), %r12      # 0xf28a
movzbl %bpl, %ebp
movq 0x50(%rbx), %rbx
testq %rbx, %rbx
je 0x95bf
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x95a2
movq %rsi, %rdi
movq 0x10(%rbx), %rsi
jmp 0x95a5
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
movl %ebp, %r8d
callq 0x94ff
testb %al, %al
je 0x9588
jmp 0x95c1
movq 0x50(%rbx), %rbx
jmp 0x95c1
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15d1(%rip), %rdi      # 0xaba5
leaq 0x138a(%rip), %rsi      # 0xa965
leaq 0x16a0(%rip), %rcx      # 0xac82
movl $0x3d7, %edx            # imm = 0x3D7
callq 0x31b0
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/figures.cpp
// Function: Figure7_PSA_shape::Figure7_PSA_shape()
Figure7_PSA_shape::Figure7_PSA_shape()
{
   // configure base class

   disk_center = vec3( 3.0, 3.0, 0.0 );
   disk_radius = 2.2 ;
   draw_projectors = true ;
   flip_axes = true ;

   // create original disk
   const vec3
      disk_center_norm = disk_center.normalized(),
      disk_axis_1      = disk_center.cross( {0.0,1.0,0.0} ).normalized(),
      disk_axis_2      = disk_axis_1.cross( disk_center_norm  ).normalized() ;

   original_pol = new Ellipse( 256, disk_center, disk_radius*disk_axis_1,
                                                 disk_radius*disk_axis_2 );

   // initilize base class
   initialize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x8796
leaq 0x88(%rbx), %r14
movaps 0x62af(%rip), %xmm0     # 0xb090
movups %xmm0, 0x88(%rbx)
movb $0x1, %al
movb %al, 0x98(%rbx)
movb %al, 0x6c(%rbx)
movq %r14, %rdi
callq 0x5372
movss %xmm0, -0x44(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x40(%rbp)
movss %xmm1, -0x3c(%rbp)
movabsq $0x3f80000000000000, %rax # imm = 0x3F80000000000000
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
andl $0x0, 0x8(%rsi)
movq %r14, %rdi
callq 0x5398
leaq -0x38(%rbp), %rdi
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
callq 0x5372
leaq -0x50(%rbp), %rdi
movss %xmm0, (%rdi)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, 0x4(%rdi)
movss %xmm1, 0x8(%rdi)
leaq -0x44(%rbp), %rsi
callq 0x5398
leaq -0x28(%rbp), %rdi
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
callq 0x5372
movss %xmm0, -0x38(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x34(%rbp)
movss %xmm1, -0x30(%rbp)
movl $0x98, %edi
callq 0x31b0
movq %rax, %r15
movss 0x94(%rbx), %xmm0
leaq -0x50(%rbp), %rdi
callq 0x52f1
movlps %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movss 0x94(%rbx), %xmm0
leaq -0x38(%rbp), %rdi
callq 0x52f1
leaq -0x28(%rbp), %rcx
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x70d6
movq %r15, 0xa0(%rbx)
movq %rbx, %rdi
callq 0x4b92
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4eeb
jmp 0x4eeb
jmp 0x4eeb
movq %rax, %r14
jmp 0x4efb
movq %rax, %r14
movq %r15, %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x53e4
movq %r14, %rdi
callq 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/figures.cpp
// Function: Figure9_PSA_ellipse_lune::Figure9_PSA_ellipse_lune()
Figure9_PSA_ellipse_lune::Figure9_PSA_ellipse_lune()
{
   // configure base class

   disk_center = vec3( 3.0, 1.0, 0.0 );
   disk_radius = 5.0 ;
   draw_projectors = true ;
   flip_axes = true ;

   // create original disk
   const vec3
      disk_center_norm = disk_center.normalized(),
      disk_axis_1      = disk_center.cross( {0.0,1.0,0.0} ).normalized(),
      disk_axis_2      = disk_axis_1.cross( disk_center_norm  ).normalized() ;

   original_pol = new Ellipse( 256, disk_center, disk_radius*disk_axis_1,
                                                 disk_radius*disk_axis_2 );

   // initilize base class
   initialize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x8796
leaq 0x88(%rbx), %r14
movaps 0x6033(%rip), %xmm0     # 0xb0b0
movups %xmm0, 0x88(%rbx)
movb $0x1, %al
movb %al, 0x98(%rbx)
movb %al, 0x6c(%rbx)
movq %r14, %rdi
callq 0x5372
movss %xmm0, -0x44(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x40(%rbp)
movss %xmm1, -0x3c(%rbp)
movabsq $0x3f80000000000000, %rax # imm = 0x3F80000000000000
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
andl $0x0, 0x8(%rsi)
movq %r14, %rdi
callq 0x5398
leaq -0x38(%rbp), %rdi
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
callq 0x5372
leaq -0x50(%rbp), %rdi
movss %xmm0, (%rdi)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, 0x4(%rdi)
movss %xmm1, 0x8(%rdi)
leaq -0x44(%rbp), %rsi
callq 0x5398
leaq -0x28(%rbp), %rdi
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
callq 0x5372
movss %xmm0, -0x38(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x34(%rbp)
movss %xmm1, -0x30(%rbp)
movl $0x98, %edi
callq 0x31b0
movq %rax, %r15
movss 0x94(%rbx), %xmm0
leaq -0x50(%rbp), %rdi
callq 0x52f1
movlps %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movss 0x94(%rbx), %xmm0
leaq -0x38(%rbp), %rdi
callq 0x52f1
leaq -0x28(%rbp), %rcx
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x70d6
movq %r15, 0xa0(%rbx)
movq %rbx, %rdi
callq 0x4b92
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5187
jmp 0x5187
jmp 0x5187
movq %rax, %r14
jmp 0x5197
movq %rax, %r14
movq %r15, %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x53e4
movq %r14, %rdi
callq 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/figures.cpp
// Function: Figure10_PSA_lune::Figure10_PSA_lune()
Figure10_PSA_lune::Figure10_PSA_lune()
{
   // configure base class

   disk_center = vec3( 3.0, -1.0, 0.0 );
   disk_radius = 5.0 ;
   draw_projectors = false ;

   // create original disk
   const vec3
      disk_center_norm = disk_center.normalized(),
      disk_axis_1      = disk_center.cross( {0.0,1.0,0.0} ).normalized(),
      disk_axis_2      = disk_axis_1.cross( disk_center_norm  ).normalized() ;

   original_pol = new Ellipse( 256, disk_center, disk_radius*disk_axis_1,
                                                 disk_radius*disk_axis_2 );

   // initilize base class
   initialize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x8796
leaq 0x88(%rbx), %r14
movaps 0x5ef5(%rip), %xmm0     # 0xb0c0
movups %xmm0, 0x88(%rbx)
movb $0x0, 0x98(%rbx)
movq %r14, %rdi
callq 0x5372
movss %xmm0, -0x44(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x40(%rbp)
movss %xmm1, -0x3c(%rbp)
movabsq $0x3f80000000000000, %rax # imm = 0x3F80000000000000
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
andl $0x0, 0x8(%rsi)
movq %r14, %rdi
callq 0x5398
leaq -0x38(%rbp), %rdi
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
callq 0x5372
leaq -0x50(%rbp), %rdi
movss %xmm0, (%rdi)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, 0x4(%rdi)
movss %xmm1, 0x8(%rdi)
leaq -0x44(%rbp), %rsi
callq 0x5398
leaq -0x28(%rbp), %rdi
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
callq 0x5372
movss %xmm0, -0x38(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, -0x34(%rbp)
movss %xmm1, -0x30(%rbp)
movl $0x98, %edi
callq 0x31b0
movq %rax, %r15
movss 0x94(%rbx), %xmm0
leaq -0x50(%rbp), %rdi
callq 0x52f1
movlps %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movss 0x94(%rbx), %xmm0
leaq -0x38(%rbp), %rdi
callq 0x52f1
leaq -0x28(%rbp), %rcx
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x70d6
movq %r15, 0xa0(%rbx)
movq %rbx, %rdi
callq 0x4b92
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x52d1
jmp 0x52d1
jmp 0x52d1
movq %rax, %r14
jmp 0x52e1
movq %rax, %r14
movq %r15, %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x53e4
movq %r14, %rdi
callq 0x3250
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x535c
movq %r14, %rdi
movl %r15d, %esi
callq 0x54cc
movss (%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x54cc
movss -0x1c(%rbp), %xmm0
subss (%rax), %xmm0
movss %xmm0, -0x28(%rbp,%r15,4)
incq %r15
jmp 0x5322
movsd -0x28(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movss (%rdi), %xmm1
movss 0x4(%rdi), %xmm2
movss 0x8(%rsi), %xmm3
movss 0x8(%rdi), %xmm4
movss (%rsi), %xmm5
movss 0x4(%rsi), %xmm6
movaps %xmm2, %xmm0
mulss %xmm3, %xmm0
mulss %xmm1, %xmm3
mulss %xmm6, %xmm1
mulss %xmm4, %xmm6
subss %xmm6, %xmm0
mulss %xmm5, %xmm4
subss %xmm3, %xmm4
unpcklps %xmm4, %xmm0            # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
mulss %xmm2, %xmm5
subss %xmm5, %xmm1
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x54b7
movq %r14, %rdi
movl %r15d, %esi
callq 0x54cc
movss (%rax), %xmm0
mulss (%rbx), %xmm0
movss %xmm0, -0x28(%rbp,%r15,4)
incq %r15
jmp 0x5492
movsd -0x28(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorps %xmm0, %xmm0
cmpl $0x3, %r15d
je 0x55da
movq %r14, %rdi
movl %r15d, %esi
movsd %xmm0, -0x20(%rbp)
callq 0x54cc
cvtss2sd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x54cc
cvtss2sd (%rax), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
incl %r15d
jmp 0x558f
cvtsd2ss %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x595c(%rip), %rsi      # 0xb324
callq 0x31a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3180
leaq 0x595a(%rip), %rsi      # 0xb339
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x5972(%rip), %rsi      # 0xb368
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x59ae(%rip), %rsi      # 0xb3bb
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x59ea(%rip), %rsi      # 0xb40e
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x58da(%rip), %rsi      # 0xb324
callq 0x31a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3180
leaq 0x59bf(%rip), %rsi      # 0xb420
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x58f0(%rip), %rsi      # 0xb368
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x59c0(%rip), %rsi      # 0xb44f
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x5968(%rip), %rsi      # 0xb40e
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
leaq 0x59e1(%rip), %rsi      # 0xb4ae
callq 0x31a0
cvtss2sd (%rbx), %xmm0
mulsd 0x576a(%rip), %xmm0     # 0xb248
movq %rax, %rdi
callq 0x3200
leaq 0x59b3(%rip), %r14      # 0xb4a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x31a0
cvtss2sd 0x4(%rbx), %xmm0
mulsd 0x5743(%rip), %xmm0     # 0xb248
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
movq %r14, %rsi
callq 0x31a0
cvtss2sd 0x8(%rbx), %xmm0
mulsd 0x5723(%rip), %xmm0     # 0xb248
movq %rax, %rdi
callq 0x3200
leaq 0x596f(%rip), %rsi      # 0xb4a3
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
leaq 0x5955(%rip), %rsi      # 0xb4a6
callq 0x31a0
cvtss2sd (%rbx), %xmm0
mulsd 0x56e6(%rip), %xmm0     # 0xb248
movq %rax, %rdi
callq 0x3200
leaq 0x592f(%rip), %r14      # 0xb4a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x31a0
cvtss2sd 0x4(%rbx), %xmm0
mulsd 0x56bf(%rip), %xmm0     # 0xb248
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
movq %r14, %rsi
callq 0x31a0
cvtss2sd 0x8(%rbx), %xmm0
mulsd 0x569f(%rip), %xmm0     # 0xb248
movq %rax, %rdi
callq 0x3200
leaq 0x58fb(%rip), %rsi      # 0xb4b3
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30d0
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: write_coord2(std::ostream&, VectorTempl2<float> const&)
void write_coord2( std::ostream & os, const vec2 & p )
{
   using namespace std ;
   if ( isnan(p[0]) && isnan(p[1]) )
      cout << "warning: not a number found in vec2. Not written to SVG output file." << endl ;
   else
       os << p[0] << " " << p[1] ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movss (%rsi), %xmm0
ucomiss %xmm0, %xmm0
jnp 0x5c09
movss 0x4(%rbx), %xmm1
ucomiss %xmm1, %xmm1
jnp 0x5c09
movq 0xa3d9(%rip), %rdi      # 0xffc8
leaq 0x58c2(%rip), %rsi      # 0xb4b8
callq 0x31a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30d0
callq 0x3140
leaq 0x58a1(%rip), %rsi      # 0xb4b6
movq %rax, %rdi
callq 0x31a0
movss 0x4(%rbx), %xmm0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3140
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
leaq 0x28(%rdi), %rbx
leaq 0x38(%rdi), %rax
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
movw $0x101, 0x18(%rdi)      # imm = 0x101
movb $0x1, 0x1a(%rdi)
movaps 0x530d(%rip), %xmm0     # 0xb290
movups %xmm0, (%rdi)
movabsq $0x3f0000003f000000, %rax # imm = 0x3F0000003F000000
movq %rax, 0x10(%rdi)
movabsq $0x3f0000003d4ccccd, %rax # imm = 0x3F0000003D4CCCCD
movq %rax, 0x1c(%rdi)
andw $0x0, 0x24(%rdi)
leaq 0x5661(%rip), %rsi      # 0xb60f
movq %rbx, %rdi
callq 0x3280
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x30c0
movq %r14, %rdi
callq 0x3250
// File: /workspace/github_cpp_makefile_star2_O2/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: PathStyle::writeSVG(SVGContext&)
void PathStyle::writeSVG( SVGContext & ctx )
{
  using namespace std ;
  std::ostream & os = *(ctx.os) ;

   os << "   style='" ;

   os << "fill:" ;
   if ( draw_filled )
   {
      if ( use_grad_fill )
      {
         if ( grad_fill_name == "no name" )
            cout << "WARNING: using 'no name' as grad fill name." << endl ;
         os << "url(#" << grad_fill_name << ")" ;
      }
      else
         write_color( os, fill_color ) ;
   }
   else
      os << "none" ;
   os << "; " ;

   if ( draw_filled )
      os << "fill-opacity:" << fill_opacity << "; " ;

   os << "stroke:" ;
   if ( draw_lines )
      write_color( os, lines_color ) ;
   else
      os << "none" ;
   os << "; " ;

   if ( draw_lines )
      os << "stroke-width:" << lines_width << "; " ;

   if ( draw_lines && dashed_lines )
      os << "stroke-dasharray:0.01,0.01; " ;

   os << "' " << endl ;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rsi), %rbx
leaq 0x5632(%rip), %rsi      # 0xb617
movq %rbx, %rdi
callq 0x31a0
leaq 0x562e(%rip), %rsi      # 0xb622
movq %rbx, %rdi
callq 0x31a0
cmpb $0x1, 0x1a(%r14)
jne 0x6062
cmpb $0x1, 0x25(%r14)
jne 0x6073
leaq 0x28(%r14), %r15
leaq 0x55fa(%rip), %rsi      # 0xb60f
movq %r15, %rdi
callq 0x9776
testb %al, %al
je 0x603c
movq 0x9fa0(%rip), %rdi      # 0xffc8
leaq 0x55f9(%rip), %rsi      # 0xb628
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x5611(%rip), %rsi      # 0xb654
movq %rbx, %rdi
callq 0x31a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x3180
leaq 0x5447(%rip), %rsi      # 0xb4a4
movq %rax, %rdi
jmp 0x606c
leaq 0x55f1(%rip), %rsi      # 0xb65a
movq %rbx, %rdi
callq 0x31a0
jmp 0x607f
leaq 0xc(%r14), %rsi
movq %rbx, %rdi
callq 0x5abc
leaq 0x5617(%rip), %rsi      # 0xb69d
movq %rbx, %rdi
callq 0x31a0
cmpb $0x1, 0x1a(%r14)
jne 0x60c1
leaq 0x55c3(%rip), %rsi      # 0xb65f
movq %rbx, %rdi
callq 0x31a0
movss 0x20(%r14), %xmm0
movq %rax, %rdi
callq 0x3140
leaq 0x55e4(%rip), %rsi      # 0xb69d
movq %rax, %rdi
callq 0x31a0
leaq 0x55a5(%rip), %rsi      # 0xb66d
movq %rbx, %rdi
callq 0x31a0
cmpb $0x1, 0x18(%r14)
jne 0x60e4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5abc
jmp 0x60f3
leaq 0x556f(%rip), %rsi      # 0xb65a
movq %rbx, %rdi
callq 0x31a0
leaq 0x55a3(%rip), %rsi      # 0xb69d
movq %rbx, %rdi
callq 0x31a0
movb 0x18(%r14), %al
cmpb $0x1, %al
jne 0x613a
leaq 0x5564(%rip), %rsi      # 0xb675
movq %rbx, %rdi
callq 0x31a0
movss 0x1c(%r14), %xmm0
movq %rax, %rdi
callq 0x3140
leaq 0x556f(%rip), %rsi      # 0xb69d
movq %rax, %rdi
callq 0x31a0
movb 0x18(%r14), %al
testb $0x1, %al
je 0x6154
cmpb $0x1, 0x24(%r14)
jne 0x6154
leaq 0x5537(%rip), %rsi      # 0xb683
movq %rbx, %rdi
callq 0x31a0
leaq 0x535a(%rip), %rsi      # 0xb4b5
movq %rbx, %rdi
callq 0x31a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpb $0x0, 0x8(%rdi)
je 0x62b2
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x5f56
movb $0x0, 0x18(%r14)
movb $0x1, 0x1a(%r14)
movq 0x28(%r15), %rax
movq %rax, 0xc(%r14)
movl 0x30(%r15), %eax
movl %eax, 0x14(%r14)
movl $0x3f800000, 0x20(%r14) # imm = 0x3F800000
movq (%rbx), %r14
testq %r14, %r14
je 0x62d1
leaq 0x54c0(%rip), %rsi      # 0xb6dc
movq %r14, %rdi
callq 0x31a0
movss 0x34(%r15), %xmm0
movq %rax, %rdi
callq 0x3140
leaq 0x54b0(%rip), %rsi      # 0xb6e9
movq %rax, %rdi
callq 0x31a0
movss 0x38(%r15), %xmm0
movq %rax, %rdi
callq 0x3140
leaq 0x549a(%rip), %rsi      # 0xb6f0
movq %rax, %rdi
callq 0x31a0
movss 0x3c(%r15), %xmm0
movq %rax, %rdi
callq 0x3140
leaq 0x5242(%rip), %rsi      # 0xb4b5
movq %rax, %rdi
callq 0x31a0
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x5fce
leaq 0x517d(%rip), %rsi      # 0xb40b
movq %r14, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq -0x38(%rbp), %rdi
callq 0x30c0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5954(%rip), %rdi      # 0xbc0d
leaq 0x5264(%rip), %rsi      # 0xb524
leaq 0x53d9(%rip), %rcx      # 0xb6a0
movl $0xf6, %edx
callq 0x3110
leaq 0x53f2(%rip), %rdi      # 0xb6ca
leaq 0x5245(%rip), %rsi      # 0xb524
leaq 0x53ba(%rip), %rcx      # 0xb6a0
movl $0x100, %edx            # imm = 0x100
callq 0x3110
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3250
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
movq 0x80(%rdi), %rax
cmpq %rax, 0x88(%rdi)
je 0x639b
movq %rax, 0x88(%rbx)
leaq 0x80(%rbx), %r15
movq 0x68(%rbx), %r12
movq 0x70(%rbx), %r13
movb $0x1, %r14b
cmpq %r13, %r12
je 0x641f
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x5e9e
movlps %xmm0, -0x38(%rbp)
testb $0x1, %r14b
je 0x63d1
movlhps %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movups %xmm0, 0xc(%rbx)
jmp 0x640a
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
movaps %xmm0, %xmm2
minss 0xc(%rbx), %xmm2
movss %xmm2, 0xc(%rbx)
movaps %xmm1, %xmm2
minss 0x10(%rbx), %xmm2
movss %xmm2, 0x10(%rbx)
movss 0x14(%rbx), %xmm2
maxss %xmm2, %xmm0
movss %xmm0, 0x14(%rbx)
maxss 0x18(%rbx), %xmm1
movss %xmm1, 0x18(%rbx)
movq %r15, %rdi
leaq -0x38(%rbp), %rsi
callq 0x9786
addq $0xc, %r12
xorl %r14d, %r14d
jmp 0x63ad
movb $0x1, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq