LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/JRLamontagne[P]cdice_sa/CDICEInit.cpp
// Function: allocateClim(DICE*)
void allocateClim(DICE *dice)
{
  
  if(dice->ctrl.use_doeclim==1) {
    // DOEclim model variables
    dice->clim.forc = new double[dice->config.ns];
    dice->clim.IB = new double[4];
    dice->clim.A = new double[4];
    dice->clim.Ker = new double[dice->config.ns];
    
    dice->clim.temp = new double[dice->config.ns];
    dice->clim.temp_landair = new double[dice->config.ns];
    dice->clim.temp_sst = new double[dice->config.ns];
    dice->clim.heat_mixed = new double[dice->config.ns];
    dice->clim.heat_interior = new double[dice->config.ns];
    dice->clim.heatflux_mixed = new double[dice->config.ns];
    dice->clim.heatflux_interior = new double[dice->config.ns];
    
    dice->clim.cs_cal = new double [dice->config.n_calpoints];
    dice->clim.kv_cal = new double [dice->config.n_calpoints];
    dice->clim.alpha_cal = new double [dice->config.n_calpoints];
    
		//doeclim_DICE_init(dice);

  }

  else {
    // DICE Climate model variables
    dice->clim.tatm = new double[dice->config.nPeriods];		// Increase temperature of atmosphere [dC from 1900]
    dice->clim.tocean = new double[dice->config.nPeriods];	// Increase temperature of lower oceans [dC from 1900]
    
  }

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, 0x58(%rdi)
jne 0x39ff
movslq 0x28(%rbx), %rax
leaq (,%rax,8), %r14
testq %rax, %rax
movq $-0x1, %r15
cmovsq %r15, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, 0xb0(%rbx)
movl $0x20, %edi
callq 0x2030
movq %rax, 0x100(%rbx)
movl $0x20, %edi
callq 0x2030
movq %rax, 0x108(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x120(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x140(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x148(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x150(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x158(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x160(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x168(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x170(%rbx)
movslq 0x30(%rbx), %rax
leaq (,%rax,8), %r14
testq %rax, %rax
cmovsq %r15, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, 0x178(%rbx)
movl $0x188, %r15d           # imm = 0x188
movl $0x180, %r12d           # imm = 0x180
jmp 0x3a24
movslq (%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %r14
cmovnsq %rcx, %r14
movl $0x130, %r15d           # imm = 0x130
movl $0x128, %r12d           # imm = 0x128
movq %r14, %rdi
callq 0x2030
movq %rax, (%rbx,%r12)
movq %r14, %rdi
callq 0x2030
movq %rax, (%rbx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/JRLamontagne[P]cdice_sa/CDICEInit.cpp
// Function: allocateLims(DICE*)
void allocateLims(DICE *dice)
{
  dice->lims.k_lo = 1.0;
  dice->lims.mat_lo = 10.0;
  dice->lims.mu_lo = 100.0;
  dice->lims.ml_lo = 1000.0;
  dice->lims.c_lo = 2.0;
  dice->lims.tocean_up = 20.0;
  dice->lims.tocean_lo = -1.0;
  dice->lims.tatm_lo = 0.0;
  dice->lims.tatm_up = 40.0;
  dice->lims.cpc_lo = 0.01;
  dice->lims.y_lo = 0.0;
  dice->lims.ygross_lo = 0.0;
  dice->lims.i_lo = 0.0;
  dice->lims.miu_up = new double[dice->config.nPeriods];	// Upper limit of control policy for each time period

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movaps 0x436d(%rip), %xmm0     # 0x8080
movups %xmm0, 0x4b0(%rdi)
movaps 0x436f(%rip), %xmm0     # 0x8090
movups %xmm0, 0x4c0(%rdi)
movaps 0x4371(%rip), %xmm0     # 0x80a0
movups %xmm0, 0x4d0(%rdi)
movsd 0x4392(%rip), %xmm0     # 0x80d0
movups %xmm0, 0x4e0(%rdi)
movaps 0x4364(%rip), %xmm0     # 0x80b0
movups %xmm0, 0x4f0(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x500(%rdi)
movq $0x0, 0x510(%rdi)
movslq (%rdi), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, 0x528(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/JRLamontagne[P]cdice_sa/CDICEInit.cpp
// Function: allocateDICE(DICE*)
void allocateDICE(DICE *dice)
{
	allocateCtrl(dice);
	allocateConfig(dice);
	allocateCarb(dice);
	allocateEcon(dice);
	allocateDvars(dice);
	allocateLims(dice);
	allocateClim(dice);
	
	if(dice->ctrl.use_doeclim == 1) {	
  	doeclim_load_calibration(dice, dice->config.n_calpoints);
  }

	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, 0x58(%rdi)
callq 0x3808
movq %rbx, %rdi
callq 0x3857
movq %rbx, %rdi
callq 0x3a48
movslq (%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %r14
cmovnsq %rcx, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, 0x48(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, 0x50(%rbx)
movq %rbx, %rdi
callq 0x3d08
movq %rbx, %rdi
callq 0x38f7
cmpl $0x1, 0x58(%rbx)
jne 0x4537
movl 0x30(%rbx), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7976
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/JRLamontagne[P]cdice_sa/CDICE.cpp
// Function: calcCarb1(DICE*)
void calcCarb1(DICE *dice)
{

  Carb *carb = &dice->carb;
  Lims *lims = &dice->lims;
  
  // Carbon pools
  carb->mat[0] = carb->mat0;
  if(carb->mat[0] < lims->mat_lo) {
    carb->mat[0] = lims->mat_lo;
  }
  
  carb->mu[0] = carb->mu0;
  if(carb->mu[0] < lims->mu_lo) {
    carb->mu[0] = lims->mu_lo;
  }

  carb->ml[0] = carb->ml0;
  if(carb->ml[0] < lims->ml_lo) {
    carb->ml[0] = lims->ml_lo;
  }

  // Radiative forcing
  carb->forc[0] = carb->fco22x*(log(carb->mat[0]/588.000)/log(2.0))+carb->forcoth[0];
  
  return;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x3e0(%rdi), %xmm1
movq 0x478(%rdi), %rax
movsd %xmm1, (%rax)
movsd 0x4b8(%rdi), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4f04
movsd %xmm0, (%rax)
movsd 0x3e8(%rbx), %xmm1
movq 0x480(%rbx), %rcx
movsd %xmm1, (%rcx)
movsd 0x4c0(%rbx), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4f29
movsd %xmm0, (%rcx)
movsd 0x3f0(%rbx), %xmm1
movq 0x488(%rbx), %rcx
movsd %xmm1, (%rcx)
movsd 0x4c8(%rbx), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4f4e
movsd %xmm0, (%rcx)
movsd 0x448(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rax), %xmm0
divsd 0x3190(%rip), %xmm0     # 0x80f8
callq 0x2170
divsd 0x318b(%rip), %xmm0     # 0x8100
mulsd 0x8(%rsp), %xmm0
movq 0x468(%rbx), %rax
movq 0x470(%rbx), %rcx
addsd (%rax), %xmm0
movsd %xmm0, (%rcx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/JRLamontagne[P]cdice_sa/CDICE.cpp
// Function: calcClim1(DICE*)
void calcClim1(DICE *dice)
{
  Clim *clim = &dice->clim;
  Lims *lims = &dice->lims;

  // Atmospheric temperature
  clim->tatm[0] = clim->tatm0;
  if(clim->tatm[0] < lims->tatm_lo) {
    clim->tatm[0] = lims->tatm_lo;
  }
  if(clim->tatm[0] > lims->tatm_up) {
    clim->tatm[0] = lims->tatm_up;
  }
  
  // Oceanic temperature
  clim->tocean[0] = clim->tocean0;
  if(clim->tocean[0] < lims->tocean_lo) {
    clim->tocean[0] = lims->tocean_lo;
  }
  if(clim->tocean[0] > lims->tocean_up) {
    clim->tocean[0] = lims->tocean_up;
  }
  
  return;
}

// Assembly:
movsd 0x70(%rdi), %xmm1
movq 0x128(%rdi), %rax
movsd %xmm1, (%rax)
movsd 0x4e8(%rdi), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4fb9
movsd %xmm0, (%rax)
movsd (%rax), %xmm1
movsd 0x4f0(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x4fcf
movsd %xmm0, (%rax)
movsd 0x68(%rdi), %xmm1
movq 0x130(%rdi), %rax
movsd %xmm1, (%rax)
movsd 0x4e0(%rdi), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4ff1
movsd %xmm0, (%rax)
movsd (%rax), %xmm1
movsd 0x4d8(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x5007
movsd %xmm0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/JRLamontagne[P]cdice_sa/CDICE.cpp
// Function: calcCarb(DICE*, int)
void calcCarb(DICE *dice, int t)
{

  Econ *econ = &dice->econ;
  Carb *carb = &dice->carb;
  Lims *lims = &dice->lims;
  
  // Carbon pools (carbon cycle box model)
  carb->mat[t] = (econ->e[t-1]*(5.0/3.666))+carb->b11*carb->mat[t-1]+carb->b21*carb->mu[t-1];
  if(carb->mat[t] < lims->mat_lo) {
    carb->mat[t] = lims->mat_lo;
  }

  carb->mu[t] = carb->b12*carb->mat[t-1]+carb->b22*carb->mu[t-1]+carb->b32*carb->ml[t-1];
  if(carb->mu[t] < lims->mu_lo) {
    carb->mu[t] = lims->mu_lo;
  }
  carb->ml[t] = carb->b33*carb->ml[t-1]+carb->b23*carb->mu[t-1];
  if(carb->ml[t] < lims->ml_lo) {
    carb->ml[t] = lims->ml_lo;
  }
  
  // Radiatice forcing
  carb->forc[t] = carb->fco22x*(log(carb->mat[t]/588.000)/log(2.0))+carb->forcoth[t];
  
  return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3b8(%rdi), %rax
movslq %esi, %r14
leaq -0x1(%r14), %rcx
movsd -0x8(%rax,%r14,8), %xmm1
movq 0x478(%rdi), %rax
movsd -0x8(%rax,%r14,8), %xmm0
movsd 0x420(%rdi), %xmm2
mulsd %xmm0, %xmm2
mulsd 0x2d3c(%rip), %xmm1     # 0x80e8
addsd %xmm2, %xmm1
movsd 0x428(%rdi), %xmm2
movq 0x480(%rdi), %rdx
mulsd -0x8(%rdx,%r14,8), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%rax,%r14,8)
movsd 0x4b8(%rdi), %xmm1
ucomisd %xmm2, %xmm1
jbe 0x53e4
movsd %xmm1, (%rax,%r14,8)
movsd (%rdx,%rcx,8), %xmm1
movsd 0x430(%rbx), %xmm2
mulsd %xmm1, %xmm2
mulsd 0x410(%rbx), %xmm0
addsd %xmm2, %xmm0
movsd 0x438(%rbx), %xmm2
movq 0x488(%rbx), %rsi
mulsd (%rsi,%rcx,8), %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, (%rdx,%r14,8)
movsd 0x4c0(%rbx), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x5433
movsd %xmm0, (%rdx,%r14,8)
mulsd 0x418(%rbx), %xmm1
movsd 0x440(%rbx), %xmm2
mulsd (%rsi,%rcx,8), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%rsi,%r14,8)
movsd 0x4c8(%rbx), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x5466
movsd %xmm0, (%rsi,%r14,8)
movsd 0x448(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd (%rax,%r14,8), %xmm0
divsd 0x2c77(%rip), %xmm0     # 0x80f8
callq 0x2170
divsd 0x2c72(%rip), %xmm0     # 0x8100
mulsd (%rsp), %xmm0
movq 0x468(%rbx), %rax
movq 0x470(%rbx), %rcx
addsd (%rax,%r14,8), %xmm0
movsd %xmm0, (%rcx,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/JRLamontagne[P]cdice_sa/CDICE.cpp
// Function: calcClim(DICE*, int)
void calcClim(DICE *dice, int t)
{

  Config *config = &dice->config;
  Econ *econ = &dice->econ;
  Carb *carb = &dice->carb;
  Clim *clim = &dice->clim;
  Dvars *dvars = &dice->dvars;
  Ctrl *ctrl = &dice->ctrl;
  Lims *lims = &dice->lims;

  clim->tatm[t] = clim->tatm[t-1]+clim->c1*((carb->forc[t]-((carb->fco22x/clim->t2xco2)*clim->tatm[t-1]))-(clim->c3*(clim->tatm[t-1]-clim->tocean[t-1])));
  if(clim->tatm[t] < lims->tatm_lo) {
    clim->tatm[t] = lims->tatm_lo;
  }
  if(clim->tatm[t] > lims->tatm_up) {
    clim->tatm[t] = lims->tatm_up;
  }

  clim->tocean[t] = clim->tocean[t-1]+clim->c4*(clim->tatm[t-1]-clim->tocean[t-1]);
  if(clim->tocean[t] < lims->tocean_lo) {
    clim->tocean[t] = lims->tocean_lo;
  }
  if(clim->tocean[t] > lims->tocean_up) {
    clim->tocean[t] = lims->tocean_up;
  }

  return;
}

// Assembly:
movq 0x128(%rdi), %rdx
movq 0x130(%rdi), %rax
movslq %esi, %rcx
movsd -0x8(%rdx,%rcx,8), %xmm0
movq 0x470(%rdi), %rsi
movsd 0x448(%rdi), %xmm1
divsd 0x60(%rdi), %xmm1
movsd (%rsi,%rcx,8), %xmm2
mulsd %xmm0, %xmm1
subsd %xmm1, %xmm2
movapd %xmm0, %xmm1
subsd -0x8(%rax,%rcx,8), %xmm1
mulsd 0x80(%rdi), %xmm1
subsd %xmm1, %xmm2
mulsd 0x78(%rdi), %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, (%rdx,%rcx,8)
movsd 0x4e8(%rdi), %xmm1
ucomisd %xmm2, %xmm1
jbe 0x5524
movsd %xmm1, (%rdx,%rcx,8)
leaq -0x1(%rcx), %rsi
movsd (%rdx,%rcx,8), %xmm2
movsd 0x4f0(%rdi), %xmm1
ucomisd %xmm1, %xmm2
jbe 0x5540
movsd %xmm1, (%rdx,%rcx,8)
movsd (%rax,%rsi,8), %xmm1
subsd %xmm1, %xmm0
mulsd 0x88(%rdi), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd 0x4e0(%rdi), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x556d
movsd %xmm1, (%rax,%rcx,8)
movsd (%rax,%rcx,8), %xmm1
movsd 0x4d8(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x5585
movsd %xmm0, (%rax,%rcx,8)
retq
// File: /workspace/github_cpp_makefile_star2_O1/JRLamontagne[P]cdice_sa/CDICE.cpp
// Function: processModel(DICE*)
void processModel(DICE *dice)
{
	
  // Calculate exogenous time series
  calcExog(dice);
  
   // Calculate the first time step of carbon model
  calcCarb1(dice);

  // Calculate the first time step of climate model
  if(dice->ctrl.use_doeclim == 1) {
    doeclim_hindcast(dice);
  }
  else {
    calcClim1(dice);
  }
  
  // Calculate the first time step of economic model
  calcEcon1(dice);
  
  // Calculate the rest of the time series
  for (int tIndex=1; tIndex<dice->config.nPeriods; tIndex++)
    {
      calcCarb(dice, tIndex);

      if(dice->ctrl.use_doeclim == 1) {
				doeclim_dice_ts(dice, tIndex);
    	}
      else {
				calcClim(dice, tIndex);
      }

      calcEcon(dice, tIndex);
    }
  
  // Do the post-processing
  postProcess(dice);
  
  return;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4ad0
movq %rbx, %rdi
callq 0x4ed7
cmpl $0x1, 0x58(%rbx)
jne 0x5d2b
movq %rbx, %rdi
callq 0x751b
jmp 0x5d33
movq %rbx, %rdi
callq 0x4f97
movq %rbx, %rdi
callq 0x5008
cmpl $0x2, (%rbx)
jl 0x5d7b
movl $0x1, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x536e
cmpl $0x1, 0x58(%rbx)
jne 0x5d61
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7643
jmp 0x5d6b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x54b5
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5586
incl %ebp
cmpl (%rbx), %ebp
jl 0x5d45
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5a2f
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: count_lines(char const*, int*)
void count_lines(const char *filename, int *numlines)
{
	int ch;	
	*numlines = 0;
	FILE * fp = fopen(filename, "r");
	
	do {
		ch = fgetc(fp);
		if(ch == '\n') { *numlines = *numlines + 1; }
	} while (ch != EOF);

//	if(ch != '\n' && *numlines != 0) 
//    *numlines = *numlines + 1;

	fclose(fp);
	
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl $0x0, (%rsi)
leaq 0x24f0(%rip), %rsi      # 0x8290
callq 0x2220
movq %rax, %r14
movq %r14, %rdi
callq 0x22c0
cmpl $0xa, %eax
je 0x5dbc
cmpl $-0x1, %eax
jne 0x5da8
jmp 0x5dc0
incl (%rbx)
jmp 0x5da8
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: invert_1d_2x2_matrix(double*, double*)
void invert_1d_2x2_matrix(double * x, double * y)
{
  double temp_d = (x[0]*x[3] - x[1]*x[2]);
  if(temp_d == 0) {
    fprintf(stderr, "Matrix inversion divide by zero. Aborting...\n");
    exit(EXIT_FAILURE);
  }
  double temp = 1/temp_d;
  y[0] = temp * x[3];
  y[1] = temp * -1 * x[1];
  y[2] = temp * -1 * x[2];
  y[3] = temp * x[0];

  return;
}

// Assembly:
movsd 0x10(%rdi), %xmm2
movsd 0x18(%rdi), %xmm0
mulsd 0x8(%rdi), %xmm2
movsd (%rdi), %xmm1
mulsd %xmm0, %xmm1
subsd %xmm2, %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x5df6
jnp 0x5e38
movsd 0x220a(%rip), %xmm2     # 0x8008
divsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
movsd %xmm0, (%rsi)
movapd 0x232e(%rip), %xmm0     # 0x8140
xorpd %xmm2, %xmm0
movsd 0x8(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsi)
mulsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rsi)
mulsd (%rdi), %xmm2
movsd %xmm2, 0x18(%rsi)
retq
pushq %rax
callq 0x23fb
// File: /workspace/github_cpp_makefile_star2_O1/JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: doeclim_DICE_init(DICE*)
void doeclim_DICE_init(DICE *dice)
{
  Clim *clim = &dice->clim;
  Config *config = &dice->config;
/*
  for(int i=0; i<clim->ns; i++) {
    clim->Ker[i] = 0.0;
    clim->temp[i] = 0.0;
    clim->temp_landair[i] = 0.0;
    clim->temp_sst[i] = 0.0;
    clim->heat_mixed[i] = 0.0;
    clim->heat_interior[i] = 0.0;
    clim->heatflux_mixed[i] = 0.0;
    clim->heatflux_interior[i] = 0.0;
    clim->forc[i] = 0.0;
  }
  for(int i=0; i<4; i++) {
		clim->IB[i] = 0.0;
    clim->A[i] = 0.0;
  }
*/
  // Initialize the doeclim model
  doeclim_init(clim->t2co, clim->kappa, config->dt, config->ns,
		 &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);
  
  // Run the hindcast
  //doeclim_hindcast(dice);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movsd 0x98(%rdi), %xmm0
movsd 0xa0(%rdi), %xmm1
movl 0x24(%rdi), %eax
movl 0x28(%rdi), %esi
leaq 0xb8(%rdi), %rdx
leaq 0xc0(%rdi), %rcx
leaq 0xc8(%rdi), %r8
leaq 0xd0(%rdi), %r9
leaq 0xd8(%rdi), %r10
leaq 0xe0(%rdi), %r11
leaq 0xe8(%rdi), %rbx
leaq 0xf0(%rdi), %r14
leaq 0xf8(%rdi), %r15
movups 0x100(%rdi), %xmm2
leaq 0x110(%rdi), %r12
movq 0x120(%rdi), %r13
addq $0x118, %rdi            # imm = 0x118
movq %r13, 0x48(%rsp)
movq %rdi, 0x40(%rsp)
movq %r12, 0x38(%rsp)
movups %xmm2, 0x28(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, 0x18(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x8(%rsp)
movq %r10, (%rsp)
movl %eax, %edi
callq 0x6259
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x20(%rdi)
jle 0x7642
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
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 0x5e59
incl %ebp
cmpl 0x20(%rbx), %ebp
jl 0x7538
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa67(%rip), %rdi       # 0x82c0
leaq 0xa30(%rip), %rsi       # 0x8290
callq 0x2220
movq %rax, %r14
leaq 0x30(%rsp), %r13
leaq 0x2c(%rsp), %rbp
leaq 0x28(%rsp), %r15
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x22b0
testl %eax, %eax
jne 0x795f
subq $0x8, %rsp
movq %r14, %rdi
leaq 0xa53(%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 0x2380
addq $0x40, %rsp
cmpl $0xb, %eax
jne 0x795f
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
xorps %xmm0, %xmm0
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 0x787a
movq %r14, %rdi
callq 0x21c0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x980(%rip), %rdi       # 0x8310
leaq 0x8f9(%rip), %rsi       # 0x8290
callq 0x2220
movq %rax, %r14
cmpl $0x2, %ebp
movl $0x1, %r15d
cmovgel %ebp, %r15d
leaq 0x10(%rsp), %r13
leaq 0xc(%rsp), %rbp
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x22b0
testl %eax, %eax
jne 0x7a30
movq %r14, %rdi
leaq 0x934(%rip), %rsi       # 0x8303
leaq 0x14(%rsp), %rdx
movq %r13, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x2380
cmpl $0x3, %eax
jne 0x7a30
xorps %xmm0, %xmm0
cvtss2sd 0x14(%rsp), %xmm0
movq 0x178(%rbx), %rax
movsd %xmm0, (%rax,%r12,8)
xorps %xmm0, %xmm0
cvtss2sd 0x10(%rsp), %xmm0
movq 0x180(%rbx), %rax
movsd %xmm0, (%rax,%r12,8)
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
movq 0x188(%rbx), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x79b9
movq %r14, %rdi
callq 0x21c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x30(%rdi), %rax
testq %rax, %rax
jle 0x7aaf
movq 0x178(%rdi), %r8
xorl %ecx, %ecx
movsd 0x7bf(%rip), %xmm2      # 0x8220
movsd 0x7bf(%rip), %xmm3      # 0x8228
xorpd %xmm1, %xmm1
xorl %edx, %edx
xorl %esi, %esi
movsd (%r8,%rcx,8), %xmm4
subsd %xmm0, %xmm4
ucomisd %xmm1, %xmm4
jne 0x7a83
jnp 0x7ab5
jb 0x7a93
ucomisd %xmm4, %xmm2
jbe 0x7a93
movl %ecx, %esi
movapd %xmm4, %xmm2
jmp 0x7aa5
ucomisd %xmm4, %xmm1
jb 0x7aa5
ucomisd %xmm3, %xmm4
jbe 0x7aa5
movl %ecx, %edx
movapd %xmm4, %xmm3
incq %rcx
cmpq %rcx, %rax
jne 0x7a71
jmp 0x7ab9
xorl %esi, %esi
xorl %edx, %edx
jmp 0x7ab9
movl %ecx, %esi
movl %ecx, %edx
cmpl %esi, %edx
jne 0x7ae2
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
jmp 0x7b47
movslq %esi, %rax
movq 0x178(%rdi), %rcx
movq 0x180(%rdi), %rsi
movsd (%rcx,%rax,8), %xmm1
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm2
subsd %xmm2, %xmm1
subsd %xmm2, %xmm0
divsd %xmm1, %xmm0
movsd (%rsi,%rax,8), %xmm1
movsd (%rsi,%rdx,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,%rdx,8), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0xa8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %al
testb %al, %al
je 0x4b00
movb (%rsi), %cl
cmpb $0x2a, %cl
je 0x4b00
cmpb %al, %cl
setne %al
cmpb $0x3f, %cl
setne %cl
testb %cl, %al
jne 0x4b5e
incq %rsi
movb 0x1(%rdi), %al
incq %rdi
jmp 0x4adb
movb (%rdi), %dl
testb %dl, %dl
je 0x4b4f
xorl %eax, %eax
xorl %ecx, %ecx
movb (%rsi), %r8b
cmpb $0x2a, %r8b
jne 0x4b25
cmpb $0x0, 0x1(%rsi)
je 0x4b61
incq %rsi
leaq 0x1(%rdi), %rcx
movq %rsi, %rax
jmp 0x4b49
cmpb %dl, %r8b
setne %dl
cmpb $0x3f, %r8b
setne %r8b
testb %r8b, %dl
jne 0x4b40
incq %rsi
incq %rdi
jmp 0x4b49
movq %rcx, %rdi
incq %rcx
movq %rax, %rsi
movb (%rdi), %dl
testb %dl, %dl
jne 0x4b0a
movb (%rsi), %al
incq %rsi
cmpb $0x2a, %al
je 0x4b4f
testb %al, %al
sete %al
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x7684(%rip), %rsi      # 0xc1f9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xb1bd
movq (%r14), %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3060
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4ba9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3250
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40(%rdi), %r15
movq 0x48(%rdi), %rax
subq %r15, %rax
setne %bl
je 0x85d9
sarq $0x5, %rax
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r12
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %r13
xorl %ebp, %ebp
cmpq $0x1, %r12
sbbq %r12, %rbp
addq $0x8, %r15
movl $0x1, %r14d
movq (%r15), %rdx
cmpq %r13, %rdx
jne 0x85bf
testq %rdx, %rdx
je 0x85d9
movq -0x8(%r15), %rdi
movq (%rsp), %rsi
callq 0x3270
testl %eax, %eax
je 0x85d9
cmpq %r12, %r14
setb %bl
leaq (%r14,%rbp), %rax
incq %rax
incq %r14
addq $0x60, %r15
cmpq $0x1, %rax
jne 0x85a1
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x32c0
leaq 0x42d7(%rip), %rcx      # 0xc8e8
leaq 0x42d7(%rip), %rsi      # 0xc8ef
cmpb $0x0, 0x87c(%r14)
cmovneq %rcx, %rsi
movl $0x6, %edx
movq %rax, %rdi
callq 0x32c0
xorl %r12d, %r12d
leaq 0x3aae(%rip), %r15      # 0xc0e9
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x32c0
movl 0x864(%r14,%r12,4), %esi
movq %rbx, %rdi
callq 0x3400
incq %r12
cmpq $0x6, %r12
jne 0x863b
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq 0x40(%r14), %rax
cmpq %rax, 0x48(%r14)
je 0x86ef
movl $0x8, %r12d
xorl %r13d, %r13d
leaq 0x3a44(%rip), %r15      # 0xc0e9
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x32c0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x32c0
incq %r13
movq 0x40(%r14), %rax
movq 0x48(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
imulq %rbp, %rcx
addq $0x60, %r12
cmpq %rcx, %r13
jb 0x86af
cmpq $0x0, 0x888(%r14)
je 0x8723
leaq 0x41f6(%rip), %rsi      # 0xc8f6
movl $0x6, %edx
movq %rbx, %rdi
callq 0x32c0
movq 0x880(%r14), %rsi
movq 0x888(%r14), %rdx
movq %rbx, %rdi
callq 0x32c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
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_O1/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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70b4(%rip), %rsi      # 0xd2b0
movl $0x14, %edx
callq 0x31e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x31e0
movq %rax, %rbx
leaq 0x70a6(%rip), %rsi      # 0xd2c5
movl $0x2e, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x7097(%rip), %rsi      # 0xd2f4
movl $0x52, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x70ac(%rip), %rsi      # 0xd347
movl $0x52, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x70c1(%rip), %rsi      # 0xd39a
movl $0x11, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3130
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6f8b(%rip), %rsi      # 0xd2b0
movl $0x14, %edx
callq 0x31e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x31e0
movq %rax, %rbx
leaq 0x7064(%rip), %rsi      # 0xd3ac
movl $0x2e, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x6f6e(%rip), %rsi      # 0xd2f4
movl $0x52, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x7017(%rip), %rsi      # 0xd3db
movl $0x50, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x6f98(%rip), %rsi      # 0xd39a
movl $0x11, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3130
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6fe9(%rip), %rsi      # 0xd43a
movl $0x4, %edx
callq 0x31e0
cvtss2sd (%rbx), %xmm0
mulsd 0x6d69(%rip), %xmm0     # 0xd1d0
movq %r14, %rdi
callq 0x3250
movq %rax, %r14
leaq 0x6fb3(%rip), %r15      # 0xd42c
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rbx), %xmm0
mulsd 0x6d37(%rip), %xmm0     # 0xd1d0
movq %r14, %rdi
callq 0x3250
movq %rax, %r14
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%rbx), %xmm0
mulsd 0x6d0c(%rip), %xmm0     # 0xd1d0
movq %r14, %rdi
callq 0x3250
leaq 0x6f5c(%rip), %rsi      # 0xd42f
movl $0x2, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6f31(%rip), %rsi      # 0xd432
movl $0xc, %edx
callq 0x31e0
cvtss2sd (%rbx), %xmm0
mulsd 0x6cb9(%rip), %xmm0     # 0xd1d0
movq %r14, %rdi
callq 0x3250
movq %rax, %r14
leaq 0x6f03(%rip), %r15      # 0xd42c
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rbx), %xmm0
mulsd 0x6c87(%rip), %xmm0     # 0xd1d0
movq %r14, %rdi
callq 0x3250
movq %rax, %r14
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%rbx), %xmm0
mulsd 0x6c5c(%rip), %xmm0     # 0xd1d0
movq %r14, %rdi
callq 0x3250
movq %rax, %rbx
leaq 0x6eb9(%rip), %rsi      # 0xd43f
movl $0x4, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3130
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rsi, %rbx
movss (%rsi), %xmm0
ucomiss %xmm0, %xmm0
jnp 0x6627
movss 0x4(%rbx), %xmm1
ucomiss %xmm1, %xmm1
jnp 0x6627
movq 0xb9e8(%rip), %rbx      # 0x11fd0
leaq 0x6e55(%rip), %rsi      # 0xd444
movl $0x44, %edx
movq %rbx, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3130
cvtss2sd %xmm0, %xmm0
callq 0x3250
movq %rax, %r14
leaq 0x6e08(%rip), %rsi      # 0xd442
movl $0x1, %edx
movq %rax, %rdi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rbx), %xmm0
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x28(%rdi), %rbx
leaq 0x38(%rdi), %r15
movq %r15, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
movw $0x101, 0x18(%rdi)      # imm = 0x101
movb $0x1, 0x1a(%rdi)
movaps 0x65a5(%rip), %xmm0     # 0xd220
movups %xmm0, (%rdi)
movabsq $0x3f0000003f000000, %rax # imm = 0x3F0000003F000000
movq %rax, 0x10(%rdi)
movabsq $0x3f0000003d4ccccd, %rax # imm = 0x3F0000003D4CCCCD
movq %rax, 0x1c(%rdi)
movw $0x0, 0x24(%rdi)
leaq 0x68f4(%rip), %rcx      # 0xd59b
movl $0x7, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3240
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6cd4
callq 0x31a0
movq %r14, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x50, %rsp
cmpb $0x0, 0x8(%rdi)
je 0x70a9
movq %rsi, %r14
movq %rdi, %r15
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0x6c48
movb $0x0, 0x18(%rbx)
movb $0x1, 0x1a(%rbx)
movq 0x28(%r15), %rax
movq %rax, 0xc(%rbx)
movl 0x30(%r15), %eax
movl %eax, 0x14(%rbx)
movl $0x3f800000, 0x20(%rbx) # imm = 0x3F800000
movq (%r14), %rbx
testq %rbx, %rbx
je 0x70c8
leaq 0x66a4(%rip), %rsi      # 0xd668
movl $0xc, %edx
movq %rbx, %rdi
callq 0x31e0
cvtss2sd 0x34(%r15), %xmm0
movq %rbx, %rdi
callq 0x3250
movq %rax, %r12
leaq 0x668c(%rip), %rsi      # 0xd675
movl $0x6, %edx
movq %rax, %rdi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x38(%r15), %xmm0
movq %r12, %rdi
callq 0x3250
movq %rax, %r12
leaq 0x666b(%rip), %rsi      # 0xd67c
movl $0x5, %edx
movq %rax, %rdi
callq 0x31e0
xorps %xmm0, %xmm0
cvtss2sd 0x3c(%r15), %xmm0
movq %r12, %rdi
callq 0x3250
leaq 0x640b(%rip), %rsi      # 0xd441
movl $0x2, %edx
movq %rax, %rdi
callq 0x31e0
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0x6cdc
leaq 0x6341(%rip), %rsi      # 0xd397
movl $0x2, %edx
movq %rbx, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x709c
callq 0x31a0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6ae9(%rip), %rdi      # 0xdb99
leaq 0x63f9(%rip), %rsi      # 0xd4b0
leaq 0x656e(%rip), %rcx      # 0xd62c
movl $0xf6, %edx
callq 0x3120
leaq 0x6587(%rip), %rdi      # 0xd656
leaq 0x63da(%rip), %rsi      # 0xd4b0
leaq 0x654f(%rip), %rcx      # 0xd62c
movl $0x100, %edx            # imm = 0x100
callq 0x3120
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x70fc
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x1c(%rdi), %rsi
movq %rax, %rdi
callq 0x6b62
movlps %xmm0, 0x34(%rbx)
movlhps %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movups %xmm0, 0xc(%rbx)
movb $0x1, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movq 0x80(%rdi), %rax
cmpq %rax, 0x88(%rdi)
je 0x719a
movq %rax, 0x88(%rbx)
movq 0x68(%rbx), %r15
movq 0x70(%rbx), %r13
cmpq %r13, %r15
je 0x727e
leaq 0x80(%rbx), %rax
movq %rax, -0x38(%rbp)
movb $0x1, %r12b
movq %r14, %rdi
movq %r15, %rsi
callq 0x6b62
movlps %xmm0, -0x30(%rbp)
testb $0x1, %r12b
je 0x71df
movq -0x30(%rbp), %rax
movq %rax, 0xc(%rbx)
movq %rax, 0x14(%rbx)
xorl %r12d, %r12d
jmp 0x7243
movss -0x30(%rbp), %xmm0
movaps %xmm0, %xmm1
minss 0xc(%rbx), %xmm1
movss %xmm1, 0xc(%rbx)
movss -0x2c(%rbp), %xmm1
movaps %xmm1, %xmm2
minss 0x10(%rbx), %xmm2
movss %xmm2, 0x10(%rbx)
movss 0x14(%rbx), %xmm2
movss 0x18(%rbx), %xmm3
movaps %xmm2, %xmm4
cmpltss %xmm0, %xmm4
movss -0x30(%rbp), %xmm0
andps %xmm4, %xmm0
andnps %xmm2, %xmm4
orps %xmm4, %xmm0
movss %xmm0, 0x14(%rbx)
movaps %xmm3, %xmm0
cmpltss %xmm1, %xmm0
movss -0x2c(%rbp), %xmm1
andps %xmm0, %xmm1
andnps %xmm3, %xmm0
orps %xmm0, %xmm1
movss %xmm1, 0x18(%rbx)
movq 0x88(%rbx), %rsi
cmpq 0x90(%rbx), %rsi
je 0x7264
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x88(%rbx)
jmp 0x7271
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0xc1e4
addq $0xc, %r15
cmpq %r13, %r15
jne 0x71b9
movb $0x1, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/carlos-urena[P]svg-gen/svgobjects.cpp
// Function: ObjectsSet::project(Camera const&)
void ObjectsSet::project( const Camera & cam )
{
   bool primero = true ;

   for( Object * pobjeto : objetos )
   {
      assert( pobjeto != nullptr );
      pobjeto->project( cam );

      if ( primero )
      {
         min = pobjeto->min ;
         max = pobjeto->max ;
         primero = false ;
   }
   else
   {
      min[0] = std::min( min[0], pobjeto->min[0] );
      min[1] = std::min( min[1], pobjeto->min[1] );
      max[0] = std::max( max[0], pobjeto->max[0] );
      max[1] = std::max( max[1], pobjeto->max[1] );
   }
   //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
pushq %rax
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
movq 0x20(%rdi), %r12
movq 0x28(%rdi), %r13
cmpq %r13, %r12
je 0x764b
movb $0x1, %r14b
movq (%r12), %r15
testq %r15, %r15
je 0x765e
movq (%r15), %rax
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq *0x8(%rax)
testb $0x1, %r14b
je 0x7602
movq 0xc(%r15), %rax
movq %rax, 0xc(%rbx)
movq 0x14(%r15), %rax
movq %rax, 0x14(%rbx)
xorl %r14d, %r14d
jmp 0x7642
movss 0xc(%r15), %xmm0
minss 0xc(%rbx), %xmm0
movss %xmm0, 0xc(%rbx)
movss 0x10(%r15), %xmm0
minss 0x10(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
movss 0x14(%r15), %xmm0
maxss 0x14(%rbx), %xmm0
movss %xmm0, 0x14(%rbx)
movss 0x18(%r15), %xmm0
maxss 0x18(%rbx), %xmm0
movss %xmm0, 0x18(%rbx)
addq $0x8, %r12
cmpq %r13, %r12
jne 0x75cd
movb $0x1, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x60ee(%rip), %rdi      # 0xd753
leaq 0x5e44(%rip), %rsi      # 0xd4b0
leaq 0x60f3(%rip), %rcx      # 0xd766
movl $0x182, %edx            # imm = 0x182
callq 0x3120
nop