int tcopy_8(int m, int n, const double *a, int lda, double *b) {
  int i, j;
  const double *aoffset;
  const double *aoffset1, *aoffset2, *aoffset3, *aoffset4;
  const double *aoffset5, *aoffset6, *aoffset7, *aoffset8;
  double *boffset, *boffset1, *boffset2, *boffset3, *boffset4;
  double ctemp01, ctemp02, ctemp03, ctemp04;
  double ctemp05, ctemp06, ctemp07, ctemp08;
  double ctemp09, ctemp10, ctemp11, ctemp12;
  double ctemp13, ctemp14, ctemp15, ctemp16;
  double ctemp17, ctemp18, ctemp19, ctemp20;
  double ctemp21, ctemp22, ctemp23, ctemp24;
  double ctemp25, ctemp26, ctemp27, ctemp28;
  double ctemp29, ctemp30, ctemp31, ctemp32;
  double ctemp33, ctemp34, ctemp35, ctemp36;
  double ctemp37, ctemp38, ctemp39, ctemp40;
  double ctemp41, ctemp42, ctemp43, ctemp44;
  double ctemp45, ctemp46, ctemp47, ctemp48;
  double ctemp49, ctemp50, ctemp51, ctemp52;
  double ctemp53, ctemp54, ctemp55, ctemp56;
  double ctemp57, ctemp58, ctemp59, ctemp60;
  double ctemp61, ctemp62, ctemp63, ctemp64;
  aoffset = a;
  boffset = b;
  boffset2 = b + m * (n & ~7);
  boffset3 = b + m * (n & ~3);
  boffset4 = b + m * (n & ~1);
  j = (m >> 3);
  if (j > 0) {
    do {
      aoffset1 = aoffset;
      aoffset2 = aoffset1 + lda;
      aoffset3 = aoffset2 + lda;
      aoffset4 = aoffset3 + lda;
      aoffset5 = aoffset4 + lda;
      aoffset6 = aoffset5 + lda;
      aoffset7 = aoffset6 + lda;
      aoffset8 = aoffset7 + lda;
      aoffset += 8 * lda;
      boffset1 = boffset;
      boffset += 64;
      i = (n >> 3);
      if (i > 0) {
        do {
          ctemp01 = *(aoffset1 + 0);
          ctemp02 = *(aoffset1 + 1);
          ctemp03 = *(aoffset1 + 2);
          ctemp04 = *(aoffset1 + 3);
          ctemp05 = *(aoffset1 + 4);
          ctemp06 = *(aoffset1 + 5);
          ctemp07 = *(aoffset1 + 6);
          ctemp08 = *(aoffset1 + 7);
          aoffset1 += 8;
          ctemp09 = *(aoffset2 + 0);
          ctemp10 = *(aoffset2 + 1);
          ctemp11 = *(aoffset2 + 2);
          ctemp12 = *(aoffset2 + 3);
          ctemp13 = *(aoffset2 + 4);
          ctemp14 = *(aoffset2 + 5);
          ctemp15 = *(aoffset2 + 6);
          ctemp16 = *(aoffset2 + 7);
          aoffset2 += 8;
          ctemp17 = *(aoffset3 + 0);
          ctemp18 = *(aoffset3 + 1);
          ctemp19 = *(aoffset3 + 2);
          ctemp20 = *(aoffset3 + 3);
          ctemp21 = *(aoffset3 + 4);
          ctemp22 = *(aoffset3 + 5);
          ctemp23 = *(aoffset3 + 6);
          ctemp24 = *(aoffset3 + 7);
          aoffset3 += 8;
          ctemp25 = *(aoffset4 + 0);
          ctemp26 = *(aoffset4 + 1);
          ctemp27 = *(aoffset4 + 2);
          ctemp28 = *(aoffset4 + 3);
          ctemp29 = *(aoffset4 + 4);
          ctemp30 = *(aoffset4 + 5);
          ctemp31 = *(aoffset4 + 6);
          ctemp32 = *(aoffset4 + 7);
          aoffset4 += 8;
          ctemp33 = *(aoffset5 + 0);
          ctemp34 = *(aoffset5 + 1);
          ctemp35 = *(aoffset5 + 2);
          ctemp36 = *(aoffset5 + 3);
          ctemp37 = *(aoffset5 + 4);
          ctemp38 = *(aoffset5 + 5);
          ctemp39 = *(aoffset5 + 6);
          ctemp40 = *(aoffset5 + 7);
          aoffset5 += 8;
          ctemp41 = *(aoffset6 + 0);
          ctemp42 = *(aoffset6 + 1);
          ctemp43 = *(aoffset6 + 2);
          ctemp44 = *(aoffset6 + 3);
          ctemp45 = *(aoffset6 + 4);
          ctemp46 = *(aoffset6 + 5);
          ctemp47 = *(aoffset6 + 6);
          ctemp48 = *(aoffset6 + 7);
          aoffset6 += 8;
          ctemp49 = *(aoffset7 + 0);
          ctemp50 = *(aoffset7 + 1);
          ctemp51 = *(aoffset7 + 2);
          ctemp52 = *(aoffset7 + 3);
          ctemp53 = *(aoffset7 + 4);
          ctemp54 = *(aoffset7 + 5);
          ctemp55 = *(aoffset7 + 6);
          ctemp56 = *(aoffset7 + 7);
          aoffset7 += 8;
          ctemp57 = *(aoffset8 + 0);
          ctemp58 = *(aoffset8 + 1);
          ctemp59 = *(aoffset8 + 2);
          ctemp60 = *(aoffset8 + 3);
          ctemp61 = *(aoffset8 + 4);
          ctemp62 = *(aoffset8 + 5);
          ctemp63 = *(aoffset8 + 6);
          ctemp64 = *(aoffset8 + 7);
          aoffset8 += 8;
          *(boffset1 + 0) = ctemp01;
          *(boffset1 + 1) = ctemp02;
          *(boffset1 + 2) = ctemp03;
          *(boffset1 + 3) = ctemp04;
          *(boffset1 + 4) = ctemp05;
          *(boffset1 + 5) = ctemp06;
          *(boffset1 + 6) = ctemp07;
          *(boffset1 + 7) = ctemp08;
          *(boffset1 + 8) = ctemp09;
          *(boffset1 + 9) = ctemp10;
          *(boffset1 + 10) = ctemp11;
          *(boffset1 + 11) = ctemp12;
          *(boffset1 + 12) = ctemp13;
          *(boffset1 + 13) = ctemp14;
          *(boffset1 + 14) = ctemp15;
          *(boffset1 + 15) = ctemp16;
          *(boffset1 + 16) = ctemp17;
          *(boffset1 + 17) = ctemp18;
          *(boffset1 + 18) = ctemp19;
          *(boffset1 + 19) = ctemp20;
          *(boffset1 + 20) = ctemp21;
          *(boffset1 + 21) = ctemp22;
          *(boffset1 + 22) = ctemp23;
          *(boffset1 + 23) = ctemp24;
          *(boffset1 + 24) = ctemp25;
          *(boffset1 + 25) = ctemp26;
          *(boffset1 + 26) = ctemp27;
          *(boffset1 + 27) = ctemp28;
          *(boffset1 + 28) = ctemp29;
          *(boffset1 + 29) = ctemp30;
          *(boffset1 + 30) = ctemp31;
          *(boffset1 + 31) = ctemp32;
          *(boffset1 + 32) = ctemp33;
          *(boffset1 + 33) = ctemp34;
          *(boffset1 + 34) = ctemp35;
          *(boffset1 + 35) = ctemp36;
          *(boffset1 + 36) = ctemp37;
          *(boffset1 + 37) = ctemp38;
          *(boffset1 + 38) = ctemp39;
          *(boffset1 + 39) = ctemp40;
          *(boffset1 + 40) = ctemp41;
          *(boffset1 + 41) = ctemp42;
          *(boffset1 + 42) = ctemp43;
          *(boffset1 + 43) = ctemp44;
          *(boffset1 + 44) = ctemp45;
          *(boffset1 + 45) = ctemp46;
          *(boffset1 + 46) = ctemp47;
          *(boffset1 + 47) = ctemp48;
          *(boffset1 + 48) = ctemp49;
          *(boffset1 + 49) = ctemp50;
          *(boffset1 + 50) = ctemp51;
          *(boffset1 + 51) = ctemp52;
          *(boffset1 + 52) = ctemp53;
          *(boffset1 + 53) = ctemp54;
          *(boffset1 + 54) = ctemp55;
          *(boffset1 + 55) = ctemp56;
          *(boffset1 + 56) = ctemp57;
          *(boffset1 + 57) = ctemp58;
          *(boffset1 + 58) = ctemp59;
          *(boffset1 + 59) = ctemp60;
          *(boffset1 + 60) = ctemp61;
          *(boffset1 + 61) = ctemp62;
          *(boffset1 + 62) = ctemp63;
          *(boffset1 + 63) = ctemp64;
          boffset1 += m * 8;
          i--;
        } while (i > 0);
      }
      if (n & 4) {
        ctemp01 = *(aoffset1 + 0);
        ctemp02 = *(aoffset1 + 1);
        ctemp03 = *(aoffset1 + 2);
        ctemp04 = *(aoffset1 + 3);
        aoffset1 += 4;
        ctemp05 = *(aoffset2 + 0);
        ctemp06 = *(aoffset2 + 1);
        ctemp07 = *(aoffset2 + 2);
        ctemp08 = *(aoffset2 + 3);
        aoffset2 += 4;
        ctemp09 = *(aoffset3 + 0);
        ctemp10 = *(aoffset3 + 1);
        ctemp11 = *(aoffset3 + 2);
        ctemp12 = *(aoffset3 + 3);
        aoffset3 += 4;
        ctemp13 = *(aoffset4 + 0);
        ctemp14 = *(aoffset4 + 1);
        ctemp15 = *(aoffset4 + 2);
        ctemp16 = *(aoffset4 + 3);
        aoffset4 += 4;
        ctemp17 = *(aoffset5 + 0);
        ctemp18 = *(aoffset5 + 1);
        ctemp19 = *(aoffset5 + 2);
        ctemp20 = *(aoffset5 + 3);
        aoffset5 += 4;
        ctemp21 = *(aoffset6 + 0);
        ctemp22 = *(aoffset6 + 1);
        ctemp23 = *(aoffset6 + 2);
        ctemp24 = *(aoffset6 + 3);
        aoffset6 += 4;
        ctemp25 = *(aoffset7 + 0);
        ctemp26 = *(aoffset7 + 1);
        ctemp27 = *(aoffset7 + 2);
        ctemp28 = *(aoffset7 + 3);
        aoffset7 += 4;
        ctemp29 = *(aoffset8 + 0);
        ctemp30 = *(aoffset8 + 1);
        ctemp31 = *(aoffset8 + 2);
        ctemp32 = *(aoffset8 + 3);
        aoffset8 += 4;
        *(boffset2 + 0) = ctemp01;
        *(boffset2 + 1) = ctemp02;
        *(boffset2 + 2) = ctemp03;
        *(boffset2 + 3) = ctemp04;
        *(boffset2 + 4) = ctemp05;
        *(boffset2 + 5) = ctemp06;
        *(boffset2 + 6) = ctemp07;
        *(boffset2 + 7) = ctemp08;
        *(boffset2 + 8) = ctemp09;
        *(boffset2 + 9) = ctemp10;
        *(boffset2 + 10) = ctemp11;
        *(boffset2 + 11) = ctemp12;
        *(boffset2 + 12) = ctemp13;
        *(boffset2 + 13) = ctemp14;
        *(boffset2 + 14) = ctemp15;
        *(boffset2 + 15) = ctemp16;
        *(boffset2 + 16) = ctemp17;
        *(boffset2 + 17) = ctemp18;
        *(boffset2 + 18) = ctemp19;
        *(boffset2 + 19) = ctemp20;
        *(boffset2 + 20) = ctemp21;
        *(boffset2 + 21) = ctemp22;
        *(boffset2 + 22) = ctemp23;
        *(boffset2 + 23) = ctemp24;
        *(boffset2 + 24) = ctemp25;
        *(boffset2 + 25) = ctemp26;
        *(boffset2 + 26) = ctemp27;
        *(boffset2 + 27) = ctemp28;
        *(boffset2 + 28) = ctemp29;
        *(boffset2 + 29) = ctemp30;
        *(boffset2 + 30) = ctemp31;
        *(boffset2 + 31) = ctemp32;
        boffset2 += 32;
      }
      if (n & 2) {
        ctemp01 = *(aoffset1 + 0);
        ctemp02 = *(aoffset1 + 1);
        aoffset1 += 2;
        ctemp03 = *(aoffset2 + 0);
        ctemp04 = *(aoffset2 + 1);
        aoffset2 += 2;
        ctemp05 = *(aoffset3 + 0);
        ctemp06 = *(aoffset3 + 1);
        aoffset3 += 2;
        ctemp07 = *(aoffset4 + 0);
        ctemp08 = *(aoffset4 + 1);
        aoffset4 += 2;
        ctemp09 = *(aoffset5 + 0);
        ctemp10 = *(aoffset5 + 1);
        aoffset5 += 2;
        ctemp11 = *(aoffset6 + 0);
        ctemp12 = *(aoffset6 + 1);
        aoffset6 += 2;
        ctemp13 = *(aoffset7 + 0);
        ctemp14 = *(aoffset7 + 1);
        aoffset7 += 2;
        ctemp15 = *(aoffset8 + 0);
        ctemp16 = *(aoffset8 + 1);
        aoffset8 += 2;
        *(boffset3 + 0) = ctemp01;
        *(boffset3 + 1) = ctemp02;
        *(boffset3 + 2) = ctemp03;
        *(boffset3 + 3) = ctemp04;
        *(boffset3 + 4) = ctemp05;
        *(boffset3 + 5) = ctemp06;
        *(boffset3 + 6) = ctemp07;
        *(boffset3 + 7) = ctemp08;
        *(boffset3 + 8) = ctemp09;
        *(boffset3 + 9) = ctemp10;
        *(boffset3 + 10) = ctemp11;
        *(boffset3 + 11) = ctemp12;
        *(boffset3 + 12) = ctemp13;
        *(boffset3 + 13) = ctemp14;
        *(boffset3 + 14) = ctemp15;
        *(boffset3 + 15) = ctemp16;
        boffset3 += 16;
      }
      if (n & 1) {
        ctemp01 = *(aoffset1 + 0);
        aoffset1++;
        ctemp02 = *(aoffset2 + 0);
        aoffset2++;
        ctemp03 = *(aoffset3 + 0);
        aoffset3++;
        ctemp04 = *(aoffset4 + 0);
        aoffset4++;
        ctemp05 = *(aoffset5 + 0);
        aoffset5++;
        ctemp06 = *(aoffset6 + 0);
        aoffset6++;
        ctemp07 = *(aoffset7 + 0);
        aoffset7++;
        ctemp08 = *(aoffset8 + 0);
        aoffset8++;
        *(boffset4 + 0) = ctemp01;
        *(boffset4 + 1) = ctemp02;
        *(boffset4 + 2) = ctemp03;
        *(boffset4 + 3) = ctemp04;
        *(boffset4 + 4) = ctemp05;
        *(boffset4 + 5) = ctemp06;
        *(boffset4 + 6) = ctemp07;
        *(boffset4 + 7) = ctemp08;
        boffset4 += 8;
      }
      j--;
    } while (j > 0);
  }
  if (m & 4) {
    aoffset1 = aoffset;
    aoffset2 = aoffset1 + lda;
    aoffset3 = aoffset2 + lda;
    aoffset4 = aoffset3 + lda;
    aoffset += 4 * lda;
    boffset1 = boffset;
    boffset += 32;
    i = (n >> 3);
    if (i > 0) {
      do {
        ctemp01 = *(aoffset1 + 0);
        ctemp02 = *(aoffset1 + 1);
        ctemp03 = *(aoffset1 + 2);
        ctemp04 = *(aoffset1 + 3);
        ctemp05 = *(aoffset1 + 4);
        ctemp06 = *(aoffset1 + 5);
        ctemp07 = *(aoffset1 + 6);
        ctemp08 = *(aoffset1 + 7);
        aoffset1 += 8;
        ctemp09 = *(aoffset2 + 0);
        ctemp10 = *(aoffset2 + 1);
        ctemp11 = *(aoffset2 + 2);
        ctemp12 = *(aoffset2 + 3);
        ctemp13 = *(aoffset2 + 4);
        ctemp14 = *(aoffset2 + 5);
        ctemp15 = *(aoffset2 + 6);
        ctemp16 = *(aoffset2 + 7);
        aoffset2 += 8;
        ctemp17 = *(aoffset3 + 0);
        ctemp18 = *(aoffset3 + 1);
        ctemp19 = *(aoffset3 + 2);
        ctemp20 = *(aoffset3 + 3);
        ctemp21 = *(aoffset3 + 4);
        ctemp22 = *(aoffset3 + 5);
        ctemp23 = *(aoffset3 + 6);
        ctemp24 = *(aoffset3 + 7);
        aoffset3 += 8;
        ctemp25 = *(aoffset4 + 0);
        ctemp26 = *(aoffset4 + 1);
        ctemp27 = *(aoffset4 + 2);
        ctemp28 = *(aoffset4 + 3);
        ctemp29 = *(aoffset4 + 4);
        ctemp30 = *(aoffset4 + 5);
        ctemp31 = *(aoffset4 + 6);
        ctemp32 = *(aoffset4 + 7);
        aoffset4 += 8;
        *(boffset1 + 0) = ctemp01;
        *(boffset1 + 1) = ctemp02;
        *(boffset1 + 2) = ctemp03;
        *(boffset1 + 3) = ctemp04;
        *(boffset1 + 4) = ctemp05;
        *(boffset1 + 5) = ctemp06;
        *(boffset1 + 6) = ctemp07;
        *(boffset1 + 7) = ctemp08;
        *(boffset1 + 8) = ctemp09;
        *(boffset1 + 9) = ctemp10;
        *(boffset1 + 10) = ctemp11;
        *(boffset1 + 11) = ctemp12;
        *(boffset1 + 12) = ctemp13;
        *(boffset1 + 13) = ctemp14;
        *(boffset1 + 14) = ctemp15;
        *(boffset1 + 15) = ctemp16;
        *(boffset1 + 16) = ctemp17;
        *(boffset1 + 17) = ctemp18;
        *(boffset1 + 18) = ctemp19;
        *(boffset1 + 19) = ctemp20;
        *(boffset1 + 20) = ctemp21;
        *(boffset1 + 21) = ctemp22;
        *(boffset1 + 22) = ctemp23;
        *(boffset1 + 23) = ctemp24;
        *(boffset1 + 24) = ctemp25;
        *(boffset1 + 25) = ctemp26;
        *(boffset1 + 26) = ctemp27;
        *(boffset1 + 27) = ctemp28;
        *(boffset1 + 28) = ctemp29;
        *(boffset1 + 29) = ctemp30;
        *(boffset1 + 30) = ctemp31;
        *(boffset1 + 31) = ctemp32;
        boffset1 += 8 * m;
        i--;
      } while (i > 0);
    }
    if (n & 4) {
      ctemp01 = *(aoffset1 + 0);
      ctemp02 = *(aoffset1 + 1);
      ctemp03 = *(aoffset1 + 2);
      ctemp04 = *(aoffset1 + 3);
      aoffset1 += 4;
      ctemp05 = *(aoffset2 + 0);
      ctemp06 = *(aoffset2 + 1);
      ctemp07 = *(aoffset2 + 2);
      ctemp08 = *(aoffset2 + 3);
      aoffset2 += 4;
      ctemp09 = *(aoffset3 + 0);
      ctemp10 = *(aoffset3 + 1);
      ctemp11 = *(aoffset3 + 2);
      ctemp12 = *(aoffset3 + 3);
      aoffset3 += 4;
      ctemp13 = *(aoffset4 + 0);
      ctemp14 = *(aoffset4 + 1);
      ctemp15 = *(aoffset4 + 2);
      ctemp16 = *(aoffset4 + 3);
      aoffset4 += 4;
      *(boffset2 + 0) = ctemp01;
      *(boffset2 + 1) = ctemp02;
      *(boffset2 + 2) = ctemp03;
      *(boffset2 + 3) = ctemp04;
      *(boffset2 + 4) = ctemp05;
      *(boffset2 + 5) = ctemp06;
      *(boffset2 + 6) = ctemp07;
      *(boffset2 + 7) = ctemp08;
      *(boffset2 + 8) = ctemp09;
      *(boffset2 + 9) = ctemp10;
      *(boffset2 + 10) = ctemp11;
      *(boffset2 + 11) = ctemp12;
      *(boffset2 + 12) = ctemp13;
      *(boffset2 + 13) = ctemp14;
      *(boffset2 + 14) = ctemp15;
      *(boffset2 + 15) = ctemp16;
      boffset2 += 16;
    }
    if (n & 2) {
      ctemp01 = *(aoffset1 + 0);
      ctemp02 = *(aoffset1 + 1);
      aoffset1 += 2;
      ctemp03 = *(aoffset2 + 0);
      ctemp04 = *(aoffset2 + 1);
      aoffset2 += 2;
      ctemp05 = *(aoffset3 + 0);
      ctemp06 = *(aoffset3 + 1);
      aoffset3 += 2;
      ctemp07 = *(aoffset4 + 0);
      ctemp08 = *(aoffset4 + 1);
      aoffset4 += 2;
      *(boffset3 + 0) = ctemp01;
      *(boffset3 + 1) = ctemp02;
      *(boffset3 + 2) = ctemp03;
      *(boffset3 + 3) = ctemp04;
      *(boffset3 + 4) = ctemp05;
      *(boffset3 + 5) = ctemp06;
      *(boffset3 + 6) = ctemp07;
      *(boffset3 + 7) = ctemp08;
      boffset3 += 8;
    }
    if (n & 1) {
      ctemp01 = *(aoffset1 + 0);
      aoffset1++;
      ctemp02 = *(aoffset2 + 0);
      aoffset2++;
      ctemp03 = *(aoffset3 + 0);
      aoffset3++;
      ctemp04 = *(aoffset4 + 0);
      aoffset4++;
      *(boffset4 + 0) = ctemp01;
      *(boffset4 + 1) = ctemp02;
      *(boffset4 + 2) = ctemp03;
      *(boffset4 + 3) = ctemp04;
      boffset4 += 4;
    }
  }
  if (m & 2) {
    aoffset1 = aoffset;
    aoffset2 = aoffset1 + lda;
    aoffset += 2 * lda;
    boffset1 = boffset;
    boffset += 16;
    i = (n >> 3);
    if (i > 0) {
      do {
        ctemp01 = *(aoffset1 + 0);
        ctemp02 = *(aoffset1 + 1);
        ctemp03 = *(aoffset1 + 2);
        ctemp04 = *(aoffset1 + 3);
        ctemp05 = *(aoffset1 + 4);
        ctemp06 = *(aoffset1 + 5);
        ctemp07 = *(aoffset1 + 6);
        ctemp08 = *(aoffset1 + 7);
        aoffset1 += 8;
        ctemp09 = *(aoffset2 + 0);
        ctemp10 = *(aoffset2 + 1);
        ctemp11 = *(aoffset2 + 2);
        ctemp12 = *(aoffset2 + 3);
        ctemp13 = *(aoffset2 + 4);
        ctemp14 = *(aoffset2 + 5);
        ctemp15 = *(aoffset2 + 6);
        ctemp16 = *(aoffset2 + 7);
        aoffset2 += 8;
        *(boffset1 + 0) = ctemp01;
        *(boffset1 + 1) = ctemp02;
        *(boffset1 + 2) = ctemp03;
        *(boffset1 + 3) = ctemp04;
        *(boffset1 + 4) = ctemp05;
        *(boffset1 + 5) = ctemp06;
        *(boffset1 + 6) = ctemp07;
        *(boffset1 + 7) = ctemp08;
        *(boffset1 + 8) = ctemp09;
        *(boffset1 + 9) = ctemp10;
        *(boffset1 + 10) = ctemp11;
        *(boffset1 + 11) = ctemp12;
        *(boffset1 + 12) = ctemp13;
        *(boffset1 + 13) = ctemp14;
        *(boffset1 + 14) = ctemp15;
        *(boffset1 + 15) = ctemp16;
        boffset1 += 8 * m;
        i--;
      } while (i > 0);
    }
    if (n & 4) {
      ctemp01 = *(aoffset1 + 0);
      ctemp02 = *(aoffset1 + 1);
      ctemp03 = *(aoffset1 + 2);
      ctemp04 = *(aoffset1 + 3);
      aoffset1 += 4;
      ctemp05 = *(aoffset2 + 0);
      ctemp06 = *(aoffset2 + 1);
      ctemp07 = *(aoffset2 + 2);
      ctemp08 = *(aoffset2 + 3);
      aoffset2 += 4;
      *(boffset2 + 0) = ctemp01;
      *(boffset2 + 1) = ctemp02;
      *(boffset2 + 2) = ctemp03;
      *(boffset2 + 3) = ctemp04;
      *(boffset2 + 4) = ctemp05;
      *(boffset2 + 5) = ctemp06;
      *(boffset2 + 6) = ctemp07;
      *(boffset2 + 7) = ctemp08;
      boffset2 += 8;
    }
    if (n & 2) {
      ctemp01 = *(aoffset1 + 0);
      ctemp02 = *(aoffset1 + 1);
      aoffset1 += 2;
      ctemp03 = *(aoffset2 + 0);
      ctemp04 = *(aoffset2 + 1);
      aoffset2 += 2;
      *(boffset3 + 0) = ctemp01;
      *(boffset3 + 1) = ctemp02;
      *(boffset3 + 2) = ctemp03;
      *(boffset3 + 3) = ctemp04;
      boffset3 += 4;
    }
    if (n & 1) {
      ctemp01 = *(aoffset1 + 0);
      aoffset1++;
      ctemp02 = *(aoffset2 + 0);
      aoffset2++;
      *(boffset4 + 0) = ctemp01;
      *(boffset4 + 1) = ctemp02;
      boffset4 += 2;
    }
  }
  if (m & 1) {
    aoffset1 = aoffset;
    aoffset += lda;
    boffset1 = boffset;
    boffset += 8;
    i = (n >> 3);
    if (i > 0) {
      do {
        ctemp01 = *(aoffset1 + 0);
        ctemp02 = *(aoffset1 + 1);
        ctemp03 = *(aoffset1 + 2);
        ctemp04 = *(aoffset1 + 3);
        ctemp05 = *(aoffset1 + 4);
        ctemp06 = *(aoffset1 + 5);
        ctemp07 = *(aoffset1 + 6);
        ctemp08 = *(aoffset1 + 7);
        aoffset1 += 8;
        *(boffset1 + 0) = ctemp01;
        *(boffset1 + 1) = ctemp02;
        *(boffset1 + 2) = ctemp03;
        *(boffset1 + 3) = ctemp04;
        *(boffset1 + 4) = ctemp05;
        *(boffset1 + 5) = ctemp06;
        *(boffset1 + 6) = ctemp07;
        *(boffset1 + 7) = ctemp08;
        boffset1 += 8 * m;
        i--;
      } while (i > 0);
    }
    if (n & 4) {
      ctemp01 = *(aoffset1 + 0);
      ctemp02 = *(aoffset1 + 1);
      ctemp03 = *(aoffset1 + 2);
      ctemp04 = *(aoffset1 + 3);
      aoffset1 += 4;
      *(boffset2 + 0) = ctemp01;
      *(boffset2 + 1) = ctemp02;
      *(boffset2 + 2) = ctemp03;
      *(boffset2 + 3) = ctemp04;
      boffset2 += 4;
    }
    if (n & 2) {
      ctemp01 = *(aoffset1 + 0);
      ctemp02 = *(aoffset1 + 1);
      aoffset1 += 2;
      *(boffset3 + 0) = ctemp01;
      *(boffset3 + 1) = ctemp02;
      boffset3 += 2;
    }
    if (n & 1) {
      ctemp01 = *(aoffset1 + 0);
      aoffset1++;
      *(boffset4 + 0) = ctemp01;
      boffset4++;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<tcopy_8>:
push   %rbp
mov    %rsp,%rbp
sub    $0x218,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    -0x8(%rbp),%edx
and    $0xfffffff8,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    -0x8(%rbp),%edx
and    $0xfffffffc,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    -0x8(%rbp),%edx
and    $0xfffffffe,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x4(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    25dd <tcopy_8+0x14dd>
jmp    11a7 <tcopy_8+0xa7>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rax
add    $0x200,%rax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    1c11 <tcopy_8+0xb11>
jmp    127a <tcopy_8+0x17a>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
mov    -0x38(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x40(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
mov    -0x50(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
mov    -0x58(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
mov    -0x60(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
mov    -0x60(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
mov    -0x60(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
mov    -0x60(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
mov    -0x60(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
mov    -0x60(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x60(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
mov    -0x60(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
mov    -0x68(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
mov    -0x68(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
mov    -0x68(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
mov    -0x68(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
mov    -0x68(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
mov    -0x68(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
mov    -0x68(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
mov    -0x68(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
mov    -0x70(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x268(%rbp)
ff
mov    -0x70(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
mov    -0x70(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
mov    -0x70(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
mov    -0x70(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
mov    -0x70(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
mov    -0x70(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x298(%rbp)
ff
mov    -0x70(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x70(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x58(%rax)
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x60(%rax)
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x68(%rax)
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x70(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x78(%rax)
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x80(%rax)
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x88(%rax)
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x90(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x98(%rax)
movsd  -0x140(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xa0(%rax)
movsd  -0x148(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xa8(%rax)
movsd  -0x150(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xb0(%rax)
movsd  -0x158(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xb8(%rax)
movsd  -0x160(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xc0(%rax)
movsd  -0x168(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xc8(%rax)
movsd  -0x170(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xd0(%rax)
movsd  -0x178(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xd8(%rax)
movsd  -0x180(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xe0(%rax)
movsd  -0x188(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xe8(%rax)
movsd  -0x190(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xf0(%rax)
movsd  -0x198(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xf8(%rax)
movsd  -0x1a0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x100(%rax)
movsd  -0x1a8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x108(%rax)
movsd  -0x1b0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x110(%rax)
movsd  -0x1b8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x118(%rax)
movsd  -0x1c0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x120(%rax)
movsd  -0x1c8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x128(%rax)
movsd  -0x1d0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x130(%rax)
movsd  -0x1d8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x138(%rax)
movsd  -0x1e0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x140(%rax)
movsd  -0x1e8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x148(%rax)
movsd  -0x1f0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x150(%rax)
movsd  -0x1f8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x158(%rax)
movsd  -0x200(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x160(%rax)
movsd  -0x208(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x168(%rax)
movsd  -0x210(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x170(%rax)
movsd  -0x218(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x178(%rax)
movsd  -0x220(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x180(%rax)
movsd  -0x228(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x188(%rax)
movsd  -0x230(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x190(%rax)
movsd  -0x238(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x198(%rax)
movsd  -0x240(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x1a0(%rax)
movsd  -0x248(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x1a8(%rax)
movsd  -0x250(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x1b0(%rax)
movsd  -0x258(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x1b8(%rax)
movsd  -0x260(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x1c0(%rax)
movsd  -0x268(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x1c8(%rax)
movsd  -0x270(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x1d0(%rax)
movsd  -0x278(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x1d8(%rax)
movsd  -0x280(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x1e0(%rax)
movsd  -0x288(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x1e8(%rax)
movsd  -0x290(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x1f0(%rax)
movsd  -0x298(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x1f8(%rax)
mov    -0x4(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jg     127a <tcopy_8+0x17a>
jmp    1c11 <tcopy_8+0xb11>
mov    -0x8(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     215b <tcopy_8+0x105b>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x40(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
mov    -0x48(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x50(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x58(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x60(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x60(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x60(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x60(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x68(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x68(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x68(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
mov    -0x68(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x70(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
mov    -0x70(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
mov    -0x70(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
mov    -0x70(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x70(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x58(%rax)
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x60(%rax)
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x68(%rax)
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x70(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x78(%rax)
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x80(%rax)
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x88(%rax)
movsd  -0x130(%rbp),%xmm0
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x90(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x98(%rax)
movsd  -0x140(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0xa0(%rax)
movsd  -0x148(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0xa8(%rax)
movsd  -0x150(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0xb0(%rax)
movsd  -0x158(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0xb8(%rax)
movsd  -0x160(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0xc0(%rax)
movsd  -0x168(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0xc8(%rax)
movsd  -0x170(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0xd0(%rax)
movsd  -0x178(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0xd8(%rax)
movsd  -0x180(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0xe0(%rax)
movsd  -0x188(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0xe8(%rax)
movsd  -0x190(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0xf0(%rax)
movsd  -0x198(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0xf8(%rax)
mov    -0x88(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     2425 <tcopy_8+0x1325>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x40(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
mov    -0x50(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x50(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x58(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x60(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x60(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x68(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x68(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x70(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x70(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x70(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x58(%rax)
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x60(%rax)
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x68(%rax)
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x70(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x78(%rax)
mov    -0x90(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     25c5 <tcopy_8+0x14c5>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x50(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x58(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x60(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x68(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x70(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x70(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x98(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jg     11a7 <tcopy_8+0xa7>
jmp    25dd <tcopy_8+0x14dd>
mov    -0x4(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     3035 <tcopy_8+0x1f35>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    2b3e <tcopy_8+0x1a3e>
jmp    2673 <tcopy_8+0x1573>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x40(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
mov    -0x50(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x50(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x58(%rax)
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x60(%rax)
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x68(%rax)
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x70(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x78(%rax)
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x80(%rax)
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x88(%rax)
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x90(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x98(%rax)
movsd  -0x140(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xa0(%rax)
movsd  -0x148(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xa8(%rax)
movsd  -0x150(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xb0(%rax)
movsd  -0x158(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xb8(%rax)
movsd  -0x160(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xc0(%rax)
movsd  -0x168(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xc8(%rax)
movsd  -0x170(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xd0(%rax)
movsd  -0x178(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xd8(%rax)
movsd  -0x180(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xe0(%rax)
movsd  -0x188(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xe8(%rax)
movsd  -0x190(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xf0(%rax)
movsd  -0x198(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0xf8(%rax)
mov    -0x4(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jg     2673 <tcopy_8+0x1573>
jmp    2b3e <tcopy_8+0x1a3e>
mov    -0x8(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     2ddc <tcopy_8+0x1cdc>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x40(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x50(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x50(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x58(%rax)
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x60(%rax)
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x68(%rax)
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x70(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x78(%rax)
mov    -0x88(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     2f50 <tcopy_8+0x1e50>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x40(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x50(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x50(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x50(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x90(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     3030 <tcopy_8+0x1f30>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x50(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x98(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x98(%rbp)
jmp    3035 <tcopy_8+0x1f35>
mov    -0x4(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     35b7 <tcopy_8+0x24b7>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    330a <tcopy_8+0x220a>
jmp    30a5 <tcopy_8+0x1fa5>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x40(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x40(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x58(%rax)
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x60(%rax)
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x68(%rax)
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x70(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x78(%rax)
mov    -0x4(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jg     30a5 <tcopy_8+0x1fa5>
jmp    330a <tcopy_8+0x220a>
mov    -0x8(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     3468 <tcopy_8+0x2368>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x40(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x40(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x88(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     3532 <tcopy_8+0x2432>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x40(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x40(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x90(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     35b2 <tcopy_8+0x24b2>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x98(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x98(%rbp)
jmp    35b7 <tcopy_8+0x24b7>
mov    -0x4(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     38e2 <tcopy_8+0x27e2>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    3759 <tcopy_8+0x2659>
jmp    360f <tcopy_8+0x250f>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x38(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x4(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jg     360f <tcopy_8+0x250f>
jmp    3759 <tcopy_8+0x2659>
mov    -0x8(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     3818 <tcopy_8+0x2718>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x38(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x88(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     388d <tcopy_8+0x278d>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x38(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x90(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     38dd <tcopy_8+0x27dd>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x98(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x98(%rbp)
jmp    38e2 <tcopy_8+0x27e2>
xor    %eax,%eax
add    $0x218,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tcopy_8>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %esi,%eax
and    $0xfffffff8,%eax
imul   %edi,%eax
cltq
lea    (%r8,%rax,8),%rax
mov    %rax,-0x78(%rsp)
mov    %esi,%eax
and    $0xfffffffc,%eax
imul   %edi,%eax
cltq
lea    (%r8,%rax,8),%rax
mov    %rax,-0x70(%rsp)
mov    %esi,%eax
and    $0xfffffffe,%eax
imul   %edi,%eax
cltq
lea    (%r8,%rax,8),%r9
mov    %rcx,-0x60(%rsp)
movslq %ecx,%r14
cmp    $0x8,%edi
mov    %esi,-0x7c(%rsp)
mov    %rdi,-0x40(%rsp)
jl     16e5 <tcopy_8+0x5e5>
mov    %edi,%ebp
shr    $0x3,%ebp
lea    0x0(,%r14,8),%ecx
movslq %ecx,%rax
mov    %rax,-0x8(%rsp)
mov    %esi,%eax
sar    $0x3,%eax
lea    0x0(,%rdi,8),%ecx
movslq %ecx,%rbx
lea    0x1f0(%r8),%r12
shl    $0x3,%rbx
imul   $0x38,%r14,%rcx
mov    %rcx,-0x10(%rsp)
mov    %r14,%rcx
shl    $0x4,%rcx
mov    %rcx,-0x18(%rsp)
lea    (%rcx,%rcx,2),%rcx
mov    %rcx,-0x20(%rsp)
lea    0x0(,%r14,8),%rdi
lea    (%rdi,%rdi,4),%rcx
mov    %rcx,-0x28(%rsp)
mov    %r14,%rcx
shl    $0x5,%rcx
mov    %rcx,-0x30(%rsp)
lea    (%rdi,%rdi,2),%rcx
mov    %rcx,-0x38(%rsp)
add    $0x1,%eax
mov    %eax,-0x64(%rsp)
jmp    126d <tcopy_8+0x16d>
xchg   %ax,%ax
movsd  (%rdx),%xmm0
movsd  (%r11),%xmm1
movsd  (%r10),%xmm2
movsd  (%rax),%xmm3
movsd  (%r9),%xmm4
movsd  (%r15),%xmm5
movsd  0x0(%r13),%xmm6
movsd  (%rcx),%xmm7
mov    -0x48(%rsp),%r9
movsd  %xmm0,(%r9)
movsd  %xmm1,0x8(%r9)
movsd  %xmm2,0x10(%r9)
movsd  %xmm3,0x18(%r9)
movsd  %xmm4,0x20(%r9)
movsd  %xmm5,0x28(%r9)
movsd  %xmm6,0x30(%r9)
movsd  %xmm7,0x38(%r9)
add    $0x40,%r9
mov    -0x50(%rsp),%rdx
mov    -0x58(%rsp),%rcx
add    $0x200,%r8
mov    -0x8(%rsp),%rax
lea    (%rdx,%rax,8),%rdx
lea    -0x1(%rcx),%eax
add    $0x200,%r12
cmp    $0x1,%ecx
mov    %eax,%ebp
jle    16e5 <tcopy_8+0x5e5>
cmp    $0x8,%esi
mov    %r9,-0x48(%rsp)
mov    %rdx,-0x50(%rsp)
mov    %rbp,-0x58(%rsp)
jl     1540 <tcopy_8+0x440>
mov    -0x64(%rsp),%ecx
mov    %r12,%rsi
nopl   0x0(%rax)
lea    (%rdx,%rdi,1),%rbp
lea    (%rdi,%rbp,1),%rax
movups (%rdi,%rbp,1),%xmm0
movaps %xmm0,0xf0(%rsp)
movups 0x10(%rdi,%rbp,1),%xmm0
movaps %xmm0,0xe0(%rsp)
movups 0x20(%rdi,%rbp,1),%xmm0
movaps %xmm0,0xd0(%rsp)
movups 0x30(%rdi,%rbp,1),%xmm0
movaps %xmm0,0xc0(%rsp)
lea    (%rax,%rdi,1),%rbp
movups (%rdi,%rax,1),%xmm0
movaps %xmm0,0xb0(%rsp)
movups 0x10(%rdi,%rax,1),%xmm0
movaps %xmm0,0xa0(%rsp)
movups 0x20(%rdi,%rax,1),%xmm0
movaps %xmm0,0x90(%rsp)
movups 0x30(%rdi,%rax,1),%xmm0
movaps %xmm0,0x80(%rsp)
lea    0x0(%rbp,%rdi,1),%rax
movups (%rdi,%rbp,1),%xmm0
movaps %xmm0,0x70(%rsp)
movups 0x10(%rdi,%rbp,1),%xmm0
movaps %xmm0,0x60(%rsp)
movups 0x20(%rdi,%rbp,1),%xmm0
movaps %xmm0,0x50(%rsp)
movups 0x30(%rdi,%rbp,1),%xmm0
movaps %xmm0,0x40(%rsp)
lea    (%rax,%rdi,1),%rbp
movups (%rdi,%rax,1),%xmm0
movaps %xmm0,0x30(%rsp)
movups 0x10(%rdi,%rax,1),%xmm0
movaps %xmm0,0x20(%rsp)
movups 0x20(%rdi,%rax,1),%xmm0
movaps %xmm0,0x10(%rsp)
movups 0x30(%rdi,%rax,1),%xmm0
movaps %xmm0,(%rsp)
lea    0x0(%rbp,%rdi,1),%rax
movups (%rdx),%xmm0
movups 0x10(%rdx),%xmm1
movups 0x20(%rdx),%xmm2
movups 0x30(%rdx),%xmm3
movups (%rdx,%rdi,1),%xmm4
movups 0x10(%rdx,%rdi,1),%xmm5
movups 0x20(%rdx,%rdi,1),%xmm6
movups 0x30(%rdx,%rdi,1),%xmm7
movups (%rdi,%rbp,1),%xmm8
movups 0x10(%rdi,%rbp,1),%xmm9
movups 0x20(%rdi,%rbp,1),%xmm10
movups 0x30(%rdi,%rbp,1),%xmm11
movups (%rdi,%rax,1),%xmm12
movups 0x10(%rdi,%rax,1),%xmm13
movups 0x20(%rdi,%rax,1),%xmm14
movups 0x30(%rdi,%rax,1),%xmm15
movups %xmm0,-0x1f0(%rsi)
movups %xmm1,-0x1e0(%rsi)
movups %xmm2,-0x1d0(%rsi)
movups %xmm3,-0x1c0(%rsi)
movups %xmm4,-0x1b0(%rsi)
movups %xmm5,-0x1a0(%rsi)
movups %xmm6,-0x190(%rsi)
movups %xmm7,-0x180(%rsi)
movaps 0xf0(%rsp),%xmm0
movups %xmm0,-0x170(%rsi)
movaps 0xe0(%rsp),%xmm0
movups %xmm0,-0x160(%rsi)
movaps 0xd0(%rsp),%xmm0
movups %xmm0,-0x150(%rsi)
movaps 0xc0(%rsp),%xmm0
movups %xmm0,-0x140(%rsi)
movaps 0xb0(%rsp),%xmm0
movups %xmm0,-0x130(%rsi)
movaps 0xa0(%rsp),%xmm0
movups %xmm0,-0x120(%rsi)
movaps 0x90(%rsp),%xmm0
movups %xmm0,-0x110(%rsi)
movaps 0x80(%rsp),%xmm0
movups %xmm0,-0x100(%rsi)
movaps 0x70(%rsp),%xmm0
movups %xmm0,-0xf0(%rsi)
movaps 0x60(%rsp),%xmm0
movups %xmm0,-0xe0(%rsi)
movaps 0x50(%rsp),%xmm0
movups %xmm0,-0xd0(%rsi)
movaps 0x40(%rsp),%xmm0
movups %xmm0,-0xc0(%rsi)
movaps 0x30(%rsp),%xmm0
movups %xmm0,-0xb0(%rsi)
movaps 0x20(%rsp),%xmm0
movups %xmm0,-0xa0(%rsi)
movaps 0x10(%rsp),%xmm0
movups %xmm0,-0x90(%rsi)
movaps (%rsp),%xmm0
movups %xmm0,-0x80(%rsi)
movups %xmm8,-0x70(%rsi)
movups %xmm9,-0x60(%rsi)
movups %xmm10,-0x50(%rsi)
movups %xmm11,-0x40(%rsi)
movups %xmm12,-0x30(%rsi)
movups %xmm13,-0x20(%rsi)
movups %xmm14,-0x10(%rsi)
movups %xmm15,(%rsi)
add    $0x40,%rdx
add    %rbx,%rsi
add    $0xffffffff,%ecx
cmp    $0x1,%ecx
jg     1290 <tcopy_8+0x190>
mov    -0x10(%rsp),%rax
lea    (%rdx,%rax,1),%rcx
mov    -0x20(%rsp),%rax
lea    (%rdx,%rax,1),%r13
mov    -0x28(%rsp),%rax
lea    (%rdx,%rax,1),%r15
mov    -0x30(%rsp),%rax
lea    (%rdx,%rax,1),%r9
mov    -0x38(%rsp),%rax
add    %rdx,%rax
mov    -0x18(%rsp),%rsi
lea    (%rdx,%rsi,1),%r10
lea    (%rdx,%rdi,1),%r11
mov    -0x7c(%rsp),%esi
test   $0x4,%sil
jne    156d <tcopy_8+0x46d>
jmp    1645 <tcopy_8+0x545>
nopl   0x0(%rax,%rax,1)
lea    (%rdx,%r14,8),%r11
lea    (%r11,%r14,8),%r10
lea    (%r10,%r14,8),%rax
lea    (%rax,%r14,8),%r9
lea    (%r9,%r14,8),%r15
lea    (%r15,%r14,8),%r13
lea    0x0(,%r14,8),%rcx
add    %r13,%rcx
test   $0x4,%sil
je     1645 <tcopy_8+0x545>
movups (%rdx),%xmm8
movups 0x10(%rdx),%xmm9
add    $0x20,%rdx
movups (%r11),%xmm10
movups 0x10(%r11),%xmm11
add    $0x20,%r11
movups (%r10),%xmm12
movups 0x10(%r10),%xmm13
add    $0x20,%r10
movups (%rax),%xmm14
movups 0x10(%rax),%xmm15
add    $0x20,%rax
movups (%r9),%xmm0
movups 0x10(%r9),%xmm1
add    $0x20,%r9
movups (%r15),%xmm2
movups 0x10(%r15),%xmm3
add    $0x20,%r15
movups 0x0(%r13),%xmm4
movups 0x10(%r13),%xmm5
add    $0x20,%r13
movups (%rcx),%xmm6
movups 0x10(%rcx),%xmm7
add    $0x20,%rcx
mov    -0x78(%rsp),%rbp
movups %xmm8,0x0(%rbp)
movups %xmm9,0x10(%rbp)
movups %xmm10,0x20(%rbp)
movups %xmm11,0x30(%rbp)
movups %xmm12,0x40(%rbp)
movups %xmm13,0x50(%rbp)
movups %xmm14,0x60(%rbp)
movups %xmm15,0x70(%rbp)
movups %xmm0,0x80(%rbp)
movups %xmm1,0x90(%rbp)
movups %xmm2,0xa0(%rbp)
movups %xmm3,0xb0(%rbp)
movups %xmm4,0xc0(%rbp)
movups %xmm5,0xd0(%rbp)
movups %xmm6,0xe0(%rbp)
movups %xmm7,0xf0(%rbp)
add    $0x100,%rbp
mov    %rbp,-0x78(%rsp)
test   $0x2,%sil
jne    1660 <tcopy_8+0x560>
test   $0x1,%sil
jne    11e0 <tcopy_8+0xe0>
jmp    16d6 <tcopy_8+0x5d6>
nopw   0x0(%rax,%rax,1)
movups (%rdx),%xmm0
add    $0x10,%rdx
movups (%r11),%xmm1
add    $0x10,%r11
movups (%r10),%xmm2
add    $0x10,%r10
movups (%rax),%xmm3
add    $0x10,%rax
movups (%r9),%xmm4
add    $0x10,%r9
movups (%r15),%xmm5
add    $0x10,%r15
movups 0x0(%r13),%xmm6
add    $0x10,%r13
movups (%rcx),%xmm7
add    $0x10,%rcx
mov    -0x70(%rsp),%rbp
movups %xmm0,0x0(%rbp)
movups %xmm1,0x10(%rbp)
movups %xmm2,0x20(%rbp)
movups %xmm3,0x30(%rbp)
movups %xmm4,0x40(%rbp)
movups %xmm5,0x50(%rbp)
movups %xmm6,0x60(%rbp)
movups %xmm7,0x70(%rbp)
sub    $0xffffffffffffff80,%rbp
mov    %rbp,-0x70(%rsp)
test   $0x1,%sil
jne    11e0 <tcopy_8+0xe0>
mov    -0x50(%rsp),%rdx
mov    -0x48(%rsp),%r9
jmp    1243 <tcopy_8+0x143>
mov    -0x40(%rsp),%r15
test   $0x4,%r15b
jne    170e <tcopy_8+0x60e>
mov    -0x70(%rsp),%rbx
mov    -0x78(%rsp),%r10
mov    -0x60(%rsp),%r12
test   $0x2,%r15b
jne    1944 <tcopy_8+0x844>
jmp    1a67 <tcopy_8+0x967>
cmp    $0x8,%esi
mov    -0x60(%rsp),%r12
jl     183c <tcopy_8+0x73c>
mov    %rdx,%rcx
mov    %esi,%edx
shr    $0x3,%edx
lea    0x0(,%r15,8),%eax
movslq %eax,%rsi
lea    0xf0(%r8),%rdi
shl    $0x3,%rsi
add    $0x1,%edx
lea    0x0(,%r14,8),%rbp
mov    %rcx,%r11
mov    -0x78(%rsp),%r10
nopl   (%rax)
movups (%rcx),%xmm8
movups 0x10(%rcx),%xmm9
movups 0x20(%rcx),%xmm10
movups 0x30(%rcx),%xmm11
lea    (%rcx,%rbp,1),%rax
movups (%rcx,%r14,8),%xmm12
movups 0x10(%rcx,%r14,8),%xmm13
movups 0x20(%rcx,%r14,8),%xmm14
movups 0x30(%rcx,%r14,8),%xmm15
add    $0x40,%rcx
lea    (%rax,%rbp,1),%rbx
movups (%rax,%r14,8),%xmm0
movups 0x10(%rax,%r14,8),%xmm1
movups 0x20(%rax,%r14,8),%xmm2
movups 0x30(%rax,%r14,8),%xmm3
movups (%rbx,%r14,8),%xmm4
movups 0x10(%rbx,%r14,8),%xmm5
movups 0x20(%rbx,%r14,8),%xmm6
movups 0x30(%rbx,%r14,8),%xmm7
movups %xmm8,-0xf0(%rdi)
ff
movups %xmm9,-0xe0(%rdi)
ff
movups %xmm10,-0xd0(%rdi)
ff
movups %xmm11,-0xc0(%rdi)
ff
movups %xmm12,-0xb0(%rdi)
ff
movups %xmm13,-0xa0(%rdi)
ff
movups %xmm14,-0x90(%rdi)
ff
movups %xmm15,-0x80(%rdi)
movups %xmm0,-0x70(%rdi)
movups %xmm1,-0x60(%rdi)
movups %xmm2,-0x50(%rdi)
movups %xmm3,-0x40(%rdi)
movups %xmm4,-0x30(%rdi)
movups %xmm5,-0x20(%rdi)
movups %xmm6,-0x10(%rdi)
movups %xmm7,(%rdi)
add    %rsi,%rdi
add    $0xffffffff,%edx
cmp    $0x1,%edx
ja     1750 <tcopy_8+0x650>
lea    (%r14,%r14,2),%rax
lea    (%rcx,%rax,8),%rdx
mov    %r14,%rax
shl    $0x4,%rax
add    %rcx,%rax
lea    (%rcx,%r14,8),%rdi
mov    -0x70(%rsp),%rbx
jmp    1858 <tcopy_8+0x758>
lea    (%rdx,%r14,8),%rdi
lea    (%rdi,%r14,8),%rax
mov    %rdx,%rcx
lea    (%rax,%r14,8),%rdx
mov    %rcx,%r11
mov    -0x70(%rsp),%rbx
mov    -0x78(%rsp),%r10
lea    0x0(,%r12,4),%ebp
testb  $0x4,-0x7c(%rsp)
je     18be <tcopy_8+0x7be>
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
add    $0x20,%rcx
movups (%rdi),%xmm2
movups 0x10(%rdi),%xmm3
add    $0x20,%rdi
movups (%rax),%xmm4
movups 0x10(%rax),%xmm5
add    $0x20,%rax
movups (%rdx),%xmm6
movups 0x10(%rdx),%xmm7
add    $0x20,%rdx
movups %xmm0,(%r10)
movups %xmm1,0x10(%r10)
movups %xmm2,0x20(%r10)
movups %xmm3,0x30(%r10)
movups %xmm4,0x40(%r10)
movups %xmm5,0x50(%r10)
movups %xmm6,0x60(%r10)
movups %xmm7,0x70(%r10)
sub    $0xffffffffffffff80,%r10
movslq %ebp,%rbp
testb  $0x2,-0x7c(%rsp)
je     18f7 <tcopy_8+0x7f7>
movups (%rcx),%xmm0
add    $0x10,%rcx
movups (%rdi),%xmm1
add    $0x10,%rdi
movups (%rax),%xmm2
add    $0x10,%rax
movups (%rdx),%xmm3
add    $0x10,%rdx
movups %xmm0,(%rbx)
movups %xmm1,0x10(%rbx)
movups %xmm2,0x20(%rbx)
movups %xmm3,0x30(%rbx)
add    $0x40,%rbx
lea    (%r11,%rbp,8),%r11
add    $0x100,%r8
mov    -0x7c(%rsp),%esi
test   $0x1,%sil
je     1937 <tcopy_8+0x837>
movsd  (%rcx),%xmm0
movsd  (%rdi),%xmm1
movsd  (%rax),%xmm2
movsd  (%rdx),%xmm3
movsd  %xmm0,(%r9)
movsd  %xmm1,0x8(%r9)
movsd  %xmm2,0x10(%r9)
movsd  %xmm3,0x18(%r9)
add    $0x20,%r9
mov    %r11,%rdx
test   $0x2,%r15b
je     1a67 <tcopy_8+0x967>
cmp    $0x8,%esi
mov    %esi,%eax
mov    %rdx,%rbp
jl     19da <tcopy_8+0x8da>
mov    %rdx,%rcx
mov    %eax,%esi
mov    %eax,%edx
shr    $0x3,%edx
lea    0x0(,%r15,8),%eax
cltq
lea    0x70(%r8),%rdi
shl    $0x3,%rax
add    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups (%rcx,%r14,8),%xmm4
movups 0x10(%rcx,%r14,8),%xmm5
movups 0x20(%rcx,%r14,8),%xmm6
movups 0x30(%rcx,%r14,8),%xmm7
add    $0x40,%rcx
movups %xmm0,-0x70(%rdi)
movups %xmm1,-0x60(%rdi)
movups %xmm2,-0x50(%rdi)
movups %xmm3,-0x40(%rdi)
movups %xmm4,-0x30(%rdi)
movups %xmm5,-0x20(%rdi)
movups %xmm6,-0x10(%rdi)
movups %xmm7,(%rdi)
add    %rax,%rdi
add    $0xffffffff,%edx
cmp    $0x1,%edx
ja     1980 <tcopy_8+0x880>
lea    (%rcx,%r14,8),%rax
jmp    19e3 <tcopy_8+0x8e3>
mov    %eax,%esi
lea    (%rdx,%r14,8),%rax
mov    %rdx,%rcx
add    %r12d,%r12d
test   $0x4,%sil
je     1a19 <tcopy_8+0x919>
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
add    $0x20,%rcx
movups (%rax),%xmm2
movups 0x10(%rax),%xmm3
add    $0x20,%rax
movups %xmm0,(%r10)
movups %xmm1,0x10(%r10)
movups %xmm2,0x20(%r10)
movups %xmm3,0x30(%r10)
add    $0x40,%r10
movslq %r12d,%rdx
test   $0x2,%sil
je     1a3b <tcopy_8+0x93b>
movups (%rcx),%xmm0
add    $0x10,%rcx
movups (%rax),%xmm1
add    $0x10,%rax
movups %xmm0,(%rbx)
movups %xmm1,0x10(%rbx)
add    $0x20,%rbx
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
sub    $0xffffffffffffff80,%r8
test   $0x1,%sil
je     1a67 <tcopy_8+0x967>
movsd  (%rcx),%xmm0
movsd  (%rax),%xmm1
movsd  %xmm0,(%r9)
movsd  %xmm1,0x8(%r9)
add    $0x10,%r9
test   $0x1,%r15b
je     1adc <tcopy_8+0x9dc>
cmp    $0x8,%esi
jl     1ac1 <tcopy_8+0x9c1>
mov    %esi,%eax
shr    $0x3,%eax
shl    $0x3,%r15d
movslq %r15d,%rcx
add    $0x30,%r8
shl    $0x3,%rcx
add    $0x1,%eax
nopl   0x0(%rax)
movups (%rdx),%xmm0
movups 0x10(%rdx),%xmm1
movups 0x20(%rdx),%xmm2
movups 0x30(%rdx),%xmm3
add    $0x40,%rdx
movups %xmm0,-0x30(%r8)
movups %xmm1,-0x20(%r8)
movups %xmm2,-0x10(%r8)
movups %xmm3,(%r8)
add    %rcx,%r8
add    $0xffffffff,%eax
cmp    $0x1,%eax
ja     1a90 <tcopy_8+0x990>
test   $0x4,%sil
jne    1af0 <tcopy_8+0x9f0>
test   $0x2,%sil
jne    1b0a <tcopy_8+0xa0a>
test   $0x1,%sil
je     1adc <tcopy_8+0x9dc>
movsd  (%rdx),%xmm0
movsd  %xmm0,(%r9)
xor    %eax,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movups (%rdx),%xmm0
movups 0x10(%rdx),%xmm1
add    $0x20,%rdx
movups %xmm0,(%r10)
movups %xmm1,0x10(%r10)
test   $0x2,%sil
je     1acd <tcopy_8+0x9cd>
movups (%rdx),%xmm0
add    $0x10,%rdx
movups %xmm0,(%rbx)
test   $0x1,%sil
jne    1ad3 <tcopy_8+0x9d3>
jmp    1adc <tcopy_8+0x9dc>

LLVM IR (-O0):
define i32 @tcopy_8(i32 %0, i32 %1, double* %2, i32 %3, double* %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca double*
%9 = alloca i32
%10 = alloca double*
%11 = alloca i32
%12 = alloca i32
%13 = alloca double*
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca double*
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca double
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca double
%44 = alloca double
%45 = alloca double
%46 = alloca double
%47 = alloca double
%48 = alloca double
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca double
%56 = alloca double
%57 = alloca double
%58 = alloca double
%59 = alloca double
%60 = alloca double
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca double
%65 = alloca double
%66 = alloca double
%67 = alloca double
%68 = alloca double
%69 = alloca double
%70 = alloca double
%71 = alloca double
%72 = alloca double
%73 = alloca double
%74 = alloca double
%75 = alloca double
%76 = alloca double
%77 = alloca double
%78 = alloca double
%79 = alloca double
%80 = alloca double
%81 = alloca double
%82 = alloca double
%83 = alloca double
%84 = alloca double
%85 = alloca double
%86 = alloca double
%87 = alloca double
%88 = alloca double
%89 = alloca double
%90 = alloca double
store i32 %0, i32* %6
store i32 %1, i32* %7
store double* %2, double** %8
store i32 %3, i32* %9
store double* %4, double** %10
%91 = load double*, double** %8
store double* %91, double** %13
%92 = load double*, double** %10
store double* %92, double** %22
%93 = load double*, double** %10
%94 = load i32, i32* %6
%95 = load i32, i32* %7
%96 = and i32 %95, -8
%97 = mul nsw i32 %94, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %93, i64 %98
store double* %99, double** %24
%100 = load double*, double** %10
%101 = load i32, i32* %6
%102 = load i32, i32* %7
%103 = and i32 %102, -4
%104 = mul nsw i32 %101, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double, double* %100, i64 %105
store double* %106, double** %25
%107 = load double*, double** %10
%108 = load i32, i32* %6
%109 = load i32, i32* %7
%110 = and i32 %109, -2
%111 = mul nsw i32 %108, %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %107, i64 %112
store double* %113, double** %26
%114 = load i32, i32* %6
%115 = ashr i32 %114, 3
store i32 %115, i32* %12
%116 = load i32, i32* %12
%117 = icmp sgt i32 %116, 0
br i1 %117, label %118, label %986
118: ; preds = %5
br label %119
119: ; preds = %982, %118
%120 = load double*, double** %13
store double* %120, double** %14
%121 = load double*, double** %14
%122 = load i32, i32* %9
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %121, i64 %123
store double* %124, double** %15
%125 = load double*, double** %15
%126 = load i32, i32* %9
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds double, double* %125, i64 %127
store double* %128, double** %16
%129 = load double*, double** %16
%130 = load i32, i32* %9
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds double, double* %129, i64 %131
store double* %132, double** %17
%133 = load double*, double** %17
%134 = load i32, i32* %9
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %133, i64 %135
store double* %136, double** %18
%137 = load double*, double** %18
%138 = load i32, i32* %9
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds double, double* %137, i64 %139
store double* %140, double** %19
%141 = load double*, double** %19
%142 = load i32, i32* %9
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %141, i64 %143
store double* %144, double** %20
%145 = load double*, double** %20
%146 = load i32, i32* %9
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds double, double* %145, i64 %147
store double* %148, double** %21
%149 = load i32, i32* %9
%150 = mul nsw i32 8, %149
%151 = load double*, double** %13
%152 = sext i32 %150 to i64
%153 = getelementptr inbounds double, double* %151, i64 %152
store double* %153, double** %13
%154 = load double*, double** %22
store double* %154, double** %23
%155 = load double*, double** %22
%156 = getelementptr inbounds double, double* %155, i64 64
store double* %156, double** %22
%157 = load i32, i32* %7
%158 = ashr i32 %157, 3
store i32 %158, i32* %11
%159 = load i32, i32* %11
%160 = icmp sgt i32 %159, 0
br i1 %160, label %161, label %574
161: ; preds = %119
br label %162
162: ; preds = %570, %161
%163 = load double*, double** %14
%164 = getelementptr inbounds double, double* %163, i64 0
%165 = load double, double* %164
store double %165, double* %27
%166 = load double*, double** %14
%167 = getelementptr inbounds double, double* %166, i64 1
%168 = load double, double* %167
store double %168, double* %28
%169 = load double*, double** %14
%170 = getelementptr inbounds double, double* %169, i64 2
%171 = load double, double* %170
store double %171, double* %29
%172 = load double*, double** %14
%173 = getelementptr inbounds double, double* %172, i64 3
%174 = load double, double* %173
store double %174, double* %30
%175 = load double*, double** %14
%176 = getelementptr inbounds double, double* %175, i64 4
%177 = load double, double* %176
store double %177, double* %31
%178 = load double*, double** %14
%179 = getelementptr inbounds double, double* %178, i64 5
%180 = load double, double* %179
store double %180, double* %32
%181 = load double*, double** %14
%182 = getelementptr inbounds double, double* %181, i64 6
%183 = load double, double* %182
store double %183, double* %33
%184 = load double*, double** %14
%185 = getelementptr inbounds double, double* %184, i64 7
%186 = load double, double* %185
store double %186, double* %34
%187 = load double*, double** %14
%188 = getelementptr inbounds double, double* %187, i64 8
store double* %188, double** %14
%189 = load double*, double** %15
%190 = getelementptr inbounds double, double* %189, i64 0
%191 = load double, double* %190
store double %191, double* %35
%192 = load double*, double** %15
%193 = getelementptr inbounds double, double* %192, i64 1
%194 = load double, double* %193
store double %194, double* %36
%195 = load double*, double** %15
%196 = getelementptr inbounds double, double* %195, i64 2
%197 = load double, double* %196
store double %197, double* %37
%198 = load double*, double** %15
%199 = getelementptr inbounds double, double* %198, i64 3
%200 = load double, double* %199
store double %200, double* %38
%201 = load double*, double** %15
%202 = getelementptr inbounds double, double* %201, i64 4
%203 = load double, double* %202
store double %203, double* %39
%204 = load double*, double** %15
%205 = getelementptr inbounds double, double* %204, i64 5
%206 = load double, double* %205
store double %206, double* %40
%207 = load double*, double** %15
%208 = getelementptr inbounds double, double* %207, i64 6
%209 = load double, double* %208
store double %209, double* %41
%210 = load double*, double** %15
%211 = getelementptr inbounds double, double* %210, i64 7
%212 = load double, double* %211
store double %212, double* %42
%213 = load double*, double** %15
%214 = getelementptr inbounds double, double* %213, i64 8
store double* %214, double** %15
%215 = load double*, double** %16
%216 = getelementptr inbounds double, double* %215, i64 0
%217 = load double, double* %216
store double %217, double* %43
%218 = load double*, double** %16
%219 = getelementptr inbounds double, double* %218, i64 1
%220 = load double, double* %219
store double %220, double* %44
%221 = load double*, double** %16
%222 = getelementptr inbounds double, double* %221, i64 2
%223 = load double, double* %222
store double %223, double* %45
%224 = load double*, double** %16
%225 = getelementptr inbounds double, double* %224, i64 3
%226 = load double, double* %225
store double %226, double* %46
%227 = load double*, double** %16
%228 = getelementptr inbounds double, double* %227, i64 4
%229 = load double, double* %228
store double %229, double* %47
%230 = load double*, double** %16
%231 = getelementptr inbounds double, double* %230, i64 5
%232 = load double, double* %231
store double %232, double* %48
%233 = load double*, double** %16
%234 = getelementptr inbounds double, double* %233, i64 6
%235 = load double, double* %234
store double %235, double* %49
%236 = load double*, double** %16
%237 = getelementptr inbounds double, double* %236, i64 7
%238 = load double, double* %237
store double %238, double* %50
%239 = load double*, double** %16
%240 = getelementptr inbounds double, double* %239, i64 8
store double* %240, double** %16
%241 = load double*, double** %17
%242 = getelementptr inbounds double, double* %241, i64 0
%243 = load double, double* %242
store double %243, double* %51
%244 = load double*, double** %17
%245 = getelementptr inbounds double, double* %244, i64 1
%246 = load double, double* %245
store double %246, double* %52
%247 = load double*, double** %17
%248 = getelementptr inbounds double, double* %247, i64 2
%249 = load double, double* %248
store double %249, double* %53
%250 = load double*, double** %17
%251 = getelementptr inbounds double, double* %250, i64 3
%252 = load double, double* %251
store double %252, double* %54
%253 = load double*, double** %17
%254 = getelementptr inbounds double, double* %253, i64 4
%255 = load double, double* %254
store double %255, double* %55
%256 = load double*, double** %17
%257 = getelementptr inbounds double, double* %256, i64 5
%258 = load double, double* %257
store double %258, double* %56
%259 = load double*, double** %17
%260 = getelementptr inbounds double, double* %259, i64 6
%261 = load double, double* %260
store double %261, double* %57
%262 = load double*, double** %17
%263 = getelementptr inbounds double, double* %262, i64 7
%264 = load double, double* %263
store double %264, double* %58
%265 = load double*, double** %17
%266 = getelementptr inbounds double, double* %265, i64 8
store double* %266, double** %17
%267 = load double*, double** %18
%268 = getelementptr inbounds double, double* %267, i64 0
%269 = load double, double* %268
store double %269, double* %59
%270 = load double*, double** %18
%271 = getelementptr inbounds double, double* %270, i64 1
%272 = load double, double* %271
store double %272, double* %60
%273 = load double*, double** %18
%274 = getelementptr inbounds double, double* %273, i64 2
%275 = load double, double* %274
store double %275, double* %61
%276 = load double*, double** %18
%277 = getelementptr inbounds double, double* %276, i64 3
%278 = load double, double* %277
store double %278, double* %62
%279 = load double*, double** %18
%280 = getelementptr inbounds double, double* %279, i64 4
%281 = load double, double* %280
store double %281, double* %63
%282 = load double*, double** %18
%283 = getelementptr inbounds double, double* %282, i64 5
%284 = load double, double* %283
store double %284, double* %64
%285 = load double*, double** %18
%286 = getelementptr inbounds double, double* %285, i64 6
%287 = load double, double* %286
store double %287, double* %65
%288 = load double*, double** %18
%289 = getelementptr inbounds double, double* %288, i64 7
%290 = load double, double* %289
store double %290, double* %66
%291 = load double*, double** %18
%292 = getelementptr inbounds double, double* %291, i64 8
store double* %292, double** %18
%293 = load double*, double** %19
%294 = getelementptr inbounds double, double* %293, i64 0
%295 = load double, double* %294
store double %295, double* %67
%296 = load double*, double** %19
%297 = getelementptr inbounds double, double* %296, i64 1
%298 = load double, double* %297
store double %298, double* %68
%299 = load double*, double** %19
%300 = getelementptr inbounds double, double* %299, i64 2
%301 = load double, double* %300
store double %301, double* %69
%302 = load double*, double** %19
%303 = getelementptr inbounds double, double* %302, i64 3
%304 = load double, double* %303
store double %304, double* %70
%305 = load double*, double** %19
%306 = getelementptr inbounds double, double* %305, i64 4
%307 = load double, double* %306
store double %307, double* %71
%308 = load double*, double** %19
%309 = getelementptr inbounds double, double* %308, i64 5
%310 = load double, double* %309
store double %310, double* %72
%311 = load double*, double** %19
%312 = getelementptr inbounds double, double* %311, i64 6
%313 = load double, double* %312
store double %313, double* %73
%314 = load double*, double** %19
%315 = getelementptr inbounds double, double* %314, i64 7
%316 = load double, double* %315
store double %316, double* %74
%317 = load double*, double** %19
%318 = getelementptr inbounds double, double* %317, i64 8
store double* %318, double** %19
%319 = load double*, double** %20
%320 = getelementptr inbounds double, double* %319, i64 0
%321 = load double, double* %320
store double %321, double* %75
%322 = load double*, double** %20
%323 = getelementptr inbounds double, double* %322, i64 1
%324 = load double, double* %323
store double %324, double* %76
%325 = load double*, double** %20
%326 = getelementptr inbounds double, double* %325, i64 2
%327 = load double, double* %326
store double %327, double* %77
%328 = load double*, double** %20
%329 = getelementptr inbounds double, double* %328, i64 3
%330 = load double, double* %329
store double %330, double* %78
%331 = load double*, double** %20
%332 = getelementptr inbounds double, double* %331, i64 4
%333 = load double, double* %332
store double %333, double* %79
%334 = load double*, double** %20
%335 = getelementptr inbounds double, double* %334, i64 5
%336 = load double, double* %335
store double %336, double* %80
%337 = load double*, double** %20
%338 = getelementptr inbounds double, double* %337, i64 6
%339 = load double, double* %338
store double %339, double* %81
%340 = load double*, double** %20
%341 = getelementptr inbounds double, double* %340, i64 7
%342 = load double, double* %341
store double %342, double* %82
%343 = load double*, double** %20
%344 = getelementptr inbounds double, double* %343, i64 8
store double* %344, double** %20
%345 = load double*, double** %21
%346 = getelementptr inbounds double, double* %345, i64 0
%347 = load double, double* %346
store double %347, double* %83
%348 = load double*, double** %21
%349 = getelementptr inbounds double, double* %348, i64 1
%350 = load double, double* %349
store double %350, double* %84
%351 = load double*, double** %21
%352 = getelementptr inbounds double, double* %351, i64 2
%353 = load double, double* %352
store double %353, double* %85
%354 = load double*, double** %21
%355 = getelementptr inbounds double, double* %354, i64 3
%356 = load double, double* %355
store double %356, double* %86
%357 = load double*, double** %21
%358 = getelementptr inbounds double, double* %357, i64 4
%359 = load double, double* %358
store double %359, double* %87
%360 = load double*, double** %21
%361 = getelementptr inbounds double, double* %360, i64 5
%362 = load double, double* %361
store double %362, double* %88
%363 = load double*, double** %21
%364 = getelementptr inbounds double, double* %363, i64 6
%365 = load double, double* %364
store double %365, double* %89
%366 = load double*, double** %21
%367 = getelementptr inbounds double, double* %366, i64 7
%368 = load double, double* %367
store double %368, double* %90
%369 = load double*, double** %21
%370 = getelementptr inbounds double, double* %369, i64 8
store double* %370, double** %21
%371 = load double, double* %27
%372 = load double*, double** %23
%373 = getelementptr inbounds double, double* %372, i64 0
store double %371, double* %373
%374 = load double, double* %28
%375 = load double*, double** %23
%376 = getelementptr inbounds double, double* %375, i64 1
store double %374, double* %376
%377 = load double, double* %29
%378 = load double*, double** %23
%379 = getelementptr inbounds double, double* %378, i64 2
store double %377, double* %379
%380 = load double, double* %30
%381 = load double*, double** %23
%382 = getelementptr inbounds double, double* %381, i64 3
store double %380, double* %382
%383 = load double, double* %31
%384 = load double*, double** %23
%385 = getelementptr inbounds double, double* %384, i64 4
store double %383, double* %385
%386 = load double, double* %32
%387 = load double*, double** %23
%388 = getelementptr inbounds double, double* %387, i64 5
store double %386, double* %388
%389 = load double, double* %33
%390 = load double*, double** %23
%391 = getelementptr inbounds double, double* %390, i64 6
store double %389, double* %391
%392 = load double, double* %34
%393 = load double*, double** %23
%394 = getelementptr inbounds double, double* %393, i64 7
store double %392, double* %394
%395 = load double, double* %35
%396 = load double*, double** %23
%397 = getelementptr inbounds double, double* %396, i64 8
store double %395, double* %397
%398 = load double, double* %36
%399 = load double*, double** %23
%400 = getelementptr inbounds double, double* %399, i64 9
store double %398, double* %400
%401 = load double, double* %37
%402 = load double*, double** %23
%403 = getelementptr inbounds double, double* %402, i64 10
store double %401, double* %403
%404 = load double, double* %38
%405 = load double*, double** %23
%406 = getelementptr inbounds double, double* %405, i64 11
store double %404, double* %406
%407 = load double, double* %39
%408 = load double*, double** %23
%409 = getelementptr inbounds double, double* %408, i64 12
store double %407, double* %409
%410 = load double, double* %40
%411 = load double*, double** %23
%412 = getelementptr inbounds double, double* %411, i64 13
store double %410, double* %412
%413 = load double, double* %41
%414 = load double*, double** %23
%415 = getelementptr inbounds double, double* %414, i64 14
store double %413, double* %415
%416 = load double, double* %42
%417 = load double*, double** %23
%418 = getelementptr inbounds double, double* %417, i64 15
store double %416, double* %418
%419 = load double, double* %43
%420 = load double*, double** %23
%421 = getelementptr inbounds double, double* %420, i64 16
store double %419, double* %421
%422 = load double, double* %44
%423 = load double*, double** %23
%424 = getelementptr inbounds double, double* %423, i64 17
store double %422, double* %424
%425 = load double, double* %45
%426 = load double*, double** %23
%427 = getelementptr inbounds double, double* %426, i64 18
store double %425, double* %427
%428 = load double, double* %46
%429 = load double*, double** %23
%430 = getelementptr inbounds double, double* %429, i64 19
store double %428, double* %430
%431 = load double, double* %47
%432 = load double*, double** %23
%433 = getelementptr inbounds double, double* %432, i64 20
store double %431, double* %433
%434 = load double, double* %48
%435 = load double*, double** %23
%436 = getelementptr inbounds double, double* %435, i64 21
store double %434, double* %436
%437 = load double, double* %49
%438 = load double*, double** %23
%439 = getelementptr inbounds double, double* %438, i64 22
store double %437, double* %439
%440 = load double, double* %50
%441 = load double*, double** %23
%442 = getelementptr inbounds double, double* %441, i64 23
store double %440, double* %442
%443 = load double, double* %51
%444 = load double*, double** %23
%445 = getelementptr inbounds double, double* %444, i64 24
store double %443, double* %445
%446 = load double, double* %52
%447 = load double*, double** %23
%448 = getelementptr inbounds double, double* %447, i64 25
store double %446, double* %448
%449 = load double, double* %53
%450 = load double*, double** %23
%451 = getelementptr inbounds double, double* %450, i64 26
store double %449, double* %451
%452 = load double, double* %54
%453 = load double*, double** %23
%454 = getelementptr inbounds double, double* %453, i64 27
store double %452, double* %454
%455 = load double, double* %55
%456 = load double*, double** %23
%457 = getelementptr inbounds double, double* %456, i64 28
store double %455, double* %457
%458 = load double, double* %56
%459 = load double*, double** %23
%460 = getelementptr inbounds double, double* %459, i64 29
store double %458, double* %460
%461 = load double, double* %57
%462 = load double*, double** %23
%463 = getelementptr inbounds double, double* %462, i64 30
store double %461, double* %463
%464 = load double, double* %58
%465 = load double*, double** %23
%466 = getelementptr inbounds double, double* %465, i64 31
store double %464, double* %466
%467 = load double, double* %59
%468 = load double*, double** %23
%469 = getelementptr inbounds double, double* %468, i64 32
store double %467, double* %469
%470 = load double, double* %60
%471 = load double*, double** %23
%472 = getelementptr inbounds double, double* %471, i64 33
store double %470, double* %472
%473 = load double, double* %61
%474 = load double*, double** %23
%475 = getelementptr inbounds double, double* %474, i64 34
store double %473, double* %475
%476 = load double, double* %62
%477 = load double*, double** %23
%478 = getelementptr inbounds double, double* %477, i64 35
store double %476, double* %478
%479 = load double, double* %63
%480 = load double*, double** %23
%481 = getelementptr inbounds double, double* %480, i64 36
store double %479, double* %481
%482 = load double, double* %64
%483 = load double*, double** %23
%484 = getelementptr inbounds double, double* %483, i64 37
store double %482, double* %484
%485 = load double, double* %65
%486 = load double*, double** %23
%487 = getelementptr inbounds double, double* %486, i64 38
store double %485, double* %487
%488 = load double, double* %66
%489 = load double*, double** %23
%490 = getelementptr inbounds double, double* %489, i64 39
store double %488, double* %490
%491 = load double, double* %67
%492 = load double*, double** %23
%493 = getelementptr inbounds double, double* %492, i64 40
store double %491, double* %493
%494 = load double, double* %68
%495 = load double*, double** %23
%496 = getelementptr inbounds double, double* %495, i64 41
store double %494, double* %496
%497 = load double, double* %69
%498 = load double*, double** %23
%499 = getelementptr inbounds double, double* %498, i64 42
store double %497, double* %499
%500 = load double, double* %70
%501 = load double*, double** %23
%502 = getelementptr inbounds double, double* %501, i64 43
store double %500, double* %502
%503 = load double, double* %71
%504 = load double*, double** %23
%505 = getelementptr inbounds double, double* %504, i64 44
store double %503, double* %505
%506 = load double, double* %72
%507 = load double*, double** %23
%508 = getelementptr inbounds double, double* %507, i64 45
store double %506, double* %508
%509 = load double, double* %73
%510 = load double*, double** %23
%511 = getelementptr inbounds double, double* %510, i64 46
store double %509, double* %511
%512 = load double, double* %74
%513 = load double*, double** %23
%514 = getelementptr inbounds double, double* %513, i64 47
store double %512, double* %514
%515 = load double, double* %75
%516 = load double*, double** %23
%517 = getelementptr inbounds double, double* %516, i64 48
store double %515, double* %517
%518 = load double, double* %76
%519 = load double*, double** %23
%520 = getelementptr inbounds double, double* %519, i64 49
store double %518, double* %520
%521 = load double, double* %77
%522 = load double*, double** %23
%523 = getelementptr inbounds double, double* %522, i64 50
store double %521, double* %523
%524 = load double, double* %78
%525 = load double*, double** %23
%526 = getelementptr inbounds double, double* %525, i64 51
store double %524, double* %526
%527 = load double, double* %79
%528 = load double*, double** %23
%529 = getelementptr inbounds double, double* %528, i64 52
store double %527, double* %529
%530 = load double, double* %80
%531 = load double*, double** %23
%532 = getelementptr inbounds double, double* %531, i64 53
store double %530, double* %532
%533 = load double, double* %81
%534 = load double*, double** %23
%535 = getelementptr inbounds double, double* %534, i64 54
store double %533, double* %535
%536 = load double, double* %82
%537 = load double*, double** %23
%538 = getelementptr inbounds double, double* %537, i64 55
store double %536, double* %538
%539 = load double, double* %83
%540 = load double*, double** %23
%541 = getelementptr inbounds double, double* %540, i64 56
store double %539, double* %541
%542 = load double, double* %84
%543 = load double*, double** %23
%544 = getelementptr inbounds double, double* %543, i64 57
store double %542, double* %544
%545 = load double, double* %85
%546 = load double*, double** %23
%547 = getelementptr inbounds double, double* %546, i64 58
store double %545, double* %547
%548 = load double, double* %86
%549 = load double*, double** %23
%550 = getelementptr inbounds double, double* %549, i64 59
store double %548, double* %550
%551 = load double, double* %87
%552 = load double*, double** %23
%553 = getelementptr inbounds double, double* %552, i64 60
store double %551, double* %553
%554 = load double, double* %88
%555 = load double*, double** %23
%556 = getelementptr inbounds double, double* %555, i64 61
store double %554, double* %556
%557 = load double, double* %89
%558 = load double*, double** %23
%559 = getelementptr inbounds double, double* %558, i64 62
store double %557, double* %559
%560 = load double, double* %90
%561 = load double*, double** %23
%562 = getelementptr inbounds double, double* %561, i64 63
store double %560, double* %562
%563 = load i32, i32* %6
%564 = mul nsw i32 %563, 8
%565 = load double*, double** %23
%566 = sext i32 %564 to i64
%567 = getelementptr inbounds double, double* %565, i64 %566
store double* %567, double** %23
%568 = load i32, i32* %11
%569 = add nsw i32 %568, -1
store i32 %569, i32* %11
br label %570
570: ; preds = %162
%571 = load i32, i32* %11
%572 = icmp sgt i32 %571, 0
br i1 %572, label %162, label %573
573: ; preds = %570
br label %574
574: ; preds = %573, %119
%575 = load i32, i32* %7
%576 = and i32 %575, 4
%577 = icmp ne i32 %576, 0
br i1 %577, label %578, label %789
578: ; preds = %574
%579 = load double*, double** %14
%580 = getelementptr inbounds double, double* %579, i64 0
%581 = load double, double* %580
store double %581, double* %27
%582 = load double*, double** %14
%583 = getelementptr inbounds double, double* %582, i64 1
%584 = load double, double* %583
store double %584, double* %28
%585 = load double*, double** %14
%586 = getelementptr inbounds double, double* %585, i64 2
%587 = load double, double* %586
store double %587, double* %29
%588 = load double*, double** %14
%589 = getelementptr inbounds double, double* %588, i64 3
%590 = load double, double* %589
store double %590, double* %30
%591 = load double*, double** %14
%592 = getelementptr inbounds double, double* %591, i64 4
store double* %592, double** %14
%593 = load double*, double** %15
%594 = getelementptr inbounds double, double* %593, i64 0
%595 = load double, double* %594
store double %595, double* %31
%596 = load double*, double** %15
%597 = getelementptr inbounds double, double* %596, i64 1
%598 = load double, double* %597
store double %598, double* %32
%599 = load double*, double** %15
%600 = getelementptr inbounds double, double* %599, i64 2
%601 = load double, double* %600
store double %601, double* %33
%602 = load double*, double** %15
%603 = getelementptr inbounds double, double* %602, i64 3
%604 = load double, double* %603
store double %604, double* %34
%605 = load double*, double** %15
%606 = getelementptr inbounds double, double* %605, i64 4
store double* %606, double** %15
%607 = load double*, double** %16
%608 = getelementptr inbounds double, double* %607, i64 0
%609 = load double, double* %608
store double %609, double* %35
%610 = load double*, double** %16
%611 = getelementptr inbounds double, double* %610, i64 1
%612 = load double, double* %611
store double %612, double* %36
%613 = load double*, double** %16
%614 = getelementptr inbounds double, double* %613, i64 2
%615 = load double, double* %614
store double %615, double* %37
%616 = load double*, double** %16
%617 = getelementptr inbounds double, double* %616, i64 3
%618 = load double, double* %617
store double %618, double* %38
%619 = load double*, double** %16
%620 = getelementptr inbounds double, double* %619, i64 4
store double* %620, double** %16
%621 = load double*, double** %17
%622 = getelementptr inbounds double, double* %621, i64 0
%623 = load double, double* %622
store double %623, double* %39
%624 = load double*, double** %17
%625 = getelementptr inbounds double, double* %624, i64 1
%626 = load double, double* %625
store double %626, double* %40
%627 = load double*, double** %17
%628 = getelementptr inbounds double, double* %627, i64 2
%629 = load double, double* %628
store double %629, double* %41
%630 = load double*, double** %17
%631 = getelementptr inbounds double, double* %630, i64 3
%632 = load double, double* %631
store double %632, double* %42
%633 = load double*, double** %17
%634 = getelementptr inbounds double, double* %633, i64 4
store double* %634, double** %17
%635 = load double*, double** %18
%636 = getelementptr inbounds double, double* %635, i64 0
%637 = load double, double* %636
store double %637, double* %43
%638 = load double*, double** %18
%639 = getelementptr inbounds double, double* %638, i64 1
%640 = load double, double* %639
store double %640, double* %44
%641 = load double*, double** %18
%642 = getelementptr inbounds double, double* %641, i64 2
%643 = load double, double* %642
store double %643, double* %45
%644 = load double*, double** %18
%645 = getelementptr inbounds double, double* %644, i64 3
%646 = load double, double* %645
store double %646, double* %46
%647 = load double*, double** %18
%648 = getelementptr inbounds double, double* %647, i64 4
store double* %648, double** %18
%649 = load double*, double** %19
%650 = getelementptr inbounds double, double* %649, i64 0
%651 = load double, double* %650
store double %651, double* %47
%652 = load double*, double** %19
%653 = getelementptr inbounds double, double* %652, i64 1
%654 = load double, double* %653
store double %654, double* %48
%655 = load double*, double** %19
%656 = getelementptr inbounds double, double* %655, i64 2
%657 = load double, double* %656
store double %657, double* %49
%658 = load double*, double** %19
%659 = getelementptr inbounds double, double* %658, i64 3
%660 = load double, double* %659
store double %660, double* %50
%661 = load double*, double** %19
%662 = getelementptr inbounds double, double* %661, i64 4
store double* %662, double** %19
%663 = load double*, double** %20
%664 = getelementptr inbounds double, double* %663, i64 0
%665 = load double, double* %664
store double %665, double* %51
%666 = load double*, double** %20
%667 = getelementptr inbounds double, double* %666, i64 1
%668 = load double, double* %667
store double %668, double* %52
%669 = load double*, double** %20
%670 = getelementptr inbounds double, double* %669, i64 2
%671 = load double, double* %670
store double %671, double* %53
%672 = load double*, double** %20
%673 = getelementptr inbounds double, double* %672, i64 3
%674 = load double, double* %673
store double %674, double* %54
%675 = load double*, double** %20
%676 = getelementptr inbounds double, double* %675, i64 4
store double* %676, double** %20
%677 = load double*, double** %21
%678 = getelementptr inbounds double, double* %677, i64 0
%679 = load double, double* %678
store double %679, double* %55
%680 = load double*, double** %21
%681 = getelementptr inbounds double, double* %680, i64 1
%682 = load double, double* %681
store double %682, double* %56
%683 = load double*, double** %21
%684 = getelementptr inbounds double, double* %683, i64 2
%685 = load double, double* %684
store double %685, double* %57
%686 = load double*, double** %21
%687 = getelementptr inbounds double, double* %686, i64 3
%688 = load double, double* %687
store double %688, double* %58
%689 = load double*, double** %21
%690 = getelementptr inbounds double, double* %689, i64 4
store double* %690, double** %21
%691 = load double, double* %27
%692 = load double*, double** %24
%693 = getelementptr inbounds double, double* %692, i64 0
store double %691, double* %693
%694 = load double, double* %28
%695 = load double*, double** %24
%696 = getelementptr inbounds double, double* %695, i64 1
store double %694, double* %696
%697 = load double, double* %29
%698 = load double*, double** %24
%699 = getelementptr inbounds double, double* %698, i64 2
store double %697, double* %699
%700 = load double, double* %30
%701 = load double*, double** %24
%702 = getelementptr inbounds double, double* %701, i64 3
store double %700, double* %702
%703 = load double, double* %31
%704 = load double*, double** %24
%705 = getelementptr inbounds double, double* %704, i64 4
store double %703, double* %705
%706 = load double, double* %32
%707 = load double*, double** %24
%708 = getelementptr inbounds double, double* %707, i64 5
store double %706, double* %708
%709 = load double, double* %33
%710 = load double*, double** %24
%711 = getelementptr inbounds double, double* %710, i64 6
store double %709, double* %711
%712 = load double, double* %34
%713 = load double*, double** %24
%714 = getelementptr inbounds double, double* %713, i64 7
store double %712, double* %714
%715 = load double, double* %35
%716 = load double*, double** %24
%717 = getelementptr inbounds double, double* %716, i64 8
store double %715, double* %717
%718 = load double, double* %36
%719 = load double*, double** %24
%720 = getelementptr inbounds double, double* %719, i64 9
store double %718, double* %720
%721 = load double, double* %37
%722 = load double*, double** %24
%723 = getelementptr inbounds double, double* %722, i64 10
store double %721, double* %723
%724 = load double, double* %38
%725 = load double*, double** %24
%726 = getelementptr inbounds double, double* %725, i64 11
store double %724, double* %726
%727 = load double, double* %39
%728 = load double*, double** %24
%729 = getelementptr inbounds double, double* %728, i64 12
store double %727, double* %729
%730 = load double, double* %40
%731 = load double*, double** %24
%732 = getelementptr inbounds double, double* %731, i64 13
store double %730, double* %732
%733 = load double, double* %41
%734 = load double*, double** %24
%735 = getelementptr inbounds double, double* %734, i64 14
store double %733, double* %735
%736 = load double, double* %42
%737 = load double*, double** %24
%738 = getelementptr inbounds double, double* %737, i64 15
store double %736, double* %738
%739 = load double, double* %43
%740 = load double*, double** %24
%741 = getelementptr inbounds double, double* %740, i64 16
store double %739, double* %741
%742 = load double, double* %44
%743 = load double*, double** %24
%744 = getelementptr inbounds double, double* %743, i64 17
store double %742, double* %744
%745 = load double, double* %45
%746 = load double*, double** %24
%747 = getelementptr inbounds double, double* %746, i64 18
store double %745, double* %747
%748 = load double, double* %46
%749 = load double*, double** %24
%750 = getelementptr inbounds double, double* %749, i64 19
store double %748, double* %750
%751 = load double, double* %47
%752 = load double*, double** %24
%753 = getelementptr inbounds double, double* %752, i64 20
store double %751, double* %753
%754 = load double, double* %48
%755 = load double*, double** %24
%756 = getelementptr inbounds double, double* %755, i64 21
store double %754, double* %756
%757 = load double, double* %49
%758 = load double*, double** %24
%759 = getelementptr inbounds double, double* %758, i64 22
store double %757, double* %759
%760 = load double, double* %50
%761 = load double*, double** %24
%762 = getelementptr inbounds double, double* %761, i64 23
store double %760, double* %762
%763 = load double, double* %51
%764 = load double*, double** %24
%765 = getelementptr inbounds double, double* %764, i64 24
store double %763, double* %765
%766 = load double, double* %52
%767 = load double*, double** %24
%768 = getelementptr inbounds double, double* %767, i64 25
store double %766, double* %768
%769 = load double, double* %53
%770 = load double*, double** %24
%771 = getelementptr inbounds double, double* %770, i64 26
store double %769, double* %771
%772 = load double, double* %54
%773 = load double*, double** %24
%774 = getelementptr inbounds double, double* %773, i64 27
store double %772, double* %774
%775 = load double, double* %55
%776 = load double*, double** %24
%777 = getelementptr inbounds double, double* %776, i64 28
store double %775, double* %777
%778 = load double, double* %56
%779 = load double*, double** %24
%780 = getelementptr inbounds double, double* %779, i64 29
store double %778, double* %780
%781 = load double, double* %57
%782 = load double*, double** %24
%783 = getelementptr inbounds double, double* %782, i64 30
store double %781, double* %783
%784 = load double, double* %58
%785 = load double*, double** %24
%786 = getelementptr inbounds double, double* %785, i64 31
store double %784, double* %786
%787 = load double*, double** %24
%788 = getelementptr inbounds double, double* %787, i64 32
store double* %788, double** %24
br label %789
789: ; preds = %578, %574
%790 = load i32, i32* %7
%791 = and i32 %790, 2
%792 = icmp ne i32 %791, 0
br i1 %792, label %793, label %908
793: ; preds = %789
%794 = load double*, double** %14
%795 = getelementptr inbounds double, double* %794, i64 0
%796 = load double, double* %795
store double %796, double* %27
%797 = load double*, double** %14
%798 = getelementptr inbounds double, double* %797, i64 1
%799 = load double, double* %798
store double %799, double* %28
%800 = load double*, double** %14
%801 = getelementptr inbounds double, double* %800, i64 2
store double* %801, double** %14
%802 = load double*, double** %15
%803 = getelementptr inbounds double, double* %802, i64 0
%804 = load double, double* %803
store double %804, double* %29
%805 = load double*, double** %15
%806 = getelementptr inbounds double, double* %805, i64 1
%807 = load double, double* %806
store double %807, double* %30
%808 = load double*, double** %15
%809 = getelementptr inbounds double, double* %808, i64 2
store double* %809, double** %15
%810 = load double*, double** %16
%811 = getelementptr inbounds double, double* %810, i64 0
%812 = load double, double* %811
store double %812, double* %31
%813 = load double*, double** %16
%814 = getelementptr inbounds double, double* %813, i64 1
%815 = load double, double* %814
store double %815, double* %32
%816 = load double*, double** %16
%817 = getelementptr inbounds double, double* %816, i64 2
store double* %817, double** %16
%818 = load double*, double** %17
%819 = getelementptr inbounds double, double* %818, i64 0
%820 = load double, double* %819
store double %820, double* %33
%821 = load double*, double** %17
%822 = getelementptr inbounds double, double* %821, i64 1
%823 = load double, double* %822
store double %823, double* %34
%824 = load double*, double** %17
%825 = getelementptr inbounds double, double* %824, i64 2
store double* %825, double** %17
%826 = load double*, double** %18
%827 = getelementptr inbounds double, double* %826, i64 0
%828 = load double, double* %827
store double %828, double* %35
%829 = load double*, double** %18
%830 = getelementptr inbounds double, double* %829, i64 1
%831 = load double, double* %830
store double %831, double* %36
%832 = load double*, double** %18
%833 = getelementptr inbounds double, double* %832, i64 2
store double* %833, double** %18
%834 = load double*, double** %19
%835 = getelementptr inbounds double, double* %834, i64 0
%836 = load double, double* %835
store double %836, double* %37
%837 = load double*, double** %19
%838 = getelementptr inbounds double, double* %837, i64 1
%839 = load double, double* %838
store double %839, double* %38
%840 = load double*, double** %19
%841 = getelementptr inbounds double, double* %840, i64 2
store double* %841, double** %19
%842 = load double*, double** %20
%843 = getelementptr inbounds double, double* %842, i64 0
%844 = load double, double* %843
store double %844, double* %39
%845 = load double*, double** %20
%846 = getelementptr inbounds double, double* %845, i64 1
%847 = load double, double* %846
store double %847, double* %40
%848 = load double*, double** %20
%849 = getelementptr inbounds double, double* %848, i64 2
store double* %849, double** %20
%850 = load double*, double** %21
%851 = getelementptr inbounds double, double* %850, i64 0
%852 = load double, double* %851
store double %852, double* %41
%853 = load double*, double** %21
%854 = getelementptr inbounds double, double* %853, i64 1
%855 = load double, double* %854
store double %855, double* %42
%856 = load double*, double** %21
%857 = getelementptr inbounds double, double* %856, i64 2
store double* %857, double** %21
%858 = load double, double* %27
%859 = load double*, double** %25
%860 = getelementptr inbounds double, double* %859, i64 0
store double %858, double* %860
%861 = load double, double* %28
%862 = load double*, double** %25
%863 = getelementptr inbounds double, double* %862, i64 1
store double %861, double* %863
%864 = load double, double* %29
%865 = load double*, double** %25
%866 = getelementptr inbounds double, double* %865, i64 2
store double %864, double* %866
%867 = load double, double* %30
%868 = load double*, double** %25
%869 = getelementptr inbounds double, double* %868, i64 3
store double %867, double* %869
%870 = load double, double* %31
%871 = load double*, double** %25
%872 = getelementptr inbounds double, double* %871, i64 4
store double %870, double* %872
%873 = load double, double* %32
%874 = load double*, double** %25
%875 = getelementptr inbounds double, double* %874, i64 5
store double %873, double* %875
%876 = load double, double* %33
%877 = load double*, double** %25
%878 = getelementptr inbounds double, double* %877, i64 6
store double %876, double* %878
%879 = load double, double* %34
%880 = load double*, double** %25
%881 = getelementptr inbounds double, double* %880, i64 7
store double %879, double* %881
%882 = load double, double* %35
%883 = load double*, double** %25
%884 = getelementptr inbounds double, double* %883, i64 8
store double %882, double* %884
%885 = load double, double* %36
%886 = load double*, double** %25
%887 = getelementptr inbounds double, double* %886, i64 9
store double %885, double* %887
%888 = load double, double* %37
%889 = load double*, double** %25
%890 = getelementptr inbounds double, double* %889, i64 10
store double %888, double* %890
%891 = load double, double* %38
%892 = load double*, double** %25
%893 = getelementptr inbounds double, double* %892, i64 11
store double %891, double* %893
%894 = load double, double* %39
%895 = load double*, double** %25
%896 = getelementptr inbounds double, double* %895, i64 12
store double %894, double* %896
%897 = load double, double* %40
%898 = load double*, double** %25
%899 = getelementptr inbounds double, double* %898, i64 13
store double %897, double* %899
%900 = load double, double* %41
%901 = load double*, double** %25
%902 = getelementptr inbounds double, double* %901, i64 14
store double %900, double* %902
%903 = load double, double* %42
%904 = load double*, double** %25
%905 = getelementptr inbounds double, double* %904, i64 15
store double %903, double* %905
%906 = load double*, double** %25
%907 = getelementptr inbounds double, double* %906, i64 16
store double* %907, double** %25
br label %908
908: ; preds = %793, %789
%909 = load i32, i32* %7
%910 = and i32 %909, 1
%911 = icmp ne i32 %910, 0
br i1 %911, label %912, label %979
912: ; preds = %908
%913 = load double*, double** %14
%914 = getelementptr inbounds double, double* %913, i64 0
%915 = load double, double* %914
store double %915, double* %27
%916 = load double*, double** %14
%917 = getelementptr inbounds double, double* %916, i32 1
store double* %917, double** %14
%918 = load double*, double** %15
%919 = getelementptr inbounds double, double* %918, i64 0
%920 = load double, double* %919
store double %920, double* %28
%921 = load double*, double** %15
%922 = getelementptr inbounds double, double* %921, i32 1
store double* %922, double** %15
%923 = load double*, double** %16
%924 = getelementptr inbounds double, double* %923, i64 0
%925 = load double, double* %924
store double %925, double* %29
%926 = load double*, double** %16
%927 = getelementptr inbounds double, double* %926, i32 1
store double* %927, double** %16
%928 = load double*, double** %17
%929 = getelementptr inbounds double, double* %928, i64 0
%930 = load double, double* %929
store double %930, double* %30
%931 = load double*, double** %17
%932 = getelementptr inbounds double, double* %931, i32 1
store double* %932, double** %17
%933 = load double*, double** %18
%934 = getelementptr inbounds double, double* %933, i64 0
%935 = load double, double* %934
store double %935, double* %31
%936 = load double*, double** %18
%937 = getelementptr inbounds double, double* %936, i32 1
store double* %937, double** %18
%938 = load double*, double** %19
%939 = getelementptr inbounds double, double* %938, i64 0
%940 = load double, double* %939
store double %940, double* %32
%941 = load double*, double** %19
%942 = getelementptr inbounds double, double* %941, i32 1
store double* %942, double** %19
%943 = load double*, double** %20
%944 = getelementptr inbounds double, double* %943, i64 0
%945 = load double, double* %944
store double %945, double* %33
%946 = load double*, double** %20
%947 = getelementptr inbounds double, double* %946, i32 1
store double* %947, double** %20
%948 = load double*, double** %21
%949 = getelementptr inbounds double, double* %948, i64 0
%950 = load double, double* %949
store double %950, double* %34
%951 = load double*, double** %21
%952 = getelementptr inbounds double, double* %951, i32 1
store double* %952, double** %21
%953 = load double, double* %27
%954 = load double*, double** %26
%955 = getelementptr inbounds double, double* %954, i64 0
store double %953, double* %955
%956 = load double, double* %28
%957 = load double*, double** %26
%958 = getelementptr inbounds double, double* %957, i64 1
store double %956, double* %958
%959 = load double, double* %29
%960 = load double*, double** %26
%961 = getelementptr inbounds double, double* %960, i64 2
store double %959, double* %961
%962 = load double, double* %30
%963 = load double*, double** %26
%964 = getelementptr inbounds double, double* %963, i64 3
store double %962, double* %964
%965 = load double, double* %31
%966 = load double*, double** %26
%967 = getelementptr inbounds double, double* %966, i64 4
store double %965, double* %967
%968 = load double, double* %32
%969 = load double*, double** %26
%970 = getelementptr inbounds double, double* %969, i64 5
store double %968, double* %970
%971 = load double, double* %33
%972 = load double*, double** %26
%973 = getelementptr inbounds double, double* %972, i64 6
store double %971, double* %973
%974 = load double, double* %34
%975 = load double*, double** %26
%976 = getelementptr inbounds double, double* %975, i64 7
store double %974, double* %976
%977 = load double*, double** %26
%978 = getelementptr inbounds double, double* %977, i64 8
store double* %978, double** %26
br label %979
979: ; preds = %912, %908
%980 = load i32, i32* %12
%981 = add nsw i32 %980, -1
store i32 %981, i32* %12
br label %982
982: ; preds = %979
%983 = load i32, i32* %12
%984 = icmp sgt i32 %983, 0
br i1 %984, label %119, label %985
985: ; preds = %982
br label %986
986: ; preds = %985, %5
%987 = load i32, i32* %6
%988 = and i32 %987, 4
%989 = icmp ne i32 %988, 0
br i1 %989, label %990, label %1443
990: ; preds = %986
%991 = load double*, double** %13
store double* %991, double** %14
%992 = load double*, double** %14
%993 = load i32, i32* %9
%994 = sext i32 %993 to i64
%995 = getelementptr inbounds double, double* %992, i64 %994
store double* %995, double** %15
%996 = load double*, double** %15
%997 = load i32, i32* %9
%998 = sext i32 %997 to i64
%999 = getelementptr inbounds double, double* %996, i64 %998
store double* %999, double** %16
%1000 = load double*, double** %16
%1001 = load i32, i32* %9
%1002 = sext i32 %1001 to i64
%1003 = getelementptr inbounds double, double* %1000, i64 %1002
store double* %1003, double** %17
%1004 = load i32, i32* %9
%1005 = mul nsw i32 4, %1004
%1006 = load double*, double** %13
%1007 = sext i32 %1005 to i64
%1008 = getelementptr inbounds double, double* %1006, i64 %1007
store double* %1008, double** %13
%1009 = load double*, double** %22
store double* %1009, double** %23
%1010 = load double*, double** %22
%1011 = getelementptr inbounds double, double* %1010, i64 32
store double* %1011, double** %22
%1012 = load i32, i32* %7
%1013 = ashr i32 %1012, 3
store i32 %1013, i32* %11
%1014 = load i32, i32* %11
%1015 = icmp sgt i32 %1014, 0
br i1 %1015, label %1016, label %1229
1016: ; preds = %990
br label %1017
1017: ; preds = %1225, %1016
%1018 = load double*, double** %14
%1019 = getelementptr inbounds double, double* %1018, i64 0
%1020 = load double, double* %1019
store double %1020, double* %27
%1021 = load double*, double** %14
%1022 = getelementptr inbounds double, double* %1021, i64 1
%1023 = load double, double* %1022
store double %1023, double* %28
%1024 = load double*, double** %14
%1025 = getelementptr inbounds double, double* %1024, i64 2
%1026 = load double, double* %1025
store double %1026, double* %29
%1027 = load double*, double** %14
%1028 = getelementptr inbounds double, double* %1027, i64 3
%1029 = load double, double* %1028
store double %1029, double* %30
%1030 = load double*, double** %14
%1031 = getelementptr inbounds double, double* %1030, i64 4
%1032 = load double, double* %1031
store double %1032, double* %31
%1033 = load double*, double** %14
%1034 = getelementptr inbounds double, double* %1033, i64 5
%1035 = load double, double* %1034
store double %1035, double* %32
%1036 = load double*, double** %14
%1037 = getelementptr inbounds double, double* %1036, i64 6
%1038 = load double, double* %1037
store double %1038, double* %33
%1039 = load double*, double** %14
%1040 = getelementptr inbounds double, double* %1039, i64 7
%1041 = load double, double* %1040
store double %1041, double* %34
%1042 = load double*, double** %14
%1043 = getelementptr inbounds double, double* %1042, i64 8
store double* %1043, double** %14
%1044 = load double*, double** %15
%1045 = getelementptr inbounds double, double* %1044, i64 0
%1046 = load double, double* %1045
store double %1046, double* %35
%1047 = load double*, double** %15
%1048 = getelementptr inbounds double, double* %1047, i64 1
%1049 = load double, double* %1048
store double %1049, double* %36
%1050 = load double*, double** %15
%1051 = getelementptr inbounds double, double* %1050, i64 2
%1052 = load double, double* %1051
store double %1052, double* %37
%1053 = load double*, double** %15
%1054 = getelementptr inbounds double, double* %1053, i64 3
%1055 = load double, double* %1054
store double %1055, double* %38
%1056 = load double*, double** %15
%1057 = getelementptr inbounds double, double* %1056, i64 4
%1058 = load double, double* %1057
store double %1058, double* %39
%1059 = load double*, double** %15
%1060 = getelementptr inbounds double, double* %1059, i64 5
%1061 = load double, double* %1060
store double %1061, double* %40
%1062 = load double*, double** %15
%1063 = getelementptr inbounds double, double* %1062, i64 6
%1064 = load double, double* %1063
store double %1064, double* %41
%1065 = load double*, double** %15
%1066 = getelementptr inbounds double, double* %1065, i64 7
%1067 = load double, double* %1066
store double %1067, double* %42
%1068 = load double*, double** %15
%1069 = getelementptr inbounds double, double* %1068, i64 8
store double* %1069, double** %15
%1070 = load double*, double** %16
%1071 = getelementptr inbounds double, double* %1070, i64 0
%1072 = load double, double* %1071
store double %1072, double* %43
%1073 = load double*, double** %16
%1074 = getelementptr inbounds double, double* %1073, i64 1
%1075 = load double, double* %1074
store double %1075, double* %44
%1076 = load double*, double** %16
%1077 = getelementptr inbounds double, double* %1076, i64 2
%1078 = load double, double* %1077
store double %1078, double* %45
%1079 = load double*, double** %16
%1080 = getelementptr inbounds double, double* %1079, i64 3
%1081 = load double, double* %1080
store double %1081, double* %46
%1082 = load double*, double** %16
%1083 = getelementptr inbounds double, double* %1082, i64 4
%1084 = load double, double* %1083
store double %1084, double* %47
%1085 = load double*, double** %16
%1086 = getelementptr inbounds double, double* %1085, i64 5
%1087 = load double, double* %1086
store double %1087, double* %48
%1088 = load double*, double** %16
%1089 = getelementptr inbounds double, double* %1088, i64 6
%1090 = load double, double* %1089
store double %1090, double* %49
%1091 = load double*, double** %16
%1092 = getelementptr inbounds double, double* %1091, i64 7
%1093 = load double, double* %1092
store double %1093, double* %50
%1094 = load double*, double** %16
%1095 = getelementptr inbounds double, double* %1094, i64 8
store double* %1095, double** %16
%1096 = load double*, double** %17
%1097 = getelementptr inbounds double, double* %1096, i64 0
%1098 = load double, double* %1097
store double %1098, double* %51
%1099 = load double*, double** %17
%1100 = getelementptr inbounds double, double* %1099, i64 1
%1101 = load double, double* %1100
store double %1101, double* %52
%1102 = load double*, double** %17
%1103 = getelementptr inbounds double, double* %1102, i64 2
%1104 = load double, double* %1103
store double %1104, double* %53
%1105 = load double*, double** %17
%1106 = getelementptr inbounds double, double* %1105, i64 3
%1107 = load double, double* %1106
store double %1107, double* %54
%1108 = load double*, double** %17
%1109 = getelementptr inbounds double, double* %1108, i64 4
%1110 = load double, double* %1109
store double %1110, double* %55
%1111 = load double*, double** %17
%1112 = getelementptr inbounds double, double* %1111, i64 5
%1113 = load double, double* %1112
store double %1113, double* %56
%1114 = load double*, double** %17
%1115 = getelementptr inbounds double, double* %1114, i64 6
%1116 = load double, double* %1115
store double %1116, double* %57
%1117 = load double*, double** %17
%1118 = getelementptr inbounds double, double* %1117, i64 7
%1119 = load double, double* %1118
store double %1119, double* %58
%1120 = load double*, double** %17
%1121 = getelementptr inbounds double, double* %1120, i64 8
store double* %1121, double** %17
%1122 = load double, double* %27
%1123 = load double*, double** %23
%1124 = getelementptr inbounds double, double* %1123, i64 0
store double %1122, double* %1124
%1125 = load double, double* %28
%1126 = load double*, double** %23
%1127 = getelementptr inbounds double, double* %1126, i64 1
store double %1125, double* %1127
%1128 = load double, double* %29
%1129 = load double*, double** %23
%1130 = getelementptr inbounds double, double* %1129, i64 2
store double %1128, double* %1130
%1131 = load double, double* %30
%1132 = load double*, double** %23
%1133 = getelementptr inbounds double, double* %1132, i64 3
store double %1131, double* %1133
%1134 = load double, double* %31
%1135 = load double*, double** %23
%1136 = getelementptr inbounds double, double* %1135, i64 4
store double %1134, double* %1136
%1137 = load double, double* %32
%1138 = load double*, double** %23
%1139 = getelementptr inbounds double, double* %1138, i64 5
store double %1137, double* %1139
%1140 = load double, double* %33
%1141 = load double*, double** %23
%1142 = getelementptr inbounds double, double* %1141, i64 6
store double %1140, double* %1142
%1143 = load double, double* %34
%1144 = load double*, double** %23
%1145 = getelementptr inbounds double, double* %1144, i64 7
store double %1143, double* %1145
%1146 = load double, double* %35
%1147 = load double*, double** %23
%1148 = getelementptr inbounds double, double* %1147, i64 8
store double %1146, double* %1148
%1149 = load double, double* %36
%1150 = load double*, double** %23
%1151 = getelementptr inbounds double, double* %1150, i64 9
store double %1149, double* %1151
%1152 = load double, double* %37
%1153 = load double*, double** %23
%1154 = getelementptr inbounds double, double* %1153, i64 10
store double %1152, double* %1154
%1155 = load double, double* %38
%1156 = load double*, double** %23
%1157 = getelementptr inbounds double, double* %1156, i64 11
store double %1155, double* %1157
%1158 = load double, double* %39
%1159 = load double*, double** %23
%1160 = getelementptr inbounds double, double* %1159, i64 12
store double %1158, double* %1160
%1161 = load double, double* %40
%1162 = load double*, double** %23
%1163 = getelementptr inbounds double, double* %1162, i64 13
store double %1161, double* %1163
%1164 = load double, double* %41
%1165 = load double*, double** %23
%1166 = getelementptr inbounds double, double* %1165, i64 14
store double %1164, double* %1166
%1167 = load double, double* %42
%1168 = load double*, double** %23
%1169 = getelementptr inbounds double, double* %1168, i64 15
store double %1167, double* %1169
%1170 = load double, double* %43
%1171 = load double*, double** %23
%1172 = getelementptr inbounds double, double* %1171, i64 16
store double %1170, double* %1172
%1173 = load double, double* %44
%1174 = load double*, double** %23
%1175 = getelementptr inbounds double, double* %1174, i64 17
store double %1173, double* %1175
%1176 = load double, double* %45
%1177 = load double*, double** %23
%1178 = getelementptr inbounds double, double* %1177, i64 18
store double %1176, double* %1178
%1179 = load double, double* %46
%1180 = load double*, double** %23
%1181 = getelementptr inbounds double, double* %1180, i64 19
store double %1179, double* %1181
%1182 = load double, double* %47
%1183 = load double*, double** %23
%1184 = getelementptr inbounds double, double* %1183, i64 20
store double %1182, double* %1184
%1185 = load double, double* %48
%1186 = load double*, double** %23
%1187 = getelementptr inbounds double, double* %1186, i64 21
store double %1185, double* %1187
%1188 = load double, double* %49
%1189 = load double*, double** %23
%1190 = getelementptr inbounds double, double* %1189, i64 22
store double %1188, double* %1190
%1191 = load double, double* %50
%1192 = load double*, double** %23
%1193 = getelementptr inbounds double, double* %1192, i64 23
store double %1191, double* %1193
%1194 = load double, double* %51
%1195 = load double*, double** %23
%1196 = getelementptr inbounds double, double* %1195, i64 24
store double %1194, double* %1196
%1197 = load double, double* %52
%1198 = load double*, double** %23
%1199 = getelementptr inbounds double, double* %1198, i64 25
store double %1197, double* %1199
%1200 = load double, double* %53
%1201 = load double*, double** %23
%1202 = getelementptr inbounds double, double* %1201, i64 26
store double %1200, double* %1202
%1203 = load double, double* %54
%1204 = load double*, double** %23
%1205 = getelementptr inbounds double, double* %1204, i64 27
store double %1203, double* %1205
%1206 = load double, double* %55
%1207 = load double*, double** %23
%1208 = getelementptr inbounds double, double* %1207, i64 28
store double %1206, double* %1208
%1209 = load double, double* %56
%1210 = load double*, double** %23
%1211 = getelementptr inbounds double, double* %1210, i64 29
store double %1209, double* %1211
%1212 = load double, double* %57
%1213 = load double*, double** %23
%1214 = getelementptr inbounds double, double* %1213, i64 30
store double %1212, double* %1214
%1215 = load double, double* %58
%1216 = load double*, double** %23
%1217 = getelementptr inbounds double, double* %1216, i64 31
store double %1215, double* %1217
%1218 = load i32, i32* %6
%1219 = mul nsw i32 8, %1218
%1220 = load double*, double** %23
%1221 = sext i32 %1219 to i64
%1222 = getelementptr inbounds double, double* %1220, i64 %1221
store double* %1222, double** %23
%1223 = load i32, i32* %11
%1224 = add nsw i32 %1223, -1
store i32 %1224, i32* %11
br label %1225
1225: ; preds = %1017
%1226 = load i32, i32* %11
%1227 = icmp sgt i32 %1226, 0
br i1 %1227, label %1017, label %1228
1228: ; preds = %1225
br label %1229
1229: ; preds = %1228, %990
%1230 = load i32, i32* %7
%1231 = and i32 %1230, 4
%1232 = icmp ne i32 %1231, 0
br i1 %1232, label %1233, label %1340
1233: ; preds = %1229
%1234 = load double*, double** %14
%1235 = getelementptr inbounds double, double* %1234, i64 0
%1236 = load double, double* %1235
store double %1236, double* %27
%1237 = load double*, double** %14
%1238 = getelementptr inbounds double, double* %1237, i64 1
%1239 = load double, double* %1238
store double %1239, double* %28
%1240 = load double*, double** %14
%1241 = getelementptr inbounds double, double* %1240, i64 2
%1242 = load double, double* %1241
store double %1242, double* %29
%1243 = load double*, double** %14
%1244 = getelementptr inbounds double, double* %1243, i64 3
%1245 = load double, double* %1244
store double %1245, double* %30
%1246 = load double*, double** %14
%1247 = getelementptr inbounds double, double* %1246, i64 4
store double* %1247, double** %14
%1248 = load double*, double** %15
%1249 = getelementptr inbounds double, double* %1248, i64 0
%1250 = load double, double* %1249
store double %1250, double* %31
%1251 = load double*, double** %15
%1252 = getelementptr inbounds double, double* %1251, i64 1
%1253 = load double, double* %1252
store double %1253, double* %32
%1254 = load double*, double** %15
%1255 = getelementptr inbounds double, double* %1254, i64 2
%1256 = load double, double* %1255
store double %1256, double* %33
%1257 = load double*, double** %15
%1258 = getelementptr inbounds double, double* %1257, i64 3
%1259 = load double, double* %1258
store double %1259, double* %34
%1260 = load double*, double** %15
%1261 = getelementptr inbounds double, double* %1260, i64 4
store double* %1261, double** %15
%1262 = load double*, double** %16
%1263 = getelementptr inbounds double, double* %1262, i64 0
%1264 = load double, double* %1263
store double %1264, double* %35
%1265 = load double*, double** %16
%1266 = getelementptr inbounds double, double* %1265, i64 1
%1267 = load double, double* %1266
store double %1267, double* %36
%1268 = load double*, double** %16
%1269 = getelementptr inbounds double, double* %1268, i64 2
%1270 = load double, double* %1269
store double %1270, double* %37
%1271 = load double*, double** %16
%1272 = getelementptr inbounds double, double* %1271, i64 3
%1273 = load double, double* %1272
store double %1273, double* %38
%1274 = load double*, double** %16
%1275 = getelementptr inbounds double, double* %1274, i64 4
store double* %1275, double** %16
%1276 = load double*, double** %17
%1277 = getelementptr inbounds double, double* %1276, i64 0
%1278 = load double, double* %1277
store double %1278, double* %39
%1279 = load double*, double** %17
%1280 = getelementptr inbounds double, double* %1279, i64 1
%1281 = load double, double* %1280
store double %1281, double* %40
%1282 = load double*, double** %17
%1283 = getelementptr inbounds double, double* %1282, i64 2
%1284 = load double, double* %1283
store double %1284, double* %41
%1285 = load double*, double** %17
%1286 = getelementptr inbounds double, double* %1285, i64 3
%1287 = load double, double* %1286
store double %1287, double* %42
%1288 = load double*, double** %17
%1289 = getelementptr inbounds double, double* %1288, i64 4
store double* %1289, double** %17
%1290 = load double, double* %27
%1291 = load double*, double** %24
%1292 = getelementptr inbounds double, double* %1291, i64 0
store double %1290, double* %1292
%1293 = load double, double* %28
%1294 = load double*, double** %24
%1295 = getelementptr inbounds double, double* %1294, i64 1
store double %1293, double* %1295
%1296 = load double, double* %29
%1297 = load double*, double** %24
%1298 = getelementptr inbounds double, double* %1297, i64 2
store double %1296, double* %1298
%1299 = load double, double* %30
%1300 = load double*, double** %24
%1301 = getelementptr inbounds double, double* %1300, i64 3
store double %1299, double* %1301
%1302 = load double, double* %31
%1303 = load double*, double** %24
%1304 = getelementptr inbounds double, double* %1303, i64 4
store double %1302, double* %1304
%1305 = load double, double* %32
%1306 = load double*, double** %24
%1307 = getelementptr inbounds double, double* %1306, i64 5
store double %1305, double* %1307
%1308 = load double, double* %33
%1309 = load double*, double** %24
%1310 = getelementptr inbounds double, double* %1309, i64 6
store double %1308, double* %1310
%1311 = load double, double* %34
%1312 = load double*, double** %24
%1313 = getelementptr inbounds double, double* %1312, i64 7
store double %1311, double* %1313
%1314 = load double, double* %35
%1315 = load double*, double** %24
%1316 = getelementptr inbounds double, double* %1315, i64 8
store double %1314, double* %1316
%1317 = load double, double* %36
%1318 = load double*, double** %24
%1319 = getelementptr inbounds double, double* %1318, i64 9
store double %1317, double* %1319
%1320 = load double, double* %37
%1321 = load double*, double** %24
%1322 = getelementptr inbounds double, double* %1321, i64 10
store double %1320, double* %1322
%1323 = load double, double* %38
%1324 = load double*, double** %24
%1325 = getelementptr inbounds double, double* %1324, i64 11
store double %1323, double* %1325
%1326 = load double, double* %39
%1327 = load double*, double** %24
%1328 = getelementptr inbounds double, double* %1327, i64 12
store double %1326, double* %1328
%1329 = load double, double* %40
%1330 = load double*, double** %24
%1331 = getelementptr inbounds double, double* %1330, i64 13
store double %1329, double* %1331
%1332 = load double, double* %41
%1333 = load double*, double** %24
%1334 = getelementptr inbounds double, double* %1333, i64 14
store double %1332, double* %1334
%1335 = load double, double* %42
%1336 = load double*, double** %24
%1337 = getelementptr inbounds double, double* %1336, i64 15
store double %1335, double* %1337
%1338 = load double*, double** %24
%1339 = getelementptr inbounds double, double* %1338, i64 16
store double* %1339, double** %24
br label %1340
1340: ; preds = %1233, %1229
%1341 = load i32, i32* %7
%1342 = and i32 %1341, 2
%1343 = icmp ne i32 %1342, 0
br i1 %1343, label %1344, label %1403
1344: ; preds = %1340
%1345 = load double*, double** %14
%1346 = getelementptr inbounds double, double* %1345, i64 0
%1347 = load double, double* %1346
store double %1347, double* %27
%1348 = load double*, double** %14
%1349 = getelementptr inbounds double, double* %1348, i64 1
%1350 = load double, double* %1349
store double %1350, double* %28
%1351 = load double*, double** %14
%1352 = getelementptr inbounds double, double* %1351, i64 2
store double* %1352, double** %14
%1353 = load double*, double** %15
%1354 = getelementptr inbounds double, double* %1353, i64 0
%1355 = load double, double* %1354
store double %1355, double* %29
%1356 = load double*, double** %15
%1357 = getelementptr inbounds double, double* %1356, i64 1
%1358 = load double, double* %1357
store double %1358, double* %30
%1359 = load double*, double** %15
%1360 = getelementptr inbounds double, double* %1359, i64 2
store double* %1360, double** %15
%1361 = load double*, double** %16
%1362 = getelementptr inbounds double, double* %1361, i64 0
%1363 = load double, double* %1362
store double %1363, double* %31
%1364 = load double*, double** %16
%1365 = getelementptr inbounds double, double* %1364, i64 1
%1366 = load double, double* %1365
store double %1366, double* %32
%1367 = load double*, double** %16
%1368 = getelementptr inbounds double, double* %1367, i64 2
store double* %1368, double** %16
%1369 = load double*, double** %17
%1370 = getelementptr inbounds double, double* %1369, i64 0
%1371 = load double, double* %1370
store double %1371, double* %33
%1372 = load double*, double** %17
%1373 = getelementptr inbounds double, double* %1372, i64 1
%1374 = load double, double* %1373
store double %1374, double* %34
%1375 = load double*, double** %17
%1376 = getelementptr inbounds double, double* %1375, i64 2
store double* %1376, double** %17
%1377 = load double, double* %27
%1378 = load double*, double** %25
%1379 = getelementptr inbounds double, double* %1378, i64 0
store double %1377, double* %1379
%1380 = load double, double* %28
%1381 = load double*, double** %25
%1382 = getelementptr inbounds double, double* %1381, i64 1
store double %1380, double* %1382
%1383 = load double, double* %29
%1384 = load double*, double** %25
%1385 = getelementptr inbounds double, double* %1384, i64 2
store double %1383, double* %1385
%1386 = load double, double* %30
%1387 = load double*, double** %25
%1388 = getelementptr inbounds double, double* %1387, i64 3
store double %1386, double* %1388
%1389 = load double, double* %31
%1390 = load double*, double** %25
%1391 = getelementptr inbounds double, double* %1390, i64 4
store double %1389, double* %1391
%1392 = load double, double* %32
%1393 = load double*, double** %25
%1394 = getelementptr inbounds double, double* %1393, i64 5
store double %1392, double* %1394
%1395 = load double, double* %33
%1396 = load double*, double** %25
%1397 = getelementptr inbounds double, double* %1396, i64 6
store double %1395, double* %1397
%1398 = load double, double* %34
%1399 = load double*, double** %25
%1400 = getelementptr inbounds double, double* %1399, i64 7
store double %1398, double* %1400
%1401 = load double*, double** %25
%1402 = getelementptr inbounds double, double* %1401, i64 8
store double* %1402, double** %25
br label %1403
1403: ; preds = %1344, %1340
%1404 = load i32, i32* %7
%1405 = and i32 %1404, 1
%1406 = icmp ne i32 %1405, 0
br i1 %1406, label %1407, label %1442
1407: ; preds = %1403
%1408 = load double*, double** %14
%1409 = getelementptr inbounds double, double* %1408, i64 0
%1410 = load double, double* %1409
store double %1410, double* %27
%1411 = load double*, double** %14
%1412 = getelementptr inbounds double, double* %1411, i32 1
store double* %1412, double** %14
%1413 = load double*, double** %15
%1414 = getelementptr inbounds double, double* %1413, i64 0
%1415 = load double, double* %1414
store double %1415, double* %28
%1416 = load double*, double** %15
%1417 = getelementptr inbounds double, double* %1416, i32 1
store double* %1417, double** %15
%1418 = load double*, double** %16
%1419 = getelementptr inbounds double, double* %1418, i64 0
%1420 = load double, double* %1419
store double %1420, double* %29
%1421 = load double*, double** %16
%1422 = getelementptr inbounds double, double* %1421, i32 1
store double* %1422, double** %16
%1423 = load double*, double** %17
%1424 = getelementptr inbounds double, double* %1423, i64 0
%1425 = load double, double* %1424
store double %1425, double* %30
%1426 = load double*, double** %17
%1427 = getelementptr inbounds double, double* %1426, i32 1
store double* %1427, double** %17
%1428 = load double, double* %27
%1429 = load double*, double** %26
%1430 = getelementptr inbounds double, double* %1429, i64 0
store double %1428, double* %1430
%1431 = load double, double* %28
%1432 = load double*, double** %26
%1433 = getelementptr inbounds double, double* %1432, i64 1
store double %1431, double* %1433
%1434 = load double, double* %29
%1435 = load double*, double** %26
%1436 = getelementptr inbounds double, double* %1435, i64 2
store double %1434, double* %1436
%1437 = load double, double* %30
%1438 = load double*, double** %26
%1439 = getelementptr inbounds double, double* %1438, i64 3
store double %1437, double* %1439
%1440 = load double*, double** %26
%1441 = getelementptr inbounds double, double* %1440, i64 4
store double* %1441, double** %26
br label %1442
1442: ; preds = %1407, %1403
br label %1443
1443: ; preds = %1442, %986
%1444 = load i32, i32* %6
%1445 = and i32 %1444, 2
%1446 = icmp ne i32 %1445, 0
br i1 %1446, label %1447, label %1696
1447: ; preds = %1443
%1448 = load double*, double** %13
store double* %1448, double** %14
%1449 = load double*, double** %14
%1450 = load i32, i32* %9
%1451 = sext i32 %1450 to i64
%1452 = getelementptr inbounds double, double* %1449, i64 %1451
store double* %1452, double** %15
%1453 = load i32, i32* %9
%1454 = mul nsw i32 2, %1453
%1455 = load double*, double** %13
%1456 = sext i32 %1454 to i64
%1457 = getelementptr inbounds double, double* %1455, i64 %1456
store double* %1457, double** %13
%1458 = load double*, double** %22
store double* %1458, double** %23
%1459 = load double*, double** %22
%1460 = getelementptr inbounds double, double* %1459, i64 16
store double* %1460, double** %22
%1461 = load i32, i32* %7
%1462 = ashr i32 %1461, 3
store i32 %1462, i32* %11
%1463 = load i32, i32* %11
%1464 = icmp sgt i32 %1463, 0
br i1 %1464, label %1465, label %1578
1465: ; preds = %1447
br label %1466
1466: ; preds = %1574, %1465
%1467 = load double*, double** %14
%1468 = getelementptr inbounds double, double* %1467, i64 0
%1469 = load double, double* %1468
store double %1469, double* %27
%1470 = load double*, double** %14
%1471 = getelementptr inbounds double, double* %1470, i64 1
%1472 = load double, double* %1471
store double %1472, double* %28
%1473 = load double*, double** %14
%1474 = getelementptr inbounds double, double* %1473, i64 2
%1475 = load double, double* %1474
store double %1475, double* %29
%1476 = load double*, double** %14
%1477 = getelementptr inbounds double, double* %1476, i64 3
%1478 = load double, double* %1477
store double %1478, double* %30
%1479 = load double*, double** %14
%1480 = getelementptr inbounds double, double* %1479, i64 4
%1481 = load double, double* %1480
store double %1481, double* %31
%1482 = load double*, double** %14
%1483 = getelementptr inbounds double, double* %1482, i64 5
%1484 = load double, double* %1483
store double %1484, double* %32
%1485 = load double*, double** %14
%1486 = getelementptr inbounds double, double* %1485, i64 6
%1487 = load double, double* %1486
store double %1487, double* %33
%1488 = load double*, double** %14
%1489 = getelementptr inbounds double, double* %1488, i64 7
%1490 = load double, double* %1489
store double %1490, double* %34
%1491 = load double*, double** %14
%1492 = getelementptr inbounds double, double* %1491, i64 8
store double* %1492, double** %14
%1493 = load double*, double** %15
%1494 = getelementptr inbounds double, double* %1493, i64 0
%1495 = load double, double* %1494
store double %1495, double* %35
%1496 = load double*, double** %15
%1497 = getelementptr inbounds double, double* %1496, i64 1
%1498 = load double, double* %1497
store double %1498, double* %36
%1499 = load double*, double** %15
%1500 = getelementptr inbounds double, double* %1499, i64 2
%1501 = load double, double* %1500
store double %1501, double* %37
%1502 = load double*, double** %15
%1503 = getelementptr inbounds double, double* %1502, i64 3
%1504 = load double, double* %1503
store double %1504, double* %38
%1505 = load double*, double** %15
%1506 = getelementptr inbounds double, double* %1505, i64 4
%1507 = load double, double* %1506
store double %1507, double* %39
%1508 = load double*, double** %15
%1509 = getelementptr inbounds double, double* %1508, i64 5
%1510 = load double, double* %1509
store double %1510, double* %40
%1511 = load double*, double** %15
%1512 = getelementptr inbounds double, double* %1511, i64 6
%1513 = load double, double* %1512
store double %1513, double* %41
%1514 = load double*, double** %15
%1515 = getelementptr inbounds double, double* %1514, i64 7
%1516 = load double, double* %1515
store double %1516, double* %42
%1517 = load double*, double** %15
%1518 = getelementptr inbounds double, double* %1517, i64 8
store double* %1518, double** %15
%1519 = load double, double* %27
%1520 = load double*, double** %23
%1521 = getelementptr inbounds double, double* %1520, i64 0
store double %1519, double* %1521
%1522 = load double, double* %28
%1523 = load double*, double** %23
%1524 = getelementptr inbounds double, double* %1523, i64 1
store double %1522, double* %1524
%1525 = load double, double* %29
%1526 = load double*, double** %23
%1527 = getelementptr inbounds double, double* %1526, i64 2
store double %1525, double* %1527
%1528 = load double, double* %30
%1529 = load double*, double** %23
%1530 = getelementptr inbounds double, double* %1529, i64 3
store double %1528, double* %1530
%1531 = load double, double* %31
%1532 = load double*, double** %23
%1533 = getelementptr inbounds double, double* %1532, i64 4
store double %1531, double* %1533
%1534 = load double, double* %32
%1535 = load double*, double** %23
%1536 = getelementptr inbounds double, double* %1535, i64 5
store double %1534, double* %1536
%1537 = load double, double* %33
%1538 = load double*, double** %23
%1539 = getelementptr inbounds double, double* %1538, i64 6
store double %1537, double* %1539
%1540 = load double, double* %34
%1541 = load double*, double** %23
%1542 = getelementptr inbounds double, double* %1541, i64 7
store double %1540, double* %1542
%1543 = load double, double* %35
%1544 = load double*, double** %23
%1545 = getelementptr inbounds double, double* %1544, i64 8
store double %1543, double* %1545
%1546 = load double, double* %36
%1547 = load double*, double** %23
%1548 = getelementptr inbounds double, double* %1547, i64 9
store double %1546, double* %1548
%1549 = load double, double* %37
%1550 = load double*, double** %23
%1551 = getelementptr inbounds double, double* %1550, i64 10
store double %1549, double* %1551
%1552 = load double, double* %38
%1553 = load double*, double** %23
%1554 = getelementptr inbounds double, double* %1553, i64 11
store double %1552, double* %1554
%1555 = load double, double* %39
%1556 = load double*, double** %23
%1557 = getelementptr inbounds double, double* %1556, i64 12
store double %1555, double* %1557
%1558 = load double, double* %40
%1559 = load double*, double** %23
%1560 = getelementptr inbounds double, double* %1559, i64 13
store double %1558, double* %1560
%1561 = load double, double* %41
%1562 = load double*, double** %23
%1563 = getelementptr inbounds double, double* %1562, i64 14
store double %1561, double* %1563
%1564 = load double, double* %42
%1565 = load double*, double** %23
%1566 = getelementptr inbounds double, double* %1565, i64 15
store double %1564, double* %1566
%1567 = load i32, i32* %6
%1568 = mul nsw i32 8, %1567
%1569 = load double*, double** %23
%1570 = sext i32 %1568 to i64
%1571 = getelementptr inbounds double, double* %1569, i64 %1570
store double* %1571, double** %23
%1572 = load i32, i32* %11
%1573 = add nsw i32 %1572, -1
store i32 %1573, i32* %11
br label %1574
1574: ; preds = %1466
%1575 = load i32, i32* %11
%1576 = icmp sgt i32 %1575, 0
br i1 %1576, label %1466, label %1577
1577: ; preds = %1574
br label %1578
1578: ; preds = %1577, %1447
%1579 = load i32, i32* %7
%1580 = and i32 %1579, 4
%1581 = icmp ne i32 %1580, 0
br i1 %1581, label %1582, label %1637
1582: ; preds = %1578
%1583 = load double*, double** %14
%1584 = getelementptr inbounds double, double* %1583, i64 0
%1585 = load double, double* %1584
store double %1585, double* %27
%1586 = load double*, double** %14
%1587 = getelementptr inbounds double, double* %1586, i64 1
%1588 = load double, double* %1587
store double %1588, double* %28
%1589 = load double*, double** %14
%1590 = getelementptr inbounds double, double* %1589, i64 2
%1591 = load double, double* %1590
store double %1591, double* %29
%1592 = load double*, double** %14
%1593 = getelementptr inbounds double, double* %1592, i64 3
%1594 = load double, double* %1593
store double %1594, double* %30
%1595 = load double*, double** %14
%1596 = getelementptr inbounds double, double* %1595, i64 4
store double* %1596, double** %14
%1597 = load double*, double** %15
%1598 = getelementptr inbounds double, double* %1597, i64 0
%1599 = load double, double* %1598
store double %1599, double* %31
%1600 = load double*, double** %15
%1601 = getelementptr inbounds double, double* %1600, i64 1
%1602 = load double, double* %1601
store double %1602, double* %32
%1603 = load double*, double** %15
%1604 = getelementptr inbounds double, double* %1603, i64 2
%1605 = load double, double* %1604
store double %1605, double* %33
%1606 = load double*, double** %15
%1607 = getelementptr inbounds double, double* %1606, i64 3
%1608 = load double, double* %1607
store double %1608, double* %34
%1609 = load double*, double** %15
%1610 = getelementptr inbounds double, double* %1609, i64 4
store double* %1610, double** %15
%1611 = load double, double* %27
%1612 = load double*, double** %24
%1613 = getelementptr inbounds double, double* %1612, i64 0
store double %1611, double* %1613
%1614 = load double, double* %28
%1615 = load double*, double** %24
%1616 = getelementptr inbounds double, double* %1615, i64 1
store double %1614, double* %1616
%1617 = load double, double* %29
%1618 = load double*, double** %24
%1619 = getelementptr inbounds double, double* %1618, i64 2
store double %1617, double* %1619
%1620 = load double, double* %30
%1621 = load double*, double** %24
%1622 = getelementptr inbounds double, double* %1621, i64 3
store double %1620, double* %1622
%1623 = load double, double* %31
%1624 = load double*, double** %24
%1625 = getelementptr inbounds double, double* %1624, i64 4
store double %1623, double* %1625
%1626 = load double, double* %32
%1627 = load double*, double** %24
%1628 = getelementptr inbounds double, double* %1627, i64 5
store double %1626, double* %1628
%1629 = load double, double* %33
%1630 = load double*, double** %24
%1631 = getelementptr inbounds double, double* %1630, i64 6
store double %1629, double* %1631
%1632 = load double, double* %34
%1633 = load double*, double** %24
%1634 = getelementptr inbounds double, double* %1633, i64 7
store double %1632, double* %1634
%1635 = load double*, double** %24
%1636 = getelementptr inbounds double, double* %1635, i64 8
store double* %1636, double** %24
br label %1637
1637: ; preds = %1582, %1578
%1638 = load i32, i32* %7
%1639 = and i32 %1638, 2
%1640 = icmp ne i32 %1639, 0
br i1 %1640, label %1641, label %1672
1641: ; preds = %1637
%1642 = load double*, double** %14
%1643 = getelementptr inbounds double, double* %1642, i64 0
%1644 = load double, double* %1643
store double %1644, double* %27
%1645 = load double*, double** %14
%1646 = getelementptr inbounds double, double* %1645, i64 1
%1647 = load double, double* %1646
store double %1647, double* %28
%1648 = load double*, double** %14
%1649 = getelementptr inbounds double, double* %1648, i64 2
store double* %1649, double** %14
%1650 = load double*, double** %15
%1651 = getelementptr inbounds double, double* %1650, i64 0
%1652 = load double, double* %1651
store double %1652, double* %29
%1653 = load double*, double** %15
%1654 = getelementptr inbounds double, double* %1653, i64 1
%1655 = load double, double* %1654
store double %1655, double* %30
%1656 = load double*, double** %15
%1657 = getelementptr inbounds double, double* %1656, i64 2
store double* %1657, double** %15
%1658 = load double, double* %27
%1659 = load double*, double** %25
%1660 = getelementptr inbounds double, double* %1659, i64 0
store double %1658, double* %1660
%1661 = load double, double* %28
%1662 = load double*, double** %25
%1663 = getelementptr inbounds double, double* %1662, i64 1
store double %1661, double* %1663
%1664 = load double, double* %29
%1665 = load double*, double** %25
%1666 = getelementptr inbounds double, double* %1665, i64 2
store double %1664, double* %1666
%1667 = load double, double* %30
%1668 = load double*, double** %25
%1669 = getelementptr inbounds double, double* %1668, i64 3
store double %1667, double* %1669
%1670 = load double*, double** %25
%1671 = getelementptr inbounds double, double* %1670, i64 4
store double* %1671, double** %25
br label %1672
1672: ; preds = %1641, %1637
%1673 = load i32, i32* %7
%1674 = and i32 %1673, 1
%1675 = icmp ne i32 %1674, 0
br i1 %1675, label %1676, label %1695
1676: ; preds = %1672
%1677 = load double*, double** %14
%1678 = getelementptr inbounds double, double* %1677, i64 0
%1679 = load double, double* %1678
store double %1679, double* %27
%1680 = load double*, double** %14
%1681 = getelementptr inbounds double, double* %1680, i32 1
store double* %1681, double** %14
%1682 = load double*, double** %15
%1683 = getelementptr inbounds double, double* %1682, i64 0
%1684 = load double, double* %1683
store double %1684, double* %28
%1685 = load double*, double** %15
%1686 = getelementptr inbounds double, double* %1685, i32 1
store double* %1686, double** %15
%1687 = load double, double* %27
%1688 = load double*, double** %26
%1689 = getelementptr inbounds double, double* %1688, i64 0
store double %1687, double* %1689
%1690 = load double, double* %28
%1691 = load double*, double** %26
%1692 = getelementptr inbounds double, double* %1691, i64 1
store double %1690, double* %1692
%1693 = load double*, double** %26
%1694 = getelementptr inbounds double, double* %1693, i64 2
store double* %1694, double** %26
br label %1695
1695: ; preds = %1676, %1672
br label %1696
1696: ; preds = %1695, %1443
%1697 = load i32, i32* %6
%1698 = and i32 %1697, 1
%1699 = icmp ne i32 %1698, 0
br i1 %1699, label %1700, label %1846
1700: ; preds = %1696
%1701 = load double*, double** %13
store double* %1701, double** %14
%1702 = load i32, i32* %9
%1703 = load double*, double** %13
%1704 = sext i32 %1702 to i64
%1705 = getelementptr inbounds double, double* %1703, i64 %1704
store double* %1705, double** %13
%1706 = load double*, double** %22
store double* %1706, double** %23
%1707 = load double*, double** %22
%1708 = getelementptr inbounds double, double* %1707, i64 8
store double* %1708, double** %22
%1709 = load i32, i32* %7
%1710 = ashr i32 %1709, 3
store i32 %1710, i32* %11
%1711 = load i32, i32* %11
%1712 = icmp sgt i32 %1711, 0
br i1 %1712, label %1713, label %1776
1713: ; preds = %1700
br label %1714
1714: ; preds = %1772, %1713
%1715 = load double*, double** %14
%1716 = getelementptr inbounds double, double* %1715, i64 0
%1717 = load double, double* %1716
store double %1717, double* %27
%1718 = load double*, double** %14
%1719 = getelementptr inbounds double, double* %1718, i64 1
%1720 = load double, double* %1719
store double %1720, double* %28
%1721 = load double*, double** %14
%1722 = getelementptr inbounds double, double* %1721, i64 2
%1723 = load double, double* %1722
store double %1723, double* %29
%1724 = load double*, double** %14
%1725 = getelementptr inbounds double, double* %1724, i64 3
%1726 = load double, double* %1725
store double %1726, double* %30
%1727 = load double*, double** %14
%1728 = getelementptr inbounds double, double* %1727, i64 4
%1729 = load double, double* %1728
store double %1729, double* %31
%1730 = load double*, double** %14
%1731 = getelementptr inbounds double, double* %1730, i64 5
%1732 = load double, double* %1731
store double %1732, double* %32
%1733 = load double*, double** %14
%1734 = getelementptr inbounds double, double* %1733, i64 6
%1735 = load double, double* %1734
store double %1735, double* %33
%1736 = load double*, double** %14
%1737 = getelementptr inbounds double, double* %1736, i64 7
%1738 = load double, double* %1737
store double %1738, double* %34
%1739 = load double*, double** %14
%1740 = getelementptr inbounds double, double* %1739, i64 8
store double* %1740, double** %14
%1741 = load double, double* %27
%1742 = load double*, double** %23
%1743 = getelementptr inbounds double, double* %1742, i64 0
store double %1741, double* %1743
%1744 = load double, double* %28
%1745 = load double*, double** %23
%1746 = getelementptr inbounds double, double* %1745, i64 1
store double %1744, double* %1746
%1747 = load double, double* %29
%1748 = load double*, double** %23
%1749 = getelementptr inbounds double, double* %1748, i64 2
store double %1747, double* %1749
%1750 = load double, double* %30
%1751 = load double*, double** %23
%1752 = getelementptr inbounds double, double* %1751, i64 3
store double %1750, double* %1752
%1753 = load double, double* %31
%1754 = load double*, double** %23
%1755 = getelementptr inbounds double, double* %1754, i64 4
store double %1753, double* %1755
%1756 = load double, double* %32
%1757 = load double*, double** %23
%1758 = getelementptr inbounds double, double* %1757, i64 5
store double %1756, double* %1758
%1759 = load double, double* %33
%1760 = load double*, double** %23
%1761 = getelementptr inbounds double, double* %1760, i64 6
store double %1759, double* %1761
%1762 = load double, double* %34
%1763 = load double*, double** %23
%1764 = getelementptr inbounds double, double* %1763, i64 7
store double %1762, double* %1764
%1765 = load i32, i32* %6
%1766 = mul nsw i32 8, %1765
%1767 = load double*, double** %23
%1768 = sext i32 %1766 to i64
%1769 = getelementptr inbounds double, double* %1767, i64 %1768
store double* %1769, double** %23
%1770 = load i32, i32* %11
%1771 = add nsw i32 %1770, -1
store i32 %1771, i32* %11
br label %1772
1772: ; preds = %1714
%1773 = load i32, i32* %11
%1774 = icmp sgt i32 %1773, 0
br i1 %1774, label %1714, label %1775
1775: ; preds = %1772
br label %1776
1776: ; preds = %1775, %1700
%1777 = load i32, i32* %7
%1778 = and i32 %1777, 4
%1779 = icmp ne i32 %1778, 0
br i1 %1779, label %1780, label %1809
1780: ; preds = %1776
%1781 = load double*, double** %14
%1782 = getelementptr inbounds double, double* %1781, i64 0
%1783 = load double, double* %1782
store double %1783, double* %27
%1784 = load double*, double** %14
%1785 = getelementptr inbounds double, double* %1784, i64 1
%1786 = load double, double* %1785
store double %1786, double* %28
%1787 = load double*, double** %14
%1788 = getelementptr inbounds double, double* %1787, i64 2
%1789 = load double, double* %1788
store double %1789, double* %29
%1790 = load double*, double** %14
%1791 = getelementptr inbounds double, double* %1790, i64 3
%1792 = load double, double* %1791
store double %1792, double* %30
%1793 = load double*, double** %14
%1794 = getelementptr inbounds double, double* %1793, i64 4
store double* %1794, double** %14
%1795 = load double, double* %27
%1796 = load double*, double** %24
%1797 = getelementptr inbounds double, double* %1796, i64 0
store double %1795, double* %1797
%1798 = load double, double* %28
%1799 = load double*, double** %24
%1800 = getelementptr inbounds double, double* %1799, i64 1
store double %1798, double* %1800
%1801 = load double, double* %29
%1802 = load double*, double** %24
%1803 = getelementptr inbounds double, double* %1802, i64 2
store double %1801, double* %1803
%1804 = load double, double* %30
%1805 = load double*, double** %24
%1806 = getelementptr inbounds double, double* %1805, i64 3
store double %1804, double* %1806
%1807 = load double*, double** %24
%1808 = getelementptr inbounds double, double* %1807, i64 4
store double* %1808, double** %24
br label %1809
1809: ; preds = %1780, %1776
%1810 = load i32, i32* %7
%1811 = and i32 %1810, 2
%1812 = icmp ne i32 %1811, 0
br i1 %1812, label %1813, label %1830
1813: ; preds = %1809
%1814 = load double*, double** %14
%1815 = getelementptr inbounds double, double* %1814, i64 0
%1816 = load double, double* %1815
store double %1816, double* %27
%1817 = load double*, double** %14
%1818 = getelementptr inbounds double, double* %1817, i64 1
%1819 = load double, double* %1818
store double %1819, double* %28
%1820 = load double*, double** %14
%1821 = getelementptr inbounds double, double* %1820, i64 2
store double* %1821, double** %14
%1822 = load double, double* %27
%1823 = load double*, double** %25
%1824 = getelementptr inbounds double, double* %1823, i64 0
store double %1822, double* %1824
%1825 = load double, double* %28
%1826 = load double*, double** %25
%1827 = getelementptr inbounds double, double* %1826, i64 1
store double %1825, double* %1827
%1828 = load double*, double** %25
%1829 = getelementptr inbounds double, double* %1828, i64 2
store double* %1829, double** %25
br label %1830
1830: ; preds = %1813, %1809
%1831 = load i32, i32* %7
%1832 = and i32 %1831, 1
%1833 = icmp ne i32 %1832, 0
br i1 %1833, label %1834, label %1845
1834: ; preds = %1830
%1835 = load double*, double** %14
%1836 = getelementptr inbounds double, double* %1835, i64 0
%1837 = load double, double* %1836
store double %1837, double* %27
%1838 = load double*, double** %14
%1839 = getelementptr inbounds double, double* %1838, i32 1
store double* %1839, double** %14
%1840 = load double, double* %27
%1841 = load double*, double** %26
%1842 = getelementptr inbounds double, double* %1841, i64 0
store double %1840, double* %1842
%1843 = load double*, double** %26
%1844 = getelementptr inbounds double, double* %1843, i32 1
store double* %1844, double** %26
br label %1845
1845: ; preds = %1834, %1830
br label %1846
1846: ; preds = %1845, %1696
ret i32 0
}

LLVM IR (-O2):
define i32 @tcopy_8(i32 %0, i32 %1, double* nocapture %2, i32 %3, double* writeonly %4) {
%6 = and i32 %1, -8
%7 = mul nsw i32 %6, %0
%8 = sext i32 %7 to i64
%9 = getelementptr inbounds double, double* %4, i64 %8
%10 = and i32 %1, -4
%11 = mul nsw i32 %10, %0
%12 = sext i32 %11 to i64
%13 = getelementptr inbounds double, double* %4, i64 %12
%14 = and i32 %1, -2
%15 = mul nsw i32 %14, %0
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds double, double* %4, i64 %16
%18 = icmp sgt i32 %0, 7
br i1 %18, label %19, label %395
19: ; preds = %5
%20 = lshr i32 %0, 3
%21 = sext i32 %3 to i64
%22 = shl nsw i32 %3, 3
%23 = sext i32 %22 to i64
%24 = ashr i32 %1, 3
%25 = icmp sgt i32 %1, 7
%26 = and i32 %1, 4
%27 = icmp eq i32 %26, 0
%28 = and i32 %1, 2
%29 = icmp eq i32 %28, 0
%30 = and i32 %1, 1
%31 = icmp eq i32 %30, 0
%32 = shl nsw i32 %0, 3
%33 = sext i32 %32 to i64
br label %34
34: ; preds = %19, %391
%35 = phi double* [ %392, %391 ], [ %17, %19 ]
%36 = phi double* [ %365, %391 ], [ %13, %19 ]
%37 = phi double* [ %314, %391 ], [ %9, %19 ]
%38 = phi double* [ %49, %391 ], [ %4, %19 ]
%39 = phi double* [ %48, %391 ], [ %2, %19 ]
%40 = phi i32 [ %393, %391 ], [ %20, %19 ]
%41 = getelementptr inbounds double, double* %39, i64 %21
%42 = getelementptr inbounds double, double* %41, i64 %21
%43 = getelementptr inbounds double, double* %42, i64 %21
%44 = getelementptr inbounds double, double* %43, i64 %21
%45 = getelementptr inbounds double, double* %44, i64 %21
%46 = getelementptr inbounds double, double* %45, i64 %21
%47 = getelementptr inbounds double, double* %46, i64 %21
%48 = getelementptr inbounds double, double* %39, i64 %23
%49 = getelementptr inbounds double, double* %38, i64 64
br i1 %25, label %50, label %223
50: ; preds = %34, %50
%51 = phi double* [ %220, %50 ], [ %38, %34 ]
%52 = phi double* [ %156, %50 ], [ %47, %34 ]
%53 = phi double* [ %144, %50 ], [ %46, %34 ]
%54 = phi double* [ %132, %50 ], [ %45, %34 ]
%55 = phi double* [ %120, %50 ], [ %44, %34 ]
%56 = phi double* [ %108, %50 ], [ %43, %34 ]
%57 = phi double* [ %96, %50 ], [ %42, %34 ]
%58 = phi double* [ %84, %50 ], [ %41, %34 ]
%59 = phi double* [ %72, %50 ], [ %39, %34 ]
%60 = phi i32 [ %221, %50 ], [ %24, %34 ]
%61 = bitcast double* %59 to <2 x double>*
%62 = load <2 x double>, <2 x double>* %61
%63 = getelementptr inbounds double, double* %59, i64 2
%64 = bitcast double* %63 to <2 x double>*
%65 = load <2 x double>, <2 x double>* %64
%66 = getelementptr inbounds double, double* %59, i64 4
%67 = bitcast double* %66 to <2 x double>*
%68 = load <2 x double>, <2 x double>* %67
%69 = getelementptr inbounds double, double* %59, i64 6
%70 = bitcast double* %69 to <2 x double>*
%71 = load <2 x double>, <2 x double>* %70
%72 = getelementptr inbounds double, double* %59, i64 8
%73 = bitcast double* %58 to <2 x double>*
%74 = load <2 x double>, <2 x double>* %73
%75 = getelementptr inbounds double, double* %58, i64 2
%76 = bitcast double* %75 to <2 x double>*
%77 = load <2 x double>, <2 x double>* %76
%78 = getelementptr inbounds double, double* %58, i64 4
%79 = bitcast double* %78 to <2 x double>*
%80 = load <2 x double>, <2 x double>* %79
%81 = getelementptr inbounds double, double* %58, i64 6
%82 = bitcast double* %81 to <2 x double>*
%83 = load <2 x double>, <2 x double>* %82
%84 = getelementptr inbounds double, double* %58, i64 8
%85 = bitcast double* %57 to <2 x double>*
%86 = load <2 x double>, <2 x double>* %85
%87 = getelementptr inbounds double, double* %57, i64 2
%88 = bitcast double* %87 to <2 x double>*
%89 = load <2 x double>, <2 x double>* %88
%90 = getelementptr inbounds double, double* %57, i64 4
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = getelementptr inbounds double, double* %57, i64 6
%94 = bitcast double* %93 to <2 x double>*
%95 = load <2 x double>, <2 x double>* %94
%96 = getelementptr inbounds double, double* %57, i64 8
%97 = bitcast double* %56 to <2 x double>*
%98 = load <2 x double>, <2 x double>* %97
%99 = getelementptr inbounds double, double* %56, i64 2
%100 = bitcast double* %99 to <2 x double>*
%101 = load <2 x double>, <2 x double>* %100
%102 = getelementptr inbounds double, double* %56, i64 4
%103 = bitcast double* %102 to <2 x double>*
%104 = load <2 x double>, <2 x double>* %103
%105 = getelementptr inbounds double, double* %56, i64 6
%106 = bitcast double* %105 to <2 x double>*
%107 = load <2 x double>, <2 x double>* %106
%108 = getelementptr inbounds double, double* %56, i64 8
%109 = bitcast double* %55 to <2 x double>*
%110 = load <2 x double>, <2 x double>* %109
%111 = getelementptr inbounds double, double* %55, i64 2
%112 = bitcast double* %111 to <2 x double>*
%113 = load <2 x double>, <2 x double>* %112
%114 = getelementptr inbounds double, double* %55, i64 4
%115 = bitcast double* %114 to <2 x double>*
%116 = load <2 x double>, <2 x double>* %115
%117 = getelementptr inbounds double, double* %55, i64 6
%118 = bitcast double* %117 to <2 x double>*
%119 = load <2 x double>, <2 x double>* %118
%120 = getelementptr inbounds double, double* %55, i64 8
%121 = bitcast double* %54 to <2 x double>*
%122 = load <2 x double>, <2 x double>* %121
%123 = getelementptr inbounds double, double* %54, i64 2
%124 = bitcast double* %123 to <2 x double>*
%125 = load <2 x double>, <2 x double>* %124
%126 = getelementptr inbounds double, double* %54, i64 4
%127 = bitcast double* %126 to <2 x double>*
%128 = load <2 x double>, <2 x double>* %127
%129 = getelementptr inbounds double, double* %54, i64 6
%130 = bitcast double* %129 to <2 x double>*
%131 = load <2 x double>, <2 x double>* %130
%132 = getelementptr inbounds double, double* %54, i64 8
%133 = bitcast double* %53 to <2 x double>*
%134 = load <2 x double>, <2 x double>* %133
%135 = getelementptr inbounds double, double* %53, i64 2
%136 = bitcast double* %135 to <2 x double>*
%137 = load <2 x double>, <2 x double>* %136
%138 = getelementptr inbounds double, double* %53, i64 4
%139 = bitcast double* %138 to <2 x double>*
%140 = load <2 x double>, <2 x double>* %139
%141 = getelementptr inbounds double, double* %53, i64 6
%142 = bitcast double* %141 to <2 x double>*
%143 = load <2 x double>, <2 x double>* %142
%144 = getelementptr inbounds double, double* %53, i64 8
%145 = bitcast double* %52 to <2 x double>*
%146 = load <2 x double>, <2 x double>* %145
%147 = getelementptr inbounds double, double* %52, i64 2
%148 = bitcast double* %147 to <2 x double>*
%149 = load <2 x double>, <2 x double>* %148
%150 = getelementptr inbounds double, double* %52, i64 4
%151 = bitcast double* %150 to <2 x double>*
%152 = load <2 x double>, <2 x double>* %151
%153 = getelementptr inbounds double, double* %52, i64 6
%154 = bitcast double* %153 to <2 x double>*
%155 = load <2 x double>, <2 x double>* %154
%156 = getelementptr inbounds double, double* %52, i64 8
%157 = bitcast double* %51 to <2 x double>*
store <2 x double> %62, <2 x double>* %157
%158 = getelementptr inbounds double, double* %51, i64 2
%159 = bitcast double* %158 to <2 x double>*
store <2 x double> %65, <2 x double>* %159
%160 = getelementptr inbounds double, double* %51, i64 4
%161 = bitcast double* %160 to <2 x double>*
store <2 x double> %68, <2 x double>* %161
%162 = getelementptr inbounds double, double* %51, i64 6
%163 = bitcast double* %162 to <2 x double>*
store <2 x double> %71, <2 x double>* %163
%164 = getelementptr inbounds double, double* %51, i64 8
%165 = bitcast double* %164 to <2 x double>*
store <2 x double> %74, <2 x double>* %165
%166 = getelementptr inbounds double, double* %51, i64 10
%167 = bitcast double* %166 to <2 x double>*
store <2 x double> %77, <2 x double>* %167
%168 = getelementptr inbounds double, double* %51, i64 12
%169 = bitcast double* %168 to <2 x double>*
store <2 x double> %80, <2 x double>* %169
%170 = getelementptr inbounds double, double* %51, i64 14
%171 = bitcast double* %170 to <2 x double>*
store <2 x double> %83, <2 x double>* %171
%172 = getelementptr inbounds double, double* %51, i64 16
%173 = bitcast double* %172 to <2 x double>*
store <2 x double> %86, <2 x double>* %173
%174 = getelementptr inbounds double, double* %51, i64 18
%175 = bitcast double* %174 to <2 x double>*
store <2 x double> %89, <2 x double>* %175
%176 = getelementptr inbounds double, double* %51, i64 20
%177 = bitcast double* %176 to <2 x double>*
store <2 x double> %92, <2 x double>* %177
%178 = getelementptr inbounds double, double* %51, i64 22
%179 = bitcast double* %178 to <2 x double>*
store <2 x double> %95, <2 x double>* %179
%180 = getelementptr inbounds double, double* %51, i64 24
%181 = bitcast double* %180 to <2 x double>*
store <2 x double> %98, <2 x double>* %181
%182 = getelementptr inbounds double, double* %51, i64 26
%183 = bitcast double* %182 to <2 x double>*
store <2 x double> %101, <2 x double>* %183
%184 = getelementptr inbounds double, double* %51, i64 28
%185 = bitcast double* %184 to <2 x double>*
store <2 x double> %104, <2 x double>* %185
%186 = getelementptr inbounds double, double* %51, i64 30
%187 = bitcast double* %186 to <2 x double>*
store <2 x double> %107, <2 x double>* %187
%188 = getelementptr inbounds double, double* %51, i64 32
%189 = bitcast double* %188 to <2 x double>*
store <2 x double> %110, <2 x double>* %189
%190 = getelementptr inbounds double, double* %51, i64 34
%191 = bitcast double* %190 to <2 x double>*
store <2 x double> %113, <2 x double>* %191
%192 = getelementptr inbounds double, double* %51, i64 36
%193 = bitcast double* %192 to <2 x double>*
store <2 x double> %116, <2 x double>* %193
%194 = getelementptr inbounds double, double* %51, i64 38
%195 = bitcast double* %194 to <2 x double>*
store <2 x double> %119, <2 x double>* %195
%196 = getelementptr inbounds double, double* %51, i64 40
%197 = bitcast double* %196 to <2 x double>*
store <2 x double> %122, <2 x double>* %197
%198 = getelementptr inbounds double, double* %51, i64 42
%199 = bitcast double* %198 to <2 x double>*
store <2 x double> %125, <2 x double>* %199
%200 = getelementptr inbounds double, double* %51, i64 44
%201 = bitcast double* %200 to <2 x double>*
store <2 x double> %128, <2 x double>* %201
%202 = getelementptr inbounds double, double* %51, i64 46
%203 = bitcast double* %202 to <2 x double>*
store <2 x double> %131, <2 x double>* %203
%204 = getelementptr inbounds double, double* %51, i64 48
%205 = bitcast double* %204 to <2 x double>*
store <2 x double> %134, <2 x double>* %205
%206 = getelementptr inbounds double, double* %51, i64 50
%207 = bitcast double* %206 to <2 x double>*
store <2 x double> %137, <2 x double>* %207
%208 = getelementptr inbounds double, double* %51, i64 52
%209 = bitcast double* %208 to <2 x double>*
store <2 x double> %140, <2 x double>* %209
%210 = getelementptr inbounds double, double* %51, i64 54
%211 = bitcast double* %210 to <2 x double>*
store <2 x double> %143, <2 x double>* %211
%212 = getelementptr inbounds double, double* %51, i64 56
%213 = bitcast double* %212 to <2 x double>*
store <2 x double> %146, <2 x double>* %213
%214 = getelementptr inbounds double, double* %51, i64 58
%215 = bitcast double* %214 to <2 x double>*
store <2 x double> %149, <2 x double>* %215
%216 = getelementptr inbounds double, double* %51, i64 60
%217 = bitcast double* %216 to <2 x double>*
store <2 x double> %152, <2 x double>* %217
%218 = getelementptr inbounds double, double* %51, i64 62
%219 = bitcast double* %218 to <2 x double>*
store <2 x double> %155, <2 x double>* %219
%220 = getelementptr inbounds double, double* %51, i64 %33
%221 = add nsw i32 %60, -1
%222 = icmp sgt i32 %60, 1
br i1 %222, label %50, label %223
223: ; preds = %50, %34
%224 = phi double* [ %47, %34 ], [ %156, %50 ]
%225 = phi double* [ %46, %34 ], [ %144, %50 ]
%226 = phi double* [ %45, %34 ], [ %132, %50 ]
%227 = phi double* [ %44, %34 ], [ %120, %50 ]
%228 = phi double* [ %43, %34 ], [ %108, %50 ]
%229 = phi double* [ %42, %34 ], [ %96, %50 ]
%230 = phi double* [ %41, %34 ], [ %84, %50 ]
%231 = phi double* [ %39, %34 ], [ %72, %50 ]
br i1 %27, label %313, label %232
232: ; preds = %223
%233 = bitcast double* %231 to <2 x double>*
%234 = load <2 x double>, <2 x double>* %233
%235 = getelementptr inbounds double, double* %231, i64 2
%236 = bitcast double* %235 to <2 x double>*
%237 = load <2 x double>, <2 x double>* %236
%238 = getelementptr inbounds double, double* %231, i64 4
%239 = bitcast double* %230 to <2 x double>*
%240 = load <2 x double>, <2 x double>* %239
%241 = getelementptr inbounds double, double* %230, i64 2
%242 = bitcast double* %241 to <2 x double>*
%243 = load <2 x double>, <2 x double>* %242
%244 = getelementptr inbounds double, double* %230, i64 4
%245 = bitcast double* %229 to <2 x double>*
%246 = load <2 x double>, <2 x double>* %245
%247 = getelementptr inbounds double, double* %229, i64 2
%248 = bitcast double* %247 to <2 x double>*
%249 = load <2 x double>, <2 x double>* %248
%250 = getelementptr inbounds double, double* %229, i64 4
%251 = bitcast double* %228 to <2 x double>*
%252 = load <2 x double>, <2 x double>* %251
%253 = getelementptr inbounds double, double* %228, i64 2
%254 = bitcast double* %253 to <2 x double>*
%255 = load <2 x double>, <2 x double>* %254
%256 = getelementptr inbounds double, double* %228, i64 4
%257 = bitcast double* %227 to <2 x double>*
%258 = load <2 x double>, <2 x double>* %257
%259 = getelementptr inbounds double, double* %227, i64 2
%260 = bitcast double* %259 to <2 x double>*
%261 = load <2 x double>, <2 x double>* %260
%262 = getelementptr inbounds double, double* %227, i64 4
%263 = bitcast double* %226 to <2 x double>*
%264 = load <2 x double>, <2 x double>* %263
%265 = getelementptr inbounds double, double* %226, i64 2
%266 = bitcast double* %265 to <2 x double>*
%267 = load <2 x double>, <2 x double>* %266
%268 = getelementptr inbounds double, double* %226, i64 4
%269 = bitcast double* %225 to <2 x double>*
%270 = load <2 x double>, <2 x double>* %269
%271 = getelementptr inbounds double, double* %225, i64 2
%272 = bitcast double* %271 to <2 x double>*
%273 = load <2 x double>, <2 x double>* %272
%274 = getelementptr inbounds double, double* %225, i64 4
%275 = bitcast double* %224 to <2 x double>*
%276 = load <2 x double>, <2 x double>* %275
%277 = getelementptr inbounds double, double* %224, i64 2
%278 = bitcast double* %277 to <2 x double>*
%279 = load <2 x double>, <2 x double>* %278
%280 = getelementptr inbounds double, double* %224, i64 4
%281 = bitcast double* %37 to <2 x double>*
store <2 x double> %234, <2 x double>* %281
%282 = getelementptr inbounds double, double* %37, i64 2
%283 = bitcast double* %282 to <2 x double>*
store <2 x double> %237, <2 x double>* %283
%284 = getelementptr inbounds double, double* %37, i64 4
%285 = bitcast double* %284 to <2 x double>*
store <2 x double> %240, <2 x double>* %285
%286 = getelementptr inbounds double, double* %37, i64 6
%287 = bitcast double* %286 to <2 x double>*
store <2 x double> %243, <2 x double>* %287
%288 = getelementptr inbounds double, double* %37, i64 8
%289 = bitcast double* %288 to <2 x double>*
store <2 x double> %246, <2 x double>* %289
%290 = getelementptr inbounds double, double* %37, i64 10
%291 = bitcast double* %290 to <2 x double>*
store <2 x double> %249, <2 x double>* %291
%292 = getelementptr inbounds double, double* %37, i64 12
%293 = bitcast double* %292 to <2 x double>*
store <2 x double> %252, <2 x double>* %293
%294 = getelementptr inbounds double, double* %37, i64 14
%295 = bitcast double* %294 to <2 x double>*
store <2 x double> %255, <2 x double>* %295
%296 = getelementptr inbounds double, double* %37, i64 16
%297 = bitcast double* %296 to <2 x double>*
store <2 x double> %258, <2 x double>* %297
%298 = getelementptr inbounds double, double* %37, i64 18
%299 = bitcast double* %298 to <2 x double>*
store <2 x double> %261, <2 x double>* %299
%300 = getelementptr inbounds double, double* %37, i64 20
%301 = bitcast double* %300 to <2 x double>*
store <2 x double> %264, <2 x double>* %301
%302 = getelementptr inbounds double, double* %37, i64 22
%303 = bitcast double* %302 to <2 x double>*
store <2 x double> %267, <2 x double>* %303
%304 = getelementptr inbounds double, double* %37, i64 24
%305 = bitcast double* %304 to <2 x double>*
store <2 x double> %270, <2 x double>* %305
%306 = getelementptr inbounds double, double* %37, i64 26
%307 = bitcast double* %306 to <2 x double>*
store <2 x double> %273, <2 x double>* %307
%308 = getelementptr inbounds double, double* %37, i64 28
%309 = bitcast double* %308 to <2 x double>*
store <2 x double> %276, <2 x double>* %309
%310 = getelementptr inbounds double, double* %37, i64 30
%311 = bitcast double* %310 to <2 x double>*
store <2 x double> %279, <2 x double>* %311
%312 = getelementptr inbounds double, double* %37, i64 32
br label %313
313: ; preds = %232, %223
%314 = phi double* [ %312, %232 ], [ %37, %223 ]
%315 = phi double* [ %280, %232 ], [ %224, %223 ]
%316 = phi double* [ %274, %232 ], [ %225, %223 ]
%317 = phi double* [ %268, %232 ], [ %226, %223 ]
%318 = phi double* [ %262, %232 ], [ %227, %223 ]
%319 = phi double* [ %256, %232 ], [ %228, %223 ]
%320 = phi double* [ %250, %232 ], [ %229, %223 ]
%321 = phi double* [ %244, %232 ], [ %230, %223 ]
%322 = phi double* [ %238, %232 ], [ %231, %223 ]
br i1 %29, label %364, label %323
323: ; preds = %313
%324 = bitcast double* %322 to <2 x double>*
%325 = load <2 x double>, <2 x double>* %324
%326 = getelementptr inbounds double, double* %322, i64 2
%327 = bitcast double* %321 to <2 x double>*
%328 = load <2 x double>, <2 x double>* %327
%329 = getelementptr inbounds double, double* %321, i64 2
%330 = bitcast double* %320 to <2 x double>*
%331 = load <2 x double>, <2 x double>* %330
%332 = getelementptr inbounds double, double* %320, i64 2
%333 = bitcast double* %319 to <2 x double>*
%334 = load <2 x double>, <2 x double>* %333
%335 = getelementptr inbounds double, double* %319, i64 2
%336 = bitcast double* %318 to <2 x double>*
%337 = load <2 x double>, <2 x double>* %336
%338 = getelementptr inbounds double, double* %318, i64 2
%339 = bitcast double* %317 to <2 x double>*
%340 = load <2 x double>, <2 x double>* %339
%341 = getelementptr inbounds double, double* %317, i64 2
%342 = bitcast double* %316 to <2 x double>*
%343 = load <2 x double>, <2 x double>* %342
%344 = getelementptr inbounds double, double* %316, i64 2
%345 = bitcast double* %315 to <2 x double>*
%346 = load <2 x double>, <2 x double>* %345
%347 = getelementptr inbounds double, double* %315, i64 2
%348 = bitcast double* %36 to <2 x double>*
store <2 x double> %325, <2 x double>* %348
%349 = getelementptr inbounds double, double* %36, i64 2
%350 = bitcast double* %349 to <2 x double>*
store <2 x double> %328, <2 x double>* %350
%351 = getelementptr inbounds double, double* %36, i64 4
%352 = bitcast double* %351 to <2 x double>*
store <2 x double> %331, <2 x double>* %352
%353 = getelementptr inbounds double, double* %36, i64 6
%354 = bitcast double* %353 to <2 x double>*
store <2 x double> %334, <2 x double>* %354
%355 = getelementptr inbounds double, double* %36, i64 8
%356 = bitcast double* %355 to <2 x double>*
store <2 x double> %337, <2 x double>* %356
%357 = getelementptr inbounds double, double* %36, i64 10
%358 = bitcast double* %357 to <2 x double>*
store <2 x double> %340, <2 x double>* %358
%359 = getelementptr inbounds double, double* %36, i64 12
%360 = bitcast double* %359 to <2 x double>*
store <2 x double> %343, <2 x double>* %360
%361 = getelementptr inbounds double, double* %36, i64 14
%362 = bitcast double* %361 to <2 x double>*
store <2 x double> %346, <2 x double>* %362
%363 = getelementptr inbounds double, double* %36, i64 16
br label %364
364: ; preds = %323, %313
%365 = phi double* [ %363, %323 ], [ %36, %313 ]
%366 = phi double* [ %347, %323 ], [ %315, %313 ]
%367 = phi double* [ %344, %323 ], [ %316, %313 ]
%368 = phi double* [ %341, %323 ], [ %317, %313 ]
%369 = phi double* [ %338, %323 ], [ %318, %313 ]
%370 = phi double* [ %335, %323 ], [ %319, %313 ]
%371 = phi double* [ %332, %323 ], [ %320, %313 ]
%372 = phi double* [ %329, %323 ], [ %321, %313 ]
%373 = phi double* [ %326, %323 ], [ %322, %313 ]
br i1 %31, label %391, label %374
374: ; preds = %364
%375 = load double, double* %373
%376 = load double, double* %372
%377 = load double, double* %371
%378 = load double, double* %370
%379 = load double, double* %369
%380 = load double, double* %368
%381 = load double, double* %367
%382 = load double, double* %366
store double %375, double* %35
%383 = getelementptr inbounds double, double* %35, i64 1
store double %376, double* %383
%384 = getelementptr inbounds double, double* %35, i64 2
store double %377, double* %384
%385 = getelementptr inbounds double, double* %35, i64 3
store double %378, double* %385
%386 = getelementptr inbounds double, double* %35, i64 4
store double %379, double* %386
%387 = getelementptr inbounds double, double* %35, i64 5
store double %380, double* %387
%388 = getelementptr inbounds double, double* %35, i64 6
store double %381, double* %388
%389 = getelementptr inbounds double, double* %35, i64 7
store double %382, double* %389
%390 = getelementptr inbounds double, double* %35, i64 8
br label %391
391: ; preds = %374, %364
%392 = phi double* [ %390, %374 ], [ %35, %364 ]
%393 = add nsw i32 %40, -1
%394 = icmp sgt i32 %40, 1
br i1 %394, label %34, label %395
395: ; preds = %391, %5
%396 = phi double* [ %17, %5 ], [ %392, %391 ]
%397 = phi double* [ %13, %5 ], [ %365, %391 ]
%398 = phi double* [ %9, %5 ], [ %314, %391 ]
%399 = phi double* [ %4, %5 ], [ %49, %391 ]
%400 = phi double* [ %2, %5 ], [ %48, %391 ]
%401 = and i32 %0, 4
%402 = icmp eq i32 %401, 0
br i1 %402, label %600, label %403
403: ; preds = %395
%404 = sext i32 %3 to i64
%405 = getelementptr inbounds double, double* %400, i64 %404
%406 = getelementptr inbounds double, double* %405, i64 %404
%407 = getelementptr inbounds double, double* %406, i64 %404
%408 = shl nsw i32 %3, 2
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds double, double* %400, i64 %409
%411 = getelementptr inbounds double, double* %399, i64 32
%412 = icmp sgt i32 %1, 7
br i1 %412, label %413, label %506
413: ; preds = %403
%414 = lshr i32 %1, 3
%415 = shl nsw i32 %0, 3
%416 = sext i32 %415 to i64
br label %417
417: ; preds = %413, %417
%418 = phi double* [ %503, %417 ], [ %399, %413 ]
%419 = phi double* [ %471, %417 ], [ %407, %413 ]
%420 = phi double* [ %459, %417 ], [ %406, %413 ]
%421 = phi double* [ %447, %417 ], [ %405, %413 ]
%422 = phi double* [ %435, %417 ], [ %400, %413 ]
%423 = phi i32 [ %504, %417 ], [ %414, %413 ]
%424 = bitcast double* %422 to <2 x double>*
%425 = load <2 x double>, <2 x double>* %424
%426 = getelementptr inbounds double, double* %422, i64 2
%427 = bitcast double* %426 to <2 x double>*
%428 = load <2 x double>, <2 x double>* %427
%429 = getelementptr inbounds double, double* %422, i64 4
%430 = bitcast double* %429 to <2 x double>*
%431 = load <2 x double>, <2 x double>* %430
%432 = getelementptr inbounds double, double* %422, i64 6
%433 = bitcast double* %432 to <2 x double>*
%434 = load <2 x double>, <2 x double>* %433
%435 = getelementptr inbounds double, double* %422, i64 8
%436 = bitcast double* %421 to <2 x double>*
%437 = load <2 x double>, <2 x double>* %436
%438 = getelementptr inbounds double, double* %421, i64 2
%439 = bitcast double* %438 to <2 x double>*
%440 = load <2 x double>, <2 x double>* %439
%441 = getelementptr inbounds double, double* %421, i64 4
%442 = bitcast double* %441 to <2 x double>*
%443 = load <2 x double>, <2 x double>* %442
%444 = getelementptr inbounds double, double* %421, i64 6
%445 = bitcast double* %444 to <2 x double>*
%446 = load <2 x double>, <2 x double>* %445
%447 = getelementptr inbounds double, double* %421, i64 8
%448 = bitcast double* %420 to <2 x double>*
%449 = load <2 x double>, <2 x double>* %448
%450 = getelementptr inbounds double, double* %420, i64 2
%451 = bitcast double* %450 to <2 x double>*
%452 = load <2 x double>, <2 x double>* %451
%453 = getelementptr inbounds double, double* %420, i64 4
%454 = bitcast double* %453 to <2 x double>*
%455 = load <2 x double>, <2 x double>* %454
%456 = getelementptr inbounds double, double* %420, i64 6
%457 = bitcast double* %456 to <2 x double>*
%458 = load <2 x double>, <2 x double>* %457
%459 = getelementptr inbounds double, double* %420, i64 8
%460 = bitcast double* %419 to <2 x double>*
%461 = load <2 x double>, <2 x double>* %460
%462 = getelementptr inbounds double, double* %419, i64 2
%463 = bitcast double* %462 to <2 x double>*
%464 = load <2 x double>, <2 x double>* %463
%465 = getelementptr inbounds double, double* %419, i64 4
%466 = bitcast double* %465 to <2 x double>*
%467 = load <2 x double>, <2 x double>* %466
%468 = getelementptr inbounds double, double* %419, i64 6
%469 = bitcast double* %468 to <2 x double>*
%470 = load <2 x double>, <2 x double>* %469
%471 = getelementptr inbounds double, double* %419, i64 8
%472 = bitcast double* %418 to <2 x double>*
store <2 x double> %425, <2 x double>* %472
%473 = getelementptr inbounds double, double* %418, i64 2
%474 = bitcast double* %473 to <2 x double>*
store <2 x double> %428, <2 x double>* %474
%475 = getelementptr inbounds double, double* %418, i64 4
%476 = bitcast double* %475 to <2 x double>*
store <2 x double> %431, <2 x double>* %476
%477 = getelementptr inbounds double, double* %418, i64 6
%478 = bitcast double* %477 to <2 x double>*
store <2 x double> %434, <2 x double>* %478
%479 = getelementptr inbounds double, double* %418, i64 8
%480 = bitcast double* %479 to <2 x double>*
store <2 x double> %437, <2 x double>* %480
%481 = getelementptr inbounds double, double* %418, i64 10
%482 = bitcast double* %481 to <2 x double>*
store <2 x double> %440, <2 x double>* %482
%483 = getelementptr inbounds double, double* %418, i64 12
%484 = bitcast double* %483 to <2 x double>*
store <2 x double> %443, <2 x double>* %484
%485 = getelementptr inbounds double, double* %418, i64 14
%486 = bitcast double* %485 to <2 x double>*
store <2 x double> %446, <2 x double>* %486
%487 = getelementptr inbounds double, double* %418, i64 16
%488 = bitcast double* %487 to <2 x double>*
store <2 x double> %449, <2 x double>* %488
%489 = getelementptr inbounds double, double* %418, i64 18
%490 = bitcast double* %489 to <2 x double>*
store <2 x double> %452, <2 x double>* %490
%491 = getelementptr inbounds double, double* %418, i64 20
%492 = bitcast double* %491 to <2 x double>*
store <2 x double> %455, <2 x double>* %492
%493 = getelementptr inbounds double, double* %418, i64 22
%494 = bitcast double* %493 to <2 x double>*
store <2 x double> %458, <2 x double>* %494
%495 = getelementptr inbounds double, double* %418, i64 24
%496 = bitcast double* %495 to <2 x double>*
store <2 x double> %461, <2 x double>* %496
%497 = getelementptr inbounds double, double* %418, i64 26
%498 = bitcast double* %497 to <2 x double>*
store <2 x double> %464, <2 x double>* %498
%499 = getelementptr inbounds double, double* %418, i64 28
%500 = bitcast double* %499 to <2 x double>*
store <2 x double> %467, <2 x double>* %500
%501 = getelementptr inbounds double, double* %418, i64 30
%502 = bitcast double* %501 to <2 x double>*
store <2 x double> %470, <2 x double>* %502
%503 = getelementptr inbounds double, double* %418, i64 %416
%504 = add nsw i32 %423, -1
%505 = icmp ugt i32 %423, 1
br i1 %505, label %417, label %506
506: ; preds = %417, %403
%507 = phi double* [ %407, %403 ], [ %471, %417 ]
%508 = phi double* [ %406, %403 ], [ %459, %417 ]
%509 = phi double* [ %405, %403 ], [ %447, %417 ]
%510 = phi double* [ %400, %403 ], [ %435, %417 ]
%511 = and i32 %1, 4
%512 = icmp eq i32 %511, 0
br i1 %512, label %554, label %513
513: ; preds = %506
%514 = bitcast double* %510 to <2 x double>*
%515 = load <2 x double>, <2 x double>* %514
%516 = getelementptr inbounds double, double* %510, i64 2
%517 = bitcast double* %516 to <2 x double>*
%518 = load <2 x double>, <2 x double>* %517
%519 = getelementptr inbounds double, double* %510, i64 4
%520 = bitcast double* %509 to <2 x double>*
%521 = load <2 x double>, <2 x double>* %520
%522 = getelementptr inbounds double, double* %509, i64 2
%523 = bitcast double* %522 to <2 x double>*
%524 = load <2 x double>, <2 x double>* %523
%525 = getelementptr inbounds double, double* %509, i64 4
%526 = bitcast double* %508 to <2 x double>*
%527 = load <2 x double>, <2 x double>* %526
%528 = getelementptr inbounds double, double* %508, i64 2
%529 = bitcast double* %528 to <2 x double>*
%530 = load <2 x double>, <2 x double>* %529
%531 = getelementptr inbounds double, double* %508, i64 4
%532 = bitcast double* %507 to <2 x double>*
%533 = load <2 x double>, <2 x double>* %532
%534 = getelementptr inbounds double, double* %507, i64 2
%535 = bitcast double* %534 to <2 x double>*
%536 = load <2 x double>, <2 x double>* %535
%537 = getelementptr inbounds double, double* %507, i64 4
%538 = bitcast double* %398 to <2 x double>*
store <2 x double> %515, <2 x double>* %538
%539 = getelementptr inbounds double, double* %398, i64 2
%540 = bitcast double* %539 to <2 x double>*
store <2 x double> %518, <2 x double>* %540
%541 = getelementptr inbounds double, double* %398, i64 4
%542 = bitcast double* %541 to <2 x double>*
store <2 x double> %521, <2 x double>* %542
%543 = getelementptr inbounds double, double* %398, i64 6
%544 = bitcast double* %543 to <2 x double>*
store <2 x double> %524, <2 x double>* %544
%545 = getelementptr inbounds double, double* %398, i64 8
%546 = bitcast double* %545 to <2 x double>*
store <2 x double> %527, <2 x double>* %546
%547 = getelementptr inbounds double, double* %398, i64 10
%548 = bitcast double* %547 to <2 x double>*
store <2 x double> %530, <2 x double>* %548
%549 = getelementptr inbounds double, double* %398, i64 12
%550 = bitcast double* %549 to <2 x double>*
store <2 x double> %533, <2 x double>* %550
%551 = getelementptr inbounds double, double* %398, i64 14
%552 = bitcast double* %551 to <2 x double>*
store <2 x double> %536, <2 x double>* %552
%553 = getelementptr inbounds double, double* %398, i64 16
br label %554
554: ; preds = %513, %506
%555 = phi double* [ %553, %513 ], [ %398, %506 ]
%556 = phi double* [ %537, %513 ], [ %507, %506 ]
%557 = phi double* [ %531, %513 ], [ %508, %506 ]
%558 = phi double* [ %525, %513 ], [ %509, %506 ]
%559 = phi double* [ %519, %513 ], [ %510, %506 ]
%560 = and i32 %1, 2
%561 = icmp eq i32 %560, 0
br i1 %561, label %583, label %562
562: ; preds = %554
%563 = bitcast double* %559 to <2 x double>*
%564 = load <2 x double>, <2 x double>* %563
%565 = getelementptr inbounds double, double* %559, i64 2
%566 = bitcast double* %558 to <2 x double>*
%567 = load <2 x double>, <2 x double>* %566
%568 = getelementptr inbounds double, double* %558, i64 2
%569 = bitcast double* %557 to <2 x double>*
%570 = load <2 x double>, <2 x double>* %569
%571 = getelementptr inbounds double, double* %557, i64 2
%572 = bitcast double* %556 to <2 x double>*
%573 = load <2 x double>, <2 x double>* %572
%574 = getelementptr inbounds double, double* %556, i64 2
%575 = bitcast double* %397 to <2 x double>*
store <2 x double> %564, <2 x double>* %575
%576 = getelementptr inbounds double, double* %397, i64 2
%577 = bitcast double* %576 to <2 x double>*
store <2 x double> %567, <2 x double>* %577
%578 = getelementptr inbounds double, double* %397, i64 4
%579 = bitcast double* %578 to <2 x double>*
store <2 x double> %570, <2 x double>* %579
%580 = getelementptr inbounds double, double* %397, i64 6
%581 = bitcast double* %580 to <2 x double>*
store <2 x double> %573, <2 x double>* %581
%582 = getelementptr inbounds double, double* %397, i64 8
br label %583
583: ; preds = %562, %554
%584 = phi double* [ %582, %562 ], [ %397, %554 ]
%585 = phi double* [ %574, %562 ], [ %556, %554 ]
%586 = phi double* [ %571, %562 ], [ %557, %554 ]
%587 = phi double* [ %568, %562 ], [ %558, %554 ]
%588 = phi double* [ %565, %562 ], [ %559, %554 ]
%589 = and i32 %1, 1
%590 = icmp eq i32 %589, 0
br i1 %590, label %600, label %591
591: ; preds = %583
%592 = load double, double* %588
%593 = load double, double* %587
%594 = load double, double* %586
%595 = load double, double* %585
store double %592, double* %396
%596 = getelementptr inbounds double, double* %396, i64 1
store double %593, double* %596
%597 = getelementptr inbounds double, double* %396, i64 2
store double %594, double* %597
%598 = getelementptr inbounds double, double* %396, i64 3
store double %595, double* %598
%599 = getelementptr inbounds double, double* %396, i64 4
br label %600
600: ; preds = %583, %591, %395
%601 = phi double* [ %599, %591 ], [ %396, %583 ], [ %396, %395 ]
%602 = phi double* [ %584, %591 ], [ %584, %583 ], [ %397, %395 ]
%603 = phi double* [ %555, %591 ], [ %555, %583 ], [ %398, %395 ]
%604 = phi double* [ %411, %591 ], [ %411, %583 ], [ %399, %395 ]
%605 = phi double* [ %410, %591 ], [ %410, %583 ], [ %400, %395 ]
%606 = and i32 %0, 2
%607 = icmp eq i32 %606, 0
br i1 %607, label %721, label %608
608: ; preds = %600
%609 = sext i32 %3 to i64
%610 = getelementptr inbounds double, double* %605, i64 %609
%611 = shl nsw i32 %3, 1
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds double, double* %605, i64 %612
%614 = getelementptr inbounds double, double* %604, i64 16
%615 = icmp sgt i32 %1, 7
br i1 %615, label %616, label %667
616: ; preds = %608
%617 = lshr i32 %1, 3
%618 = shl nsw i32 %0, 3
%619 = sext i32 %618 to i64
br label %620
620: ; preds = %616, %620
%621 = phi double* [ %664, %620 ], [ %604, %616 ]
%622 = phi double* [ %648, %620 ], [ %610, %616 ]
%623 = phi double* [ %636, %620 ], [ %605, %616 ]
%624 = phi i32 [ %665, %620 ], [ %617, %616 ]
%625 = bitcast double* %623 to <2 x double>*
%626 = load <2 x double>, <2 x double>* %625
%627 = getelementptr inbounds double, double* %623, i64 2
%628 = bitcast double* %627 to <2 x double>*
%629 = load <2 x double>, <2 x double>* %628
%630 = getelementptr inbounds double, double* %623, i64 4
%631 = bitcast double* %630 to <2 x double>*
%632 = load <2 x double>, <2 x double>* %631
%633 = getelementptr inbounds double, double* %623, i64 6
%634 = bitcast double* %633 to <2 x double>*
%635 = load <2 x double>, <2 x double>* %634
%636 = getelementptr inbounds double, double* %623, i64 8
%637 = bitcast double* %622 to <2 x double>*
%638 = load <2 x double>, <2 x double>* %637
%639 = getelementptr inbounds double, double* %622, i64 2
%640 = bitcast double* %639 to <2 x double>*
%641 = load <2 x double>, <2 x double>* %640
%642 = getelementptr inbounds double, double* %622, i64 4
%643 = bitcast double* %642 to <2 x double>*
%644 = load <2 x double>, <2 x double>* %643
%645 = getelementptr inbounds double, double* %622, i64 6
%646 = bitcast double* %645 to <2 x double>*
%647 = load <2 x double>, <2 x double>* %646
%648 = getelementptr inbounds double, double* %622, i64 8
%649 = bitcast double* %621 to <2 x double>*
store <2 x double> %626, <2 x double>* %649
%650 = getelementptr inbounds double, double* %621, i64 2
%651 = bitcast double* %650 to <2 x double>*
store <2 x double> %629, <2 x double>* %651
%652 = getelementptr inbounds double, double* %621, i64 4
%653 = bitcast double* %652 to <2 x double>*
store <2 x double> %632, <2 x double>* %653
%654 = getelementptr inbounds double, double* %621, i64 6
%655 = bitcast double* %654 to <2 x double>*
store <2 x double> %635, <2 x double>* %655
%656 = getelementptr inbounds double, double* %621, i64 8
%657 = bitcast double* %656 to <2 x double>*
store <2 x double> %638, <2 x double>* %657
%658 = getelementptr inbounds double, double* %621, i64 10
%659 = bitcast double* %658 to <2 x double>*
store <2 x double> %641, <2 x double>* %659
%660 = getelementptr inbounds double, double* %621, i64 12
%661 = bitcast double* %660 to <2 x double>*
store <2 x double> %644, <2 x double>* %661
%662 = getelementptr inbounds double, double* %621, i64 14
%663 = bitcast double* %662 to <2 x double>*
store <2 x double> %647, <2 x double>* %663
%664 = getelementptr inbounds double, double* %621, i64 %619
%665 = add nsw i32 %624, -1
%666 = icmp ugt i32 %624, 1
br i1 %666, label %620, label %667
667: ; preds = %620, %608
%668 = phi double* [ %610, %608 ], [ %648, %620 ]
%669 = phi double* [ %605, %608 ], [ %636, %620 ]
%670 = and i32 %1, 4
%671 = icmp eq i32 %670, 0
br i1 %671, label %693, label %672
672: ; preds = %667
%673 = bitcast double* %669 to <2 x double>*
%674 = load <2 x double>, <2 x double>* %673
%675 = getelementptr inbounds double, double* %669, i64 2
%676 = bitcast double* %675 to <2 x double>*
%677 = load <2 x double>, <2 x double>* %676
%678 = getelementptr inbounds double, double* %669, i64 4
%679 = bitcast double* %668 to <2 x double>*
%680 = load <2 x double>, <2 x double>* %679
%681 = getelementptr inbounds double, double* %668, i64 2
%682 = bitcast double* %681 to <2 x double>*
%683 = load <2 x double>, <2 x double>* %682
%684 = getelementptr inbounds double, double* %668, i64 4
%685 = bitcast double* %603 to <2 x double>*
store <2 x double> %674, <2 x double>* %685
%686 = getelementptr inbounds double, double* %603, i64 2
%687 = bitcast double* %686 to <2 x double>*
store <2 x double> %677, <2 x double>* %687
%688 = getelementptr inbounds double, double* %603, i64 4
%689 = bitcast double* %688 to <2 x double>*
store <2 x double> %680, <2 x double>* %689
%690 = getelementptr inbounds double, double* %603, i64 6
%691 = bitcast double* %690 to <2 x double>*
store <2 x double> %683, <2 x double>* %691
%692 = getelementptr inbounds double, double* %603, i64 8
br label %693
693: ; preds = %672, %667
%694 = phi double* [ %692, %672 ], [ %603, %667 ]
%695 = phi double* [ %684, %672 ], [ %668, %667 ]
%696 = phi double* [ %678, %672 ], [ %669, %667 ]
%697 = and i32 %1, 2
%698 = icmp eq i32 %697, 0
br i1 %698, label %710, label %699
699: ; preds = %693
%700 = bitcast double* %696 to <2 x double>*
%701 = load <2 x double>, <2 x double>* %700
%702 = getelementptr inbounds double, double* %696, i64 2
%703 = bitcast double* %695 to <2 x double>*
%704 = load <2 x double>, <2 x double>* %703
%705 = getelementptr inbounds double, double* %695, i64 2
%706 = bitcast double* %602 to <2 x double>*
store <2 x double> %701, <2 x double>* %706
%707 = getelementptr inbounds double, double* %602, i64 2
%708 = bitcast double* %707 to <2 x double>*
store <2 x double> %704, <2 x double>* %708
%709 = getelementptr inbounds double, double* %602, i64 4
br label %710
710: ; preds = %699, %693
%711 = phi double* [ %709, %699 ], [ %602, %693 ]
%712 = phi double* [ %705, %699 ], [ %695, %693 ]
%713 = phi double* [ %702, %699 ], [ %696, %693 ]
%714 = and i32 %1, 1
%715 = icmp eq i32 %714, 0
br i1 %715, label %721, label %716
716: ; preds = %710
%717 = load double, double* %713
%718 = load double, double* %712
store double %717, double* %601
%719 = getelementptr inbounds double, double* %601, i64 1
store double %718, double* %719
%720 = getelementptr inbounds double, double* %601, i64 2
br label %721
721: ; preds = %710, %716, %600
%722 = phi double* [ %720, %716 ], [ %601, %710 ], [ %601, %600 ]
%723 = phi double* [ %711, %716 ], [ %711, %710 ], [ %602, %600 ]
%724 = phi double* [ %694, %716 ], [ %694, %710 ], [ %603, %600 ]
%725 = phi double* [ %614, %716 ], [ %614, %710 ], [ %604, %600 ]
%726 = phi double* [ %613, %716 ], [ %613, %710 ], [ %605, %600 ]
%727 = and i32 %0, 1
%728 = icmp eq i32 %727, 0
br i1 %728, label %790, label %729
729: ; preds = %721
%730 = icmp sgt i32 %1, 7
br i1 %730, label %731, label %761
731: ; preds = %729
%732 = lshr i32 %1, 3
%733 = shl nsw i32 %0, 3
%734 = sext i32 %733 to i64
br label %735
735: ; preds = %731, %735
%736 = phi double* [ %758, %735 ], [ %725, %731 ]
%737 = phi double* [ %750, %735 ], [ %726, %731 ]
%738 = phi i32 [ %759, %735 ], [ %732, %731 ]
%739 = bitcast double* %737 to <2 x double>*
%740 = load <2 x double>, <2 x double>* %739
%741 = getelementptr inbounds double, double* %737, i64 2
%742 = bitcast double* %741 to <2 x double>*
%743 = load <2 x double>, <2 x double>* %742
%744 = getelementptr inbounds double, double* %737, i64 4
%745 = bitcast double* %744 to <2 x double>*
%746 = load <2 x double>, <2 x double>* %745
%747 = getelementptr inbounds double, double* %737, i64 6
%748 = bitcast double* %747 to <2 x double>*
%749 = load <2 x double>, <2 x double>* %748
%750 = getelementptr inbounds double, double* %737, i64 8
%751 = bitcast double* %736 to <2 x double>*
store <2 x double> %740, <2 x double>* %751
%752 = getelementptr inbounds double, double* %736, i64 2
%753 = bitcast double* %752 to <2 x double>*
store <2 x double> %743, <2 x double>* %753
%754 = getelementptr inbounds double, double* %736, i64 4
%755 = bitcast double* %754 to <2 x double>*
store <2 x double> %746, <2 x double>* %755
%756 = getelementptr inbounds double, double* %736, i64 6
%757 = bitcast double* %756 to <2 x double>*
store <2 x double> %749, <2 x double>* %757
%758 = getelementptr inbounds double, double* %736, i64 %734
%759 = add nsw i32 %738, -1
%760 = icmp ugt i32 %738, 1
br i1 %760, label %735, label %761
761: ; preds = %735, %729
%762 = phi double* [ %726, %729 ], [ %750, %735 ]
%763 = and i32 %1, 4
%764 = icmp eq i32 %763, 0
br i1 %764, label %775, label %765
765: ; preds = %761
%766 = bitcast double* %762 to <2 x double>*
%767 = load <2 x double>, <2 x double>* %766
%768 = getelementptr inbounds double, double* %762, i64 2
%769 = bitcast double* %768 to <2 x double>*
%770 = load <2 x double>, <2 x double>* %769
%771 = getelementptr inbounds double, double* %762, i64 4
%772 = bitcast double* %724 to <2 x double>*
store <2 x double> %767, <2 x double>* %772
%773 = getelementptr inbounds double, double* %724, i64 2
%774 = bitcast double* %773 to <2 x double>*
store <2 x double> %770, <2 x double>* %774
br label %775
775: ; preds = %765, %761
%776 = phi double* [ %771, %765 ], [ %762, %761 ]
%777 = and i32 %1, 2
%778 = icmp eq i32 %777, 0
br i1 %778, label %784, label %779
779: ; preds = %775
%780 = bitcast double* %776 to <2 x double>*
%781 = load <2 x double>, <2 x double>* %780
%782 = getelementptr inbounds double, double* %776, i64 2
%783 = bitcast double* %723 to <2 x double>*
store <2 x double> %781, <2 x double>* %783
br label %784
784: ; preds = %779, %775
%785 = phi double* [ %782, %779 ], [ %776, %775 ]
%786 = and i32 %1, 1
%787 = icmp eq i32 %786, 0
br i1 %787, label %790, label %788
788: ; preds = %784
%789 = load double, double* %785
store double %789, double* %722
br label %790
790: ; preds = %784, %788, %721
ret i32 0
}