// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/fourier.c
// Function: fourier_pk_at_k_and_z
int fourier_pk_at_k_and_z(
                          struct background * pba,
                          struct primordial * ppm,
                          struct fourier *pfo,
                          enum pk_outputs pk_output,
                          double k,
                          double z,
                          int index_pk,
                          double * out_pk, // number *out_pk_l
                          double * out_pk_ic // array out_pk_ic_l[index_ic_ic]
                          ) {

  double * out_pk_at_z;
  double * out_pk_ic_at_z = NULL;
  double * ddout_pk_at_z;
  double * ddout_pk_ic_at_z;
  int last_index;
  int index_ic1;
  int index_ic2;
  int index_ic1_ic1;
  int index_ic2_ic2;
  int index_ic1_ic2;
  double kmin;
  double * pk_primordial_k;
  double * pk_primordial_kmin;
  short do_ic = _FALSE_;

  /** - preliminary: check whether we need the decomposition into contributions from each initial condition */

  if ((pk_output == pk_linear) && (pfo->ic_size > 1) && (out_pk_ic != NULL))
    do_ic = _TRUE_;

  /** - first step: check that k is in valid range [0:kmax]
      (the test for z will be done when calling fourier_pk_linear_at_z()) */

  class_test((k < 0.) || (k > exp(pfo->ln_k[pfo->k_size-1])),
             pfo->error_message,
             "k=%e out of bounds [%e:%e]",k,0.,exp(pfo->ln_k[pfo->k_size-1]));

  /** - deal with case k = 0 for which P(k) is set to zero
      (this non-physical result can be useful for interpolations) */

  if (k == 0.) {
    *out_pk = 0.;

    if (do_ic == _TRUE_) {
      for (index_ic1_ic2=0; index_ic1_ic2<pfo->ic_ic_size; index_ic1_ic2++) {
        out_pk_ic[index_ic1_ic2] = 0.;
      }
    }
  }

  /** - deal with 0 < k <= kmax */

  else {

    class_alloc(out_pk_at_z,
                pfo->k_size*sizeof(double),
                pfo->error_message);

    if (do_ic == _TRUE_) {
      class_alloc(out_pk_ic_at_z,
                  pfo->k_size*pfo->ic_ic_size*sizeof(double),
                  pfo->error_message);
    }

    /** - deal with standard case kmin <= k <= kmax */

    if (k > exp(pfo->ln_k[0])) {

      /** --> First, get P(k) at the right z (in logarithmic format for more accurate interpolation, and then convert to linear format) */

      class_call(fourier_pk_at_z(pba,
                                 pfo,
                                 logarithmic,
                                 pk_output,
                                 z,
                                 index_pk,
                                 out_pk_at_z,
                                 out_pk_ic_at_z
                                 ),
                 pfo->error_message,
                 pfo->error_message);

      /** --> interpolate total spectrum */

      class_alloc(ddout_pk_at_z,
                  pfo->k_size*sizeof(double),
                  pfo->error_message);

      class_call(array_spline_table_lines(pfo->ln_k,
                                          pfo->k_size,
                                          out_pk_at_z,
                                          1,
                                          ddout_pk_at_z,
                                          _SPLINE_NATURAL_,
                                          pfo->error_message),
                 pfo->error_message,
                 pfo->error_message);

      class_call(array_interpolate_spline(pfo->ln_k,
                                          pfo->k_size,
                                          out_pk_at_z,
                                          ddout_pk_at_z,
                                          1,
                                          log(k),
                                          &last_index,
                                          out_pk,
                                          1,
                                          pfo->error_message),
                 pfo->error_message,
                 pfo->error_message);

      free(ddout_pk_at_z);

      // uncomment this part if you prefer a linear interpolation

      /*
        class_call(array_interpolate_linear(pfo->ln_k,
        pfo->k_size,
        out_pk_at_z,
        1,
        log(k),
        &last_index,
        out_pk,
        1,
        pfo->error_message),
        pfo->error_message,
        pfo->error_message);
      */

      /** --> convert from logarithmic to linear format */

      *out_pk = exp(*out_pk);

      /** --> interpolate each ic component */

      if (do_ic == _TRUE_) {

        class_alloc(ddout_pk_ic_at_z,
                    pfo->k_size*pfo->ic_ic_size*sizeof(double),
                    pfo->error_message);

        class_call(array_spline_table_lines(pfo->ln_k,
                                            pfo->k_size,
                                            out_pk_ic_at_z,
                                            pfo->ic_ic_size,
                                            ddout_pk_ic_at_z,
                                            _SPLINE_NATURAL_,
                                            pfo->error_message),
                   pfo->error_message,
                   pfo->error_message);

        class_call(array_interpolate_spline(pfo->ln_k,
                                            pfo->k_size,
                                            out_pk_ic_at_z,
                                            ddout_pk_ic_at_z,
                                            pfo->ic_ic_size,
                                            log(k),
                                            &last_index,
                                            out_pk_ic,
                                            pfo->ic_ic_size,
                                            pfo->error_message),
                   pfo->error_message,
                   pfo->error_message);

        free(ddout_pk_ic_at_z);

        /** --> convert each ic component from logarithmic to linear format */

        for (index_ic1=0; index_ic1 < pfo->ic_size; index_ic1++) {
          index_ic1_ic1 = index_symmetric_matrix(index_ic1,index_ic1,pfo->ic_size);
          out_pk_ic[index_ic1_ic1] = exp(out_pk_ic[index_ic1_ic1]);
        }
        for (index_ic1=0; index_ic1 < pfo->ic_size; index_ic1++) {
          for (index_ic2=index_ic1+1; index_ic2 < pfo->ic_size; index_ic2++) {
            index_ic1_ic1 = index_symmetric_matrix(index_ic1,index_ic1,pfo->ic_size);
            index_ic2_ic2 = index_symmetric_matrix(index_ic2,index_ic2,pfo->ic_size);
            index_ic1_ic2 = index_symmetric_matrix(index_ic1,index_ic2,pfo->ic_size);
            out_pk_ic[index_ic1_ic2]
              = out_pk_ic[index_ic1_ic2]*sqrt(out_pk_ic[index_ic1_ic1]*out_pk_ic[index_ic2_ic2]);
          }
        }
      }
    }

    /** --> deal with case 0 < k < kmin that requires extrapolation
     *    P(k) = [some number] * k  * P_primordial(k)
     *    so
     *    P(k) = P(kmin) * (k P_primordial(k)) / (kmin P_primordial(kmin))
     *    (note that the result is accurate only if kmin is such that [a0 kmin] << H0)
     *
     *    This is accurate for the synchronous gauge; TODO: write
     *    newtonian gauge case. Also, In presence of isocurvature
     *    modes, we assumes for simplicity that the mode with
     *    index_ic1_ic2=0 dominates at small k: exact treatment should be
     *    written if needed.
     */

    else {

      /** --> First, get P(k) at the right z (in linear format) */

      class_call(fourier_pk_at_z(pba,
                                 pfo,
                                 linear,
                                 pk_output,
                                 z,
                                 index_pk,
                                 out_pk_at_z,
                                 out_pk_ic_at_z
                                 ),
                 pfo->error_message,
                 pfo->error_message);

      /* get P(kmin) */
      *out_pk = out_pk_at_z[0];

      if (do_ic == _TRUE_) {
        for (index_ic1_ic2=0; index_ic1_ic2<pfo->ic_ic_size; index_ic1_ic2++) {
          out_pk_ic[index_ic1_ic2] = out_pk_ic_at_z[index_ic1_ic2];
        }
      }

      /* compute P_primordial(k) */

      class_alloc(pk_primordial_k,
                  sizeof(double)*pfo->ic_ic_size,
                  pfo->error_message);

      ppm->calling_from_pk = _TRUE_;
      class_call(primordial_spectrum_at_k(ppm,
                                          pfo->index_md_scalars,
                                          linear,
                                          k,
                                          pk_primordial_k),
                 ppm->error_message,
                 pfo->error_message);
      ppm->calling_from_pk = _FALSE_;
      /* compute P_primordial(kmin) */

      kmin = exp(pfo->ln_k[0]);

      class_alloc(pk_primordial_kmin,
                  sizeof(double)*pfo->ic_ic_size,
                  pfo->error_message);

      ppm->calling_from_pk = _TRUE_;
      class_call(primordial_spectrum_at_k(ppm,
                                          pfo->index_md_scalars,
                                          linear,
                                          kmin,
                                          pk_primordial_kmin),
                 ppm->error_message,
                 pfo->error_message);
      ppm->calling_from_pk = _FALSE_;
      /* finally, infer P(k) */

      *out_pk *= (k*pk_primordial_k[0]/kmin/pk_primordial_kmin[0]);

      if (do_ic == _TRUE_) {
        for (index_ic1_ic2=0; index_ic1_ic2<pfo->ic_ic_size; index_ic1_ic2++) {
          out_pk_ic[index_ic1_ic2] *= (k*pk_primordial_k[index_ic1_ic2]
                                       /kmin/pk_primordial_kmin[index_ic1_ic2]);
        }
      }

      free(pk_primordial_k);
      free(pk_primordial_kmin);
    }

    free(out_pk_at_z);
    if (do_ic == _TRUE_) {
      free(out_pk_ic_at_z);
    }
  }

  return _SUCCESS_;
}

