// File: /workspace/github_c_makefile_star2_O1/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 $0x838, %rsp            # imm = 0x838
movq %r9, 0x28(%rsp)
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x8a0(%rsp), %rbx
subq $0x40, %rsp
movq %rbx, 0x30(%rsp)
callq 0x32551
addq $0x40, %rsp
cmpl $0x1, %eax
jne 0x31ab9
leaq 0xbf96b(%rip), %rsi     # 0xf13f0
leaq 0xc47a4(%rip), %rdx     # 0xf6230
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xbf58f(%rip), %rsi     # 0xf1034
leaq 0xc47d3(%rip), %rdx     # 0xf627f
movq %rbx, %rdi
movl $0x19b, %ecx            # imm = 0x19B
jmp 0x31cd9
movq %r14, 0x20(%rsp)
leaq 0xc47cf(%rip), %rsi     # 0xf6294
leaq 0xc(%rsp), %rdx
leaq 0x1c(%rsp), %rcx
movq %r13, %rdi
movq %rbx, %r8
callq 0x1e6c0
movl %eax, %r14d
cmpl $0x1, %eax
movq %r15, 0x10(%rsp)
jne 0x31b31
leaq 0xbf902(%rip), %rsi     # 0xf13f0
leaq 0xc47ad(%rip), %rdx     # 0xf62a2
movl $0x0, 0x8(%rsp)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xbf51e(%rip), %rsi     # 0xf1034
leaq 0xc4762(%rip), %rdx     # 0xf627f
movq %rbx, %rdi
movl $0x19d, %ecx            # imm = 0x19D
movq %r15, %r8
xorl %eax, %eax
callq 0x30c2c
jmp 0x31b48
movl $0x0, 0x8(%rsp)
cmpl $0x1, 0x1c(%rsp)
jne 0x31b48
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl $0x1, %r15d
cmpl $0x1, %r14d
je 0x31ce9
movl 0x8(%rsp), %r14d
testl %r14d, %r14d
jle 0x31b6e
leaq 0xdbad7(%rip), %rdi     # 0x10d640
callq 0x8510
movq 0x10(%rsp), %r15
movw $0x0, 0x518(%r15)
subq $0x50, %rsp
movq %rbx, 0x40(%rsp)
leaq 0x5c(%rsp), %rax
movq %rax, 0x38(%rsp)
movl %r14d, 0x30(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3a911
addq $0x50, %rsp
testl %eax, %eax
je 0x31be6
leaq 0xbf83e(%rip), %rsi     # 0xf13f0
leaq 0xc472a(%rip), %rdx     # 0xf62e3
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xbf462(%rip), %rsi     # 0xf1034
leaq 0xc46a6(%rip), %rdx     # 0xf627f
movq %rbx, %rdi
movl $0x1aa, %ecx            # imm = 0x1AA
jmp 0x31cd9
movq 0x898(%rsp), %rax
movq 0x880(%rsp), %r14
subq $0x8, %rsp
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x28(%rsp), %rcx
movq %rbp, %r8
movq %rax, %rbp
movq 0x30(%rsp), %r9
pushq %rbx
pushq %rax
pushq 0x8a8(%rsp)
pushq 0x8a8(%rsp)
pushq %r14
pushq 0x8a8(%rsp)
pushq 0x8a8(%rsp)
callq 0x3ccb8
addq $0x40, %rsp
testl %eax, %eax
je 0x31c78
leaq 0xbf7a9(%rip), %rsi     # 0xf13f0
leaq 0xc46fb(%rip), %rdx     # 0xf6349
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xbf3cd(%rip), %rsi     # 0xf1034
leaq 0xc4611(%rip), %rdx     # 0xf627f
movq %rbx, %rdi
movl $0x1b0, %ecx            # imm = 0x1B0
jmp 0x31cd9
cmpl $0x1, 0xc(%rsp)
jne 0x31c91
xorl %r15d, %r15d
movq 0x10(%rsp), %rax
cmpw $0x1, 0x518(%rax)
je 0x31ce9
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x3d1e9
testl %eax, %eax
je 0x31cfe
leaq 0xbf746(%rip), %rsi     # 0xf13f0
leaq 0xc46e7(%rip), %rdx     # 0xf6398
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xbf36a(%rip), %rsi     # 0xf1034
leaq 0xc45ae(%rip), %rdx     # 0xf627f
movq %rbx, %rdi
movl $0x1be, %ecx            # imm = 0x1BE
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %r15d
movl %r15d, %eax
addq $0x838, %rsp            # imm = 0x838
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
cmpw $0x1, 0x28(%r14)
jne 0x31ce9
movl 0x8(%rsp), %ebp
testl %ebp, %ebp
jle 0x31d37
leaq 0xdb8ba(%rip), %rdi     # 0x10d5d2
callq 0x8510
leaq 0xc4696(%rip), %rdi     # 0xf63ba
xorl %eax, %eax
callq 0x8030
leaq 0xdb8f2(%rip), %rdi     # 0x10d624
callq 0x8510
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r14, %rcx
movl %ebp, %r8d
movq %rbx, %r9
callq 0x3d82e
testl %eax, %eax
je 0x31ce9
leaq 0xbf693(%rip), %rsi     # 0xf13f0
leaq 0xc46ad(%rip), %rdx     # 0xf6411
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30c2c
leaq 0xbf2b7(%rip), %rsi     # 0xf1034
leaq 0xc44fb(%rip), %rdx     # 0xf627f
movq %rbx, %rdi
movl $0x1c9, %ecx            # imm = 0x1C9
jmp 0x31cd9