// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/input.c
// Function: input_read_from_file
int input_read_from_file(struct file_content * pfc,
                         struct precision * ppr,
                         struct background *pba,
                         struct thermodynamics *pth,
                         struct perturbations *ppt,
                         struct transfer *ptr,
                         struct primordial *ppm,
                         struct harmonic *phr,
                         struct fourier * pfo,
                         struct lensing *ple,
                         struct distortions *psd,
                         struct output *pop,
                         ErrorMsg errmsg) {


  /** Summary: */

  /** - Define local variables */
  int input_verbose = 0;
  int has_shooting;

  /** Set default values
      Before getting into the assignment of parameters and the shooting, we want
      to already fix our precision parameters. No precision parameter should
      depend on any input parameter  */
  class_call(input_read_precisions(pfc,ppr,pba,pth,ppt,ptr,ppm,phr,pfo,ple,psd,pop,
                                   errmsg),
             errmsg,
             errmsg);

  class_read_int("input_verbose",input_verbose);
  if (input_verbose >0) printf("Reading input parameters\n");

  /** -- Special setting of parameter, before anything else: did shooting fail? */
  pba->shooting_failed = _FALSE_;

  /** Find out if shooting necessary and, eventually, shoot and initialize
      read parameters */
  class_call(input_shooting(pfc,ppr,pba,pth,ppt,ptr,ppm,phr,pfo,ple,psd,pop,
                            input_verbose,
                            &has_shooting,
                            errmsg),
             errmsg,
             errmsg);

  /** Update structs with input that is potentially updated after shooting */
  class_call(input_read_parameters(pfc,ppr,pba,pth,ppt,ptr,ppm,phr,pfo,ple,psd,pop,
                                    errmsg),
              errmsg,
              errmsg);

  if (has_shooting == _TRUE_ && pba->shooting_failed == _TRUE_) {
    // Shooting failed, but error must be thrown in background in order to trigger a
    // runtime error, so here we skip the rest and go straight to background
    return _SUCCESS_;
  }

  /** Write info on the read/unread parameters. This is the correct place to do it,
      since we want it to happen after all the shooting business,
      and after the final reading of all parameters */
  class_call(input_write_info(pfc,pop,
                              errmsg),
             errmsg,
             errmsg);

  if (pfo->has_pk_eq == _TRUE_) {

    if (input_verbose > 0) {
      printf(" -> since you want to use Halofit with a non-zero wa_fld and the Pk_equal method,\n");
      printf("    calling background module to extract the effective w(tau), Omega_m(tau) parameters");
      printf("    required by this method\n");
    }
    class_call(input_prepare_pk_eq(ppr,pba,pth,pfo,input_verbose,errmsg),
               errmsg,
               errmsg);
  }

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %r9, %rbp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %r13
movq 0x890(%rsp), %r15
subq $0x40, %rsp
movq %r15, 0x30(%rsp)
callq 0x323ea
addq $0x40, %rsp
cmpl $0x1, %eax
jne 0x31992
leaq 0xbca92(%rip), %rsi     # 0xee3f0
leaq 0xc18f3(%rip), %rdx     # 0xf3258
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xbc6b6(%rip), %rsi     # 0xee034
leaq 0xc1922(%rip), %rdx     # 0xf32a7
movq %r15, %rdi
movl $0x19b, %ecx            # imm = 0x19B
jmp 0x31ba4
movq %rbx, 0x18(%rsp)
leaq 0xc191e(%rip), %rsi     # 0xf32bc
leaq 0x4(%rsp), %rbx
leaq 0x14(%rsp), %rcx
movq %r13, %rdi
movq %rbx, %rdx
movq %r15, %r8
callq 0x1e736
cmpl $0x1, %eax
jne 0x319f6
leaq 0xbca2e(%rip), %rsi     # 0xee3f0
leaq 0xc1901(%rip), %rdx     # 0xf32ca
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xbc652(%rip), %rsi     # 0xee034
leaq 0xc18be(%rip), %rdx     # 0xf32a7
movq %r15, %rdi
movl $0x19d, %ecx            # imm = 0x19D
jmp 0x31ba4
xorl %ecx, %ecx
cmpl $0x1, 0x14(%rsp)
jne 0x31a03
movl 0x4(%rsp), %ecx
testl %ecx, %ecx
jle 0x31a1d
leaq 0xd8c5a(%rip), %rdi     # 0x10a668
movq %rbx, %r15
movl %ecx, %ebx
callq 0x8510
movl %ebx, %ecx
movq %r15, %rbx
movq 0x8(%rsp), %rax
movw $0x0, 0x518(%rax)
subq $0x50, %rsp
movq 0x8e0(%rsp), %rdx
movq %rdx, 0x40(%rsp)
movq %rbx, 0x38(%rsp)
movq %rax, %rbx
movl %ecx, 0x30(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
movl %ecx, %r15d
callq 0x3952f
addq $0x50, %rsp
testl %eax, %eax
je 0x31aa4
leaq 0xbc988(%rip), %rsi     # 0xee3f0
leaq 0xc189c(%rip), %rdx     # 0xf330b
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq 0x890(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xbc5a4(%rip), %rsi     # 0xee034
leaq 0xc1810(%rip), %rdx     # 0xf32a7
movq %r14, %rdi
movl $0x1aa, %ecx            # imm = 0x1AA
jmp 0x31ba4
movl %r15d, (%rsp)
movq 0x888(%rsp), %rax
movq 0x870(%rsp), %r15
subq $0x8, %rsp
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq 0x20(%rsp), %rbx
movq %rbx, %rcx
movq %r14, %r8
movq %rbp, %r9
movq %rax, %rbp
movq 0x898(%rsp), %r14
pushq %r14
pushq %rax
pushq 0x898(%rsp)
pushq 0x898(%rsp)
pushq %r15
pushq 0x898(%rsp)
pushq 0x898(%rsp)
callq 0x3b844
addq $0x40, %rsp
testl %eax, %eax
je 0x31b44
leaq 0xbc8dd(%rip), %rsi     # 0xee3f0
leaq 0xc1857(%rip), %rdx     # 0xf3371
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xbc501(%rip), %rsi     # 0xee034
leaq 0xc176d(%rip), %rdx     # 0xf32a7
movq %r14, %rdi
movl $0x1b0, %ecx            # imm = 0x1B0
jmp 0x31ba4
movq %rbp, %rsi
cmpl $0x1, 0x4(%rsp)
jne 0x31b5f
xorl %ebp, %ebp
movq 0x8(%rsp), %rax
cmpw $0x1, 0x518(%rax)
je 0x31bb3
movq %r13, %rdi
movq %r14, %rdx
callq 0x3bd49
testl %eax, %eax
je 0x31bc7
leaq 0xbc87b(%rip), %rsi     # 0xee3f0
leaq 0xc1844(%rip), %rdx     # 0xf33c0
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xbc49f(%rip), %rsi     # 0xee034
leaq 0xc170b(%rip), %rdx     # 0xf32a7
movq %r14, %rdi
movl $0x1be, %ecx            # imm = 0x1BE
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %ebp
movl %ebp, %eax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
cmpw $0x1, 0x28(%r15)
jne 0x31bb3
movl (%rsp), %r8d
testl %r8d, %r8d
jle 0x31c04
leaq 0xd8a19(%rip), %rdi     # 0x10a5fa
callq 0x8510
leaq 0xc17f5(%rip), %rdi     # 0xf33e2
xorl %eax, %eax
callq 0x8030
leaq 0xd8a51(%rip), %rdi     # 0x10a64c
callq 0x8510
movl (%rsp), %r8d
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq %r14, %r9
callq 0x3c33f
testl %eax, %eax
je 0x31bb3
leaq 0xbc7cb(%rip), %rsi     # 0xee3f0
leaq 0xc180d(%rip), %rdx     # 0xf3439
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
leaq 0xbc3ef(%rip), %rsi     # 0xee034
leaq 0xc165b(%rip), %rdx     # 0xf32a7
movq %r14, %rdi
movl $0x1c9, %ecx            # imm = 0x1C9
jmp 0x31ba4