// Assembly:
subq $0x81c8, %rsp           # imm = 0x81C8
movq 0x81d0(%rsp), %rax
movq %rdi, 0x81b8(%rsp)
movq %rsi, 0x81b0(%rsp)
movq %rdx, 0x81a8(%rsp)
movl %ecx, 0x81a4(%rsp)
movsd %xmm0, 0x8198(%rsp)
movsd %xmm1, 0x8190(%rsp)
movl %r8d, 0x818c(%rsp)
movq %r9, 0x8180(%rsp)
movq $0x0, 0x8170(%rsp)
movw $0x0, 0x812e(%rsp)
cmpl $0x0, 0x81a4(%rsp)
jne 0x1251f3
movq 0x81a8(%rsp), %rax
cmpl $0x1, 0x40(%rax)
jle 0x1251f3
cmpq $0x0, 0x81d0(%rsp)
je 0x1251f3
movw $0x1, 0x812e(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x8198(%rsp), %xmm0
ja 0x125253
movsd 0x8198(%rsp), %xmm0
movsd %xmm0, 0xb8(%rsp)
movq 0x81a8(%rsp), %rax
movq 0x80(%rax), %rax
movq 0x81a8(%rsp), %rcx
movl 0x6c(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x8670
movaps %xmm0, %xmm1
movsd 0xb8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x12532a
leaq 0x7920(%rsp), %rax
movq %rax, 0xa8(%rsp)
movsd 0x8198(%rsp), %xmm0
movsd %xmm0, 0xb0(%rsp)
movq 0x81a8(%rsp), %rax
movq 0x80(%rax), %rax
movq 0x81a8(%rsp), %rcx
movl 0x6c(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x8670
movq 0xa8(%rsp), %rdi
movaps %xmm0, %xmm2
movsd 0xb0(%rsp), %xmm0
leaq 0xdabc0(%rip), %rsi     # 0x1ffe7a
xorps %xmm1, %xmm1
movb $0x3, %al
callq 0x5b9c0
leaq 0x7120(%rsp), %rdi
leaq 0x7920(%rsp), %rcx
leaq 0xacda7(%rip), %rsi     # 0x1d2082
leaq 0xdabb3(%rip), %rdx     # 0x1ffe95
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x7120(%rsp), %r8
leaq 0xacd2d(%rip), %rsi     # 0x1d2034
leaq 0xdabb7(%rip), %rdx     # 0x1ffec5
movl $0x1e5, %ecx            # imm = 0x1E5
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movsd 0x8198(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1253ab
jp 0x1253ab
movq 0x8180(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movswl 0x812e(%rsp), %eax
cmpl $0x1, %eax
jne 0x1253a6
movl $0x0, 0x8148(%rsp)
movl 0x8148(%rsp), %eax
movq 0x81a8(%rsp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x1253a4
movq 0x81d0(%rsp), %rax
movslq 0x8148(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x8148(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8148(%rsp)
jmp 0x125365
jmp 0x1253a6
jmp 0x1264cb
movq 0x81a8(%rsp), %rax
movslq 0x6c(%rax), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0x8178(%rsp)
cmpq $0x0, 0x8178(%rsp)
jne 0x12544f
movq 0x81a8(%rsp), %rax
movslq 0x6c(%rax), %rax
shlq $0x3, %rax
movl %eax, 0x711c(%rsp)
leaq 0x6910(%rsp), %rdi
movl 0x711c(%rsp), %ecx
leaq 0xacc04(%rip), %rsi     # 0x1d2004
leaq 0xdab33(%rip), %rdx     # 0x1fff3a
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x6910(%rsp), %r8
leaq 0xacc08(%rip), %rsi     # 0x1d2034
leaq 0xdaa92(%rip), %rdx     # 0x1ffec5
movl $0x1fa, %ecx            # imm = 0x1FA
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movswl 0x812e(%rsp), %eax
cmpl $0x1, %eax
jne 0x125525
movq 0x81a8(%rsp), %rax
movl 0x6c(%rax), %eax
movq 0x81a8(%rsp), %rcx
imull 0x44(%rcx), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0x8170(%rsp)
cmpq $0x0, 0x8170(%rsp)
jne 0x125523
movq 0x81a8(%rsp), %rax
movl 0x6c(%rax), %eax
movq 0x81a8(%rsp), %rcx
imull 0x44(%rcx), %eax
cltq
shlq $0x3, %rax
movl %eax, 0x690c(%rsp)
leaq 0x6100(%rsp), %rdi
movl 0x690c(%rsp), %ecx
leaq 0xacb30(%rip), %rsi     # 0x1d2004
leaq 0xdab58(%rip), %rdx     # 0x200033
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x6100(%rsp), %r8
leaq 0xacb34(%rip), %rsi     # 0x1d2034
leaq 0xda9be(%rip), %rdx     # 0x1ffec5
movl $0x1ff, %ecx            # imm = 0x1FF
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
jmp 0x125525
movsd 0x8198(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
movq 0x81a8(%rsp), %rax
movq 0x80(%rax), %rax
movsd (%rax), %xmm0
callq 0x8670
movaps %xmm0, %xmm1
movsd 0xa0(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x125f94
movq 0x81b8(%rsp), %rdi
movq 0x81a8(%rsp), %rsi
movl 0x81a4(%rsp), %ecx
movsd 0x8190(%rsp), %xmm0
movl 0x818c(%rsp), %r8d
movq 0x8178(%rsp), %r9
movq 0x8170(%rsp), %rax
movl $0x1, %edx
movq %rax, (%rsp)
callq 0x1236f0
cmpl $0x1, %eax
jne 0x12561d
leaq 0x5900(%rsp), %rdi
movq 0x81a8(%rsp), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0xace0a(%rip), %rsi     # 0x1d23d8
leaq 0xda906(%rip), %rdx     # 0x1ffedb
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x5900(%rsp), %r8
leaq 0xaca3a(%rip), %rsi     # 0x1d2034
leaq 0xda8c4(%rip), %rdx     # 0x1ffec5
movl $0x212, %ecx            # imm = 0x212
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movq 0x81a8(%rsp), %rax
movslq 0x6c(%rax), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0x8168(%rsp)
cmpq $0x0, 0x8168(%rsp)
jne 0x1256c1
movq 0x81a8(%rsp), %rax
movslq 0x6c(%rax), %rax
shlq $0x3, %rax
movl %eax, 0x58fc(%rsp)
leaq 0x50f0(%rsp), %rdi
movl 0x58fc(%rsp), %ecx
leaq 0xac992(%rip), %rsi     # 0x1d2004
leaq 0xda8bf(%rip), %rdx     # 0x1fff38
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x50f0(%rsp), %r8
leaq 0xac996(%rip), %rsi     # 0x1d2034
leaq 0xda820(%rip), %rdx     # 0x1ffec5
movl $0x218, %ecx            # imm = 0x218
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movq 0x81a8(%rsp), %rax
movq 0x80(%rax), %rdi
movq 0x81a8(%rsp), %rax
movl 0x6c(%rax), %esi
movq 0x8178(%rsp), %rdx
movq 0x8168(%rsp), %r8
movq 0x81a8(%rsp), %rax
addq $0x192, %rax            # imm = 0x192
movl $0x1, %ecx
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x1cf90
cmpl $0x1, %eax
jne 0x12577c
leaq 0x48f0(%rsp), %rdi
movq 0x81a8(%rsp), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0xaccab(%rip), %rsi     # 0x1d23d8
leaq 0xda812(%rip), %rdx     # 0x1fff46
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x48f0(%rsp), %r8
leaq 0xac8db(%rip), %rsi     # 0x1d2034
leaq 0xda765(%rip), %rdx     # 0x1ffec5
movl $0x222, %ecx            # imm = 0x222
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movq 0x81a8(%rsp), %rax
movq 0x80(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x81a8(%rsp), %rax
movl 0x6c(%rax), %eax
movl %eax, 0x8c(%rsp)
movq 0x8178(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x8168(%rsp), %rax
movq %rax, 0x98(%rsp)
movsd 0x8198(%rsp), %xmm0
callq 0x82f0
movq 0x80(%rsp), %rdi
movl 0x8c(%rsp), %esi
movq 0x90(%rsp), %rdx
movq 0x98(%rsp), %rcx
movq 0x8180(%rsp), %r10
movq 0x81a8(%rsp), %rax
addq $0x192, %rax            # imm = 0x192
movl $0x1, %r8d
leaq 0x815c(%rsp), %r9
movq %r10, (%rsp)
movl $0x1, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x24220
cmpl $0x1, %eax
jne 0x12589e
leaq 0x40f0(%rsp), %rdi
movq 0x81a8(%rsp), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0xacb89(%rip), %rsi     # 0x1d23d8
leaq 0xda757(%rip), %rdx     # 0x1fffad
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x40f0(%rsp), %r8
leaq 0xac7b9(%rip), %rsi     # 0x1d2034
leaq 0xda643(%rip), %rdx     # 0x1ffec5
movl $0x22f, %ecx            # imm = 0x22F
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movq 0x8168(%rsp), %rdi
callq 0x8420
movq 0x8180(%rsp), %rax
movsd (%rax), %xmm0
callq 0x8670
movq 0x8180(%rsp), %rax
movsd %xmm0, (%rax)
movswl 0x812e(%rsp), %eax
cmpl $0x1, %eax
jne 0x125f8f
movq 0x81a8(%rsp), %rax
movl 0x6c(%rax), %eax
movq 0x81a8(%rsp), %rcx
imull 0x44(%rcx), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0x8160(%rsp)
cmpq $0x0, 0x8160(%rsp)
jne 0x12599c
movq 0x81a8(%rsp), %rax
movl 0x6c(%rax), %eax
movq 0x81a8(%rsp), %rcx
imull 0x44(%rcx), %eax
cltq
shlq $0x3, %rax
movl %eax, 0x40ec(%rsp)
leaq 0x38e0(%rsp), %rdi
movl 0x40ec(%rsp), %ecx
leaq 0xac6b7(%rip), %rsi     # 0x1d2004
leaq 0xda6dd(%rip), %rdx     # 0x200031
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x38e0(%rsp), %r8
leaq 0xac6bb(%rip), %rsi     # 0x1d2034
leaq 0xda545(%rip), %rdx     # 0x1ffec5
movl $0x24d, %ecx            # imm = 0x24D
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movq 0x81a8(%rsp), %rax
movq 0x80(%rax), %rdi
movq 0x81a8(%rsp), %rax
movl 0x6c(%rax), %esi
movq 0x8170(%rsp), %rdx
movq 0x81a8(%rsp), %rax
movl 0x44(%rax), %ecx
movq 0x8160(%rsp), %r8
movq 0x81a8(%rsp), %rax
addq $0x192, %rax            # imm = 0x192
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x1cf90
cmpl $0x1, %eax
jne 0x125a5d
leaq 0x30e0(%rsp), %rdi
movq 0x81a8(%rsp), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0xac9ca(%rip), %rsi     # 0x1d23d8
leaq 0xda62d(%rip), %rdx     # 0x200042
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x30e0(%rsp), %r8
leaq 0xac5fa(%rip), %rsi     # 0x1d2034
leaq 0xda484(%rip), %rdx     # 0x1ffec5
movl $0x257, %ecx            # imm = 0x257
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movq 0x81a8(%rsp), %rax
movq 0x80(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x81a8(%rsp), %rax
movl 0x6c(%rax), %eax
movl %eax, 0x64(%rsp)
movq 0x8170(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x8160(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x81a8(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, 0x7c(%rsp)
movsd 0x8198(%rsp), %xmm0
callq 0x82f0
movq 0x58(%rsp), %rdi
movl 0x64(%rsp), %esi
movq 0x68(%rsp), %rdx
movq 0x70(%rsp), %rcx
movl 0x7c(%rsp), %r8d
movq 0x81d0(%rsp), %r11
movq 0x81a8(%rsp), %rax
movl 0x44(%rax), %r10d
movq 0x81a8(%rsp), %rax
addq $0x192, %rax            # imm = 0x192
leaq 0x815c(%rsp), %r9
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x24220
cmpl $0x1, %eax
jne 0x125b7e
leaq 0x28e0(%rsp), %rdi
movq 0x81a8(%rsp), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0xac8a9(%rip), %rsi     # 0x1d23d8
leaq 0xda587(%rip), %rdx     # 0x2000bd
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x28e0(%rsp), %r8
leaq 0xac4d9(%rip), %rsi     # 0x1d2034
leaq 0xda363(%rip), %rdx     # 0x1ffec5
movl $0x264, %ecx            # imm = 0x264
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movq 0x8160(%rsp), %rdi
callq 0x8420
movl $0x0, 0x8158(%rsp)
movl 0x8158(%rsp), %eax
movq 0x81a8(%rsp), %rcx
cmpl 0x40(%rcx), %eax
jge 0x125ca0
movl 0x8158(%rsp), %eax
cmpl 0x8158(%rsp), %eax
jg 0x125c08
movl 0x8158(%rsp), %eax
movq 0x81a8(%rsp), %rcx
movl 0x40(%rcx), %ecx
imull 0x8158(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x50(%rsp)
movl 0x8158(%rsp), %eax
movl 0x8158(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x50(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x54(%rsp)
jmp 0x125c50
movl 0x8158(%rsp), %eax
movq 0x81a8(%rsp), %rcx
movl 0x40(%rcx), %ecx
imull 0x8158(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x4c(%rsp)
movl 0x8158(%rsp), %eax
movl 0x8158(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x4c(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x8150(%rsp)
movq 0x81d0(%rsp), %rax
movslq 0x8150(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x8670
movq 0x81d0(%rsp), %rax
movslq 0x8150(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x8158(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8158(%rsp)
jmp 0x125b96
movl $0x0, 0x8158(%rsp)
movl 0x8158(%rsp), %eax
movq 0x81a8(%rsp), %rcx
cmpl 0x40(%rcx), %eax
jge 0x125f8d
movl 0x8158(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8154(%rsp)
movl 0x8154(%rsp), %eax
movq 0x81a8(%rsp), %rcx
cmpl 0x40(%rcx), %eax
jge 0x125f75
movl 0x8158(%rsp), %eax
cmpl 0x8158(%rsp), %eax
jg 0x125d46
movl 0x8158(%rsp), %eax
movq 0x81a8(%rsp), %rcx
movl 0x40(%rcx), %ecx
imull 0x8158(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x44(%rsp)
movl 0x8158(%rsp), %eax
movl 0x8158(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x44(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x48(%rsp)
jmp 0x125d8e
movl 0x8158(%rsp), %eax
movq 0x81a8(%rsp), %rcx
movl 0x40(%rcx), %ecx
imull 0x8158(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x40(%rsp)
movl 0x8158(%rsp), %eax
movl 0x8158(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x40(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x48(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x8150(%rsp)
movl 0x8154(%rsp), %eax
cmpl 0x8154(%rsp), %eax
jg 0x125df3
movl 0x8154(%rsp), %eax
movq 0x81a8(%rsp), %rcx
movl 0x40(%rcx), %ecx
imull 0x8154(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x38(%rsp)
movl 0x8154(%rsp), %eax
movl 0x8154(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x38(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x3c(%rsp)
jmp 0x125e3b
movl 0x8154(%rsp), %eax
movq 0x81a8(%rsp), %rcx
movl 0x40(%rcx), %ecx
imull 0x8154(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x34(%rsp)
movl 0x8154(%rsp), %eax
movl 0x8154(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x34(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x814c(%rsp)
movl 0x8158(%rsp), %eax
cmpl 0x8154(%rsp), %eax
jg 0x125ea0
movl 0x8154(%rsp), %eax
movq 0x81a8(%rsp), %rcx
movl 0x40(%rcx), %ecx
imull 0x8158(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x2c(%rsp)
movl 0x8158(%rsp), %eax
movl 0x8158(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x2c(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x30(%rsp)
jmp 0x125ee8
movl 0x8158(%rsp), %eax
movq 0x81a8(%rsp), %rcx
movl 0x40(%rcx), %ecx
imull 0x8154(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x28(%rsp)
movl 0x8154(%rsp), %eax
movl 0x8154(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x28(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x8148(%rsp)
movq 0x81d0(%rsp), %rax
movslq 0x8148(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x81d0(%rsp), %rax
movslq 0x8150(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x81d0(%rsp), %rax
movslq 0x814c(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
callq 0x82e0
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
mulsd %xmm1, %xmm0
movq 0x81d0(%rsp), %rax
movslq 0x8148(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x8154(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8154(%rsp)
jmp 0x125cd4
jmp 0x125f77
movl 0x8158(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8158(%rsp)
jmp 0x125cab
jmp 0x125f8f
jmp 0x1264a2
movq 0x81b8(%rsp), %rdi
movq 0x81a8(%rsp), %rsi
movl 0x81a4(%rsp), %ecx
movsd 0x8190(%rsp), %xmm0
movl 0x818c(%rsp), %r8d
movq 0x8178(%rsp), %r9
movq 0x8170(%rsp), %rax
xorl %edx, %edx
movq %rax, (%rsp)
callq 0x1236f0
cmpl $0x1, %eax
jne 0x126049
leaq 0x20e0(%rsp), %rdi
movq 0x81a8(%rsp), %rcx
addq $0x192, %rcx            # imm = 0x192
leaq 0xac3de(%rip), %rsi     # 0x1d23d8
leaq 0xda165(%rip), %rdx     # 0x200166
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x20e0(%rsp), %r8
leaq 0xac00e(%rip), %rsi     # 0x1d2034
leaq 0xd9e98(%rip), %rdx     # 0x1ffec5
movl $0x295, %ecx            # imm = 0x295
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movq 0x8178(%rsp), %rax
movsd (%rax), %xmm0
movq 0x8180(%rsp), %rax
movsd %xmm0, (%rax)
movswl 0x812e(%rsp), %eax
cmpl $0x1, %eax
jne 0x1260cc
movl $0x0, 0x8148(%rsp)
movl 0x8148(%rsp), %eax
movq 0x81a8(%rsp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x1260ca
movq 0x8170(%rsp), %rax
movslq 0x8148(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x81d0(%rsp), %rax
movslq 0x8148(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x8148(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8148(%rsp)
jmp 0x126079
jmp 0x1260cc
movq 0x81a8(%rsp), %rax
movslq 0x44(%rax), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0x8138(%rsp)
cmpq $0x0, 0x8138(%rsp)
jne 0x126170
movq 0x81a8(%rsp), %rax
movslq 0x44(%rax), %rax
shlq $0x3, %rax
movl %eax, 0x20dc(%rsp)
leaq 0x18d0(%rsp), %rdi
movl 0x20dc(%rsp), %ecx
leaq 0xabee3(%rip), %rsi     # 0x1d2004
leaq 0xe7fe6(%rip), %rdx     # 0x20e10e
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x18d0(%rsp), %r8
leaq 0xabee7(%rip), %rsi     # 0x1d2034
leaq 0xd9d71(%rip), %rdx     # 0x1ffec5
movl $0x2a4, %ecx            # imm = 0x2A4
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movq 0x81b0(%rsp), %rax
movw $0x1, 0xb2c(%rax)
movq 0x81b0(%rsp), %rdi
movq 0x81a8(%rsp), %rax
movl 0x3c(%rax), %esi
movsd 0x8198(%rsp), %xmm0
movq 0x8138(%rsp), %rcx
xorl %edx, %edx
callq 0x1103c0
cmpl $0x1, %eax
jne 0x12621e
leaq 0x10d0(%rsp), %rdi
movq 0x81b0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xac209(%rip), %rsi     # 0x1d23d8
leaq 0xd9fe8(%rip), %rdx     # 0x2001be
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x10d0(%rsp), %r8
leaq 0xabe39(%rip), %rsi     # 0x1d2034
leaq 0xd9cc3(%rip), %rdx     # 0x1ffec5
movl $0x2ad, %ecx            # imm = 0x2AD
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movq 0x81b0(%rsp), %rax
movw $0x0, 0xb2c(%rax)
movq 0x81a8(%rsp), %rax
movq 0x80(%rax), %rax
movsd (%rax), %xmm0
callq 0x8670
movsd %xmm0, 0x8140(%rsp)
movq 0x81a8(%rsp), %rax
movslq 0x44(%rax), %rdi
shlq $0x3, %rdi
callq 0x8460
movq %rax, 0x8130(%rsp)
cmpq $0x0, 0x8130(%rsp)
jne 0x1262f4
movq 0x81a8(%rsp), %rax
movslq 0x44(%rax), %rax
shlq $0x3, %rax
movl %eax, 0x10cc(%rsp)
leaq 0x8c0(%rsp), %rdi
movl 0x10cc(%rsp), %ecx
leaq 0xabd5f(%rip), %rsi     # 0x1d2004
leaq 0xd9f63(%rip), %rdx     # 0x20020f
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0x8c0(%rsp), %r8
leaq 0xabd63(%rip), %rsi     # 0x1d2034
leaq 0xd9bed(%rip), %rdx     # 0x1ffec5
movl $0x2b5, %ecx            # imm = 0x2B5
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movq 0x81b0(%rsp), %rax
movw $0x1, 0xb2c(%rax)
movq 0x81b0(%rsp), %rdi
movq 0x81a8(%rsp), %rax
movl 0x3c(%rax), %esi
movsd 0x8140(%rsp), %xmm0
movq 0x8130(%rsp), %rcx
xorl %edx, %edx
callq 0x1103c0
cmpl $0x1, %eax
jne 0x1263a2
leaq 0xc0(%rsp), %rdi
movq 0x81b0(%rsp), %rcx
addq $0x32a, %rcx            # imm = 0x32A
leaq 0xac085(%rip), %rsi     # 0x1d23d8
leaq 0xd9ec8(%rip), %rdx     # 0x200222
movb $0x0, %al
callq 0x5b9c0
movq 0x81a8(%rsp), %rdi
addq $0x192, %rdi            # imm = 0x192
leaq 0xc0(%rsp), %r8
leaq 0xabcb5(%rip), %rsi     # 0x1d2034
leaq 0xd9b3f(%rip), %rdx     # 0x1ffec5
movl $0x2be, %ecx            # imm = 0x2BE
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x81c4(%rsp)
jmp 0x1264d6
movq 0x81b0(%rsp), %rax
movw $0x0, 0xb2c(%rax)
movsd 0x8198(%rsp), %xmm0
movq 0x8138(%rsp), %rax
mulsd (%rax), %xmm0
divsd 0x8140(%rsp), %xmm0
movq 0x8130(%rsp), %rax
divsd (%rax), %xmm0
movq 0x8180(%rsp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movswl 0x812e(%rsp), %eax
cmpl $0x1, %eax
jne 0x126488
movl $0x0, 0x8148(%rsp)
movl 0x8148(%rsp), %eax
movq 0x81a8(%rsp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x126486
movsd 0x8198(%rsp), %xmm0
movq 0x8138(%rsp), %rax
movslq 0x8148(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
divsd 0x8140(%rsp), %xmm0
movq 0x8130(%rsp), %rax
movslq 0x8148(%rsp), %rcx
divsd (%rax,%rcx,8), %xmm0
movq 0x81d0(%rsp), %rax
movslq 0x8148(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x8148(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8148(%rsp)
jmp 0x126409
jmp 0x126488
movq 0x8138(%rsp), %rdi
callq 0x8420
movq 0x8130(%rsp), %rdi
callq 0x8420
movq 0x8178(%rsp), %rdi
callq 0x8420
movswl 0x812e(%rsp), %eax
cmpl $0x1, %eax
jne 0x1264c9
movq 0x8170(%rsp), %rdi
callq 0x8420
jmp 0x1264cb
movl $0x0, 0x81c4(%rsp)
movl 0x81c4(%rsp), %eax
addq $0x81c8, %rsp           # imm = 0x81C8
retq
nopw %cs:(%rax,%rax)