// File: /workspace/github_c_makefile_star2_O2/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 0x2f8db
addq $0x40, %rsp
cmpl $0x1, %eax
jne 0x2eeab
leaq 0xb6579(%rip), %rsi     # 0xe53f0
leaq 0xbb2a2(%rip), %rdx     # 0xea120
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xb619d(%rip), %rsi     # 0xe5034
leaq 0xbb2d1(%rip), %rdx     # 0xea16f
movq %r15, %rdi
movl $0x19b, %ecx            # imm = 0x19B
jmp 0x2f0bc
movq %rbx, 0x18(%rsp)
leaq 0xbb2cd(%rip), %rsi     # 0xea184
leaq 0x4(%rsp), %rbx
leaq 0x14(%rsp), %rcx
movq %r13, %rdi
movq %rbx, %rdx
movq %r15, %r8
callq 0x1c5c4
cmpl $0x1, %eax
jne 0x2ef0f
leaq 0xb6515(%rip), %rsi     # 0xe53f0
leaq 0xbb2b0(%rip), %rdx     # 0xea192
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xb6139(%rip), %rsi     # 0xe5034
leaq 0xbb26d(%rip), %rdx     # 0xea16f
movq %r15, %rdi
movl $0x19d, %ecx            # imm = 0x19D
jmp 0x2f0bc
xorl %ecx, %ecx
cmpl $0x1, 0x14(%rsp)
jne 0x2ef1c
movl 0x4(%rsp), %ecx
testl %ecx, %ecx
jle 0x2ef36
leaq 0xd2609(%rip), %rdi     # 0x101530
movq %rbx, %r15
movl %ecx, %ebx
callq 0x8540
movl %ebx, %ecx
movq %r15, %rbx
movq 0x8(%rsp), %rax
andw $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 0x360fd
addq $0x50, %rsp
testl %eax, %eax
je 0x2efbc
leaq 0xb6470(%rip), %rsi     # 0xe53f0
leaq 0xbb24c(%rip), %rdx     # 0xea1d3
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq 0x890(%rsp), %r14
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xb608c(%rip), %rsi     # 0xe5034
leaq 0xbb1c0(%rip), %rdx     # 0xea16f
movq %r14, %rdi
movl $0x1aa, %ecx            # imm = 0x1AA
jmp 0x2f0bc
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 0x383c9
addq $0x40, %rsp
testl %eax, %eax
je 0x2f05c
leaq 0xb63c5(%rip), %rsi     # 0xe53f0
leaq 0xbb207(%rip), %rdx     # 0xea239
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xb5fe9(%rip), %rsi     # 0xe5034
leaq 0xbb11d(%rip), %rdx     # 0xea16f
movq %r14, %rdi
movl $0x1b0, %ecx            # imm = 0x1B0
jmp 0x2f0bc
movq %rbp, %rsi
cmpl $0x1, 0x4(%rsp)
jne 0x2f077
xorl %ebp, %ebp
movq 0x8(%rsp), %rax
cmpw $0x1, 0x518(%rax)
je 0x2f0c9
movq %r13, %rdi
movq %r14, %rdx
callq 0x388c6
testl %eax, %eax
je 0x2f0dd
leaq 0xb6363(%rip), %rsi     # 0xe53f0
leaq 0xbb1f4(%rip), %rdx     # 0xea288
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xb5f87(%rip), %rsi     # 0xe5034
leaq 0xbb0bb(%rip), %rdx     # 0xea16f
movq %r14, %rdi
movl $0x1be, %ecx            # imm = 0x1BE
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rbp
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 0x2f0c9
movl (%rsp), %r8d
testl %r8d, %r8d
jle 0x2f11a
leaq 0xd23cb(%rip), %rdi     # 0x1014c2
callq 0x8540
leaq 0xbb1a7(%rip), %rdi     # 0xea2aa
xorl %eax, %eax
callq 0x8030
leaq 0xd2403(%rip), %rdi     # 0x101514
callq 0x8540
movl (%rsp), %r8d
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq %r14, %r9
callq 0x38e74
testl %eax, %eax
je 0x2f0c9
leaq 0xb62b5(%rip), %rsi     # 0xe53f0
leaq 0xbb1bf(%rip), %rdx     # 0xea301
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
leaq 0xb5ed9(%rip), %rsi     # 0xe5034
leaq 0xbb00d(%rip), %rdx     # 0xea16f
movq %r14, %rdi
movl $0x1c9, %ecx            # imm = 0x1C9
jmp 0x2f0bc