main_resnet50.cpp

/*
 This is an autogenerated file, generated using the EzPC compiler.
 Then hand crafted by Wen-jie Lu
*/

#include <iostream>
#include <chrono>

#include "library_fixed.h"
using namespace std;
#define USE_FUSED_BN 1

int party = 0;
int port = 32000;
string address = "127.0.0.1";
int num_threads = 4;
int32_t bitlength = 41;
int32_t kScale = 12;
int32_t kDoExtractTruncate = 1;

int64_t getSignValue(uint64_t x) {
  static int64_t upper = 1LL << bitlength;
  static uint64_t mask = static_cast<uint64_t>(upper) - 1;
  static uint64_t half = static_cast<uint64_t>(upper) >> 1;

  x &= mask;
  return static_cast<int64_t>(x >= half ? x - upper : x);
}

void MatAddBroadCast2(int64_t s1, int64_t s2, uint64_t *A, uint64_t *B,
                      uint64_t *outArr) {
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      Arr2DIdxRowM(outArr, s1, s2, i1, i2) =
          SecretAdd(Arr2DIdxRowM(A, s1, s2, i1, i2), Arr1DIdxRowM(B, s2, i2));
    }
  }
}

void MatAdd4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *A,
             uint64_t *B, uint64_t *outArr) {
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) =
              SecretAdd(Arr4DIdxRowM(A, s1, s2, s3, s4, i1, i2, i3, i4),
                        Arr4DIdxRowM(B, s1, s2, s3, s4, i1, i2, i3, i4));
        }
      }
    }
  }
}

void Conv2DReshapeFilter(int64_t FH, int64_t FW, int64_t CI, int64_t CO,
                         uint64_t *inputArr, uint64_t *outputArr) {
  for (uint64_t co = 0; co < CO; co++) {
    for (uint64_t fh = 0; fh < FH; fh++) {
      for (uint64_t fw = 0; fw < FW; fw++) {
        for (uint64_t ci = 0; ci < CI; ci++) {
          int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci);
          Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) =
              Arr4DIdxRowM(inputArr, FH, FW, CI, CO, fh, fw, ci, co);
        }
      }
    }
  }
}

void Conv2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW,
                           int64_t CO, uint64_t *inputArr,
                           uint64_t *outputArr) {
  for (uint64_t co = 0; co < CO; co++) {
    for (uint64_t n = 0; n < N; n++) {
      for (uint64_t h = 0; h < finalH; h++) {
        for (uint64_t w = 0; w < finalW; w++) {
          Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) =
              Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co,
                           ((((n * finalH) * finalW) + (h * finalW)) + w));
        }
      }
    }
  }
}

void Conv2DReshapeInput(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH,
                        int64_t FW, int64_t zPadHLeft, int64_t zPadHRight,
                        int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH,
                        int64_t strideW, int64_t RRows, int64_t RCols,
                        uint64_t *inputArr, uint64_t *outputArr) {
  int64_t linIdxFilterMult = 0;
  for (uint64_t n = 0; n < N; n++) {
    int64_t leftTopCornerH = (0 - zPadHLeft);

    int64_t extremeRightBottomCornerH = ((H - 1) + zPadHRight);
    while ((((leftTopCornerH + FH) - 1) <= extremeRightBottomCornerH)) {
      int64_t leftTopCornerW = (0 - zPadWLeft);

      int64_t extremeRightBottomCornerW = ((W - 1) + zPadWRight);
      while ((((leftTopCornerW + FW) - 1) <= extremeRightBottomCornerW)) {
        for (uint64_t fh = 0; fh < FH; fh++) {
          for (uint64_t fw = 0; fw < FW; fw++) {
            int64_t curPosH = (leftTopCornerH + fh);

            int64_t curPosW = (leftTopCornerW + fw);

            uint64_t val = funcSSCons((int64_t)0);
            for (uint64_t ci = 0; ci < CI; ci++) {
              if ((((curPosH < 0) || (curPosH >= H)) ||
                   ((curPosW < 0) || (curPosW >= W)))) {
                val = funcSSCons((int64_t)0);
              } else {
                val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW,
                                   ci);
              }
              Arr2DIdxRowM(outputArr, RRows, RCols,
                           ((((fh * FW) * CI) + (fw * CI)) + ci),
                           linIdxFilterMult) = val;
            }
          }
        }
        linIdxFilterMult = (linIdxFilterMult + 1);
        leftTopCornerW = (leftTopCornerW + strideW);
      }

      leftTopCornerH = (leftTopCornerH + strideH);
    }
  }
}

void Conv2DLoopInner(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH,
                     int64_t FW, int64_t CO, int64_t zPadHLeft,
                     int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight,
                     int64_t strideH, int64_t strideW, int64_t outH,
                     int64_t outW, int64_t G, uint64_t *inputArr,
                     uint64_t *filterArr, uint64_t *outArr) {
  int64_t GIS = (CI / G);

  int64_t GOS = (CO / G);
  for (uint64_t n = 0; n < N; n++) {
    for (uint64_t cog = 0; cog < GOS; cog++) {
      for (uint64_t cig = 0; cig < GIS; cig++) {
        for (uint64_t g = 0; g < G; g++) {
          for (uint64_t h = 0; h < outH; h++) {
            for (uint64_t w = 0; w < outW; w++) {
              uint64_t val = funcSSCons((int64_t)0);

              int64_t ci = ((GIS * g) + cig);

              int64_t co = ((GOS * g) + cog);

              int64_t curPosH = ((strideH * h) - zPadHLeft);
              for (uint64_t fh = 0; fh < FH; fh++) {
                int64_t curPosW = ((strideW * w) - zPadWLeft);
                for (uint64_t fw = 0; fw < FW; fw++) {
                  if (((((curPosH >= 0) && (curPosW >= 0)) && (curPosH < H)) &&
                       (curPosW < W))) {
                    val = SecretAdd(
                        val,
                        SecretMult(Arr4DIdxRowM(inputArr, N, H, W, CI, n,
                                                curPosH, curPosW, ci),
                                   Arr4DIdxRowM(filterArr, FH, FW, (CI / G), CO,
                                                fh, fw, (ci / G), co)));
                  }
                  curPosW = (curPosW + 1);
                }
                curPosH = (curPosH + 1);
              }
              Arr4DIdxRowM(outArr, N, outH, outW, CO, n, h, w, co) = SecretAdd(
                  Arr4DIdxRowM(outArr, N, outH, outW, CO, n, h, w, co), val);
            }
          }
        }
      }
    }
  }
}

void Conv2DLoop(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH,
                int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight,
                int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH,
                int64_t strideW, int64_t G, uint64_t *inputArr,
                uint64_t *filterArr, uint64_t *outArr) {
  int64_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + 1);

  int64_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + 1);
  Conv2DLoopInner(N, H, W, CI, FH, FW, CO, zPadHLeft, zPadHRight, zPadWLeft,
                  zPadWRight, strideH, strideW, outH, outW, G, inputArr,
                  filterArr, outArr);
}

void Conv2DReshapeFilterGroup(int64_t FH, int64_t FW, int64_t CI, int64_t CO,
                              int64_t g, int64_t G, uint64_t *inputArr,
                              uint64_t *outputArr) {
  int64_t CIG = (CI / G);

  int64_t COG = (CO / G);

  int64_t startCO = (g * COG);
  for (uint64_t co = 0; co < COG; co++) {
    for (uint64_t fh = 0; fh < FH; fh++) {
      for (uint64_t fw = 0; fw < FW; fw++) {
        for (uint64_t ci = 0; ci < CIG; ci++) {
          int64_t linIdx = ((((fh * FW) * CIG) + (fw * CIG)) + ci);
          Arr2DIdxRowM(outputArr, (CO / G), ((FH * FW) * (CI / G)), co,
                       linIdx) = Arr4DIdxRowM(inputArr, FH, FW, (CI / G), CO,
                                              fh, fw, ci, (co + startCO));
        }
      }
    }
  }
}

void Conv2DReshapeMatMulOPGroup(int64_t N, int64_t finalH, int64_t finalW,
                                int64_t CO, int64_t g, int64_t G,
                                uint64_t *inputArr, uint64_t *outputArr) {
  int64_t COG = (CO / G);

  int64_t startCO = (g * COG);
  for (uint64_t co = 0; co < COG; co++) {
    for (uint64_t n = 0; n < N; n++) {
      for (uint64_t h = 0; h < finalH; h++) {
        for (uint64_t w = 0; w < finalW; w++) {
          Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w,
                       (co + startCO)) =
              Arr2DIdxRowM(inputArr, (CO / G), ((N * finalH) * finalW), co,
                           ((((n * finalH) * finalW) + (h * finalW)) + w));
        }
      }
    }
  }
}

void Conv2DReshapeInputGroup(int64_t N, int64_t H, int64_t W, int64_t CI,
                             int64_t FH, int64_t FW, int64_t zPadHLeft,
                             int64_t zPadHRight, int64_t zPadWLeft,
                             int64_t zPadWRight, int64_t strideH,
                             int64_t strideW, int64_t g, int64_t G,
                             int64_t RRows, int64_t RCols, uint64_t *inputArr,
                             uint64_t *outputArr) {
  int64_t linIdxFilterMult = 0;

  int64_t CIG = (CI / G);
  for (uint64_t n = 0; n < N; n++) {
    int64_t leftTopCornerH = (0 - zPadHLeft);

    int64_t extremeRightBottomCornerH = ((H - 1) + zPadHRight);
    while ((((leftTopCornerH + FH) - 1) <= extremeRightBottomCornerH)) {
      int64_t leftTopCornerW = (0 - zPadWLeft);

      int64_t extremeRightBottomCornerW = ((W - 1) + zPadWRight);
      while ((((leftTopCornerW + FW) - 1) <= extremeRightBottomCornerW)) {
        for (uint64_t fh = 0; fh < FH; fh++) {
          for (uint64_t fw = 0; fw < FW; fw++) {
            int64_t curPosH = (leftTopCornerH + fh);

            int64_t curPosW = (leftTopCornerW + fw);

            uint64_t val = funcSSCons((int64_t)0);

            int64_t startCI = (g * CIG);
            for (uint64_t ci = 0; ci < CIG; ci++) {
              if ((((curPosH < 0) || (curPosH >= H)) ||
                   ((curPosW < 0) || (curPosW >= W)))) {
                val = funcSSCons((int64_t)0);
              } else {
                val = Arr4DIdxRowM(inputArr, N, H, W, CI, n, curPosH, curPosW,
                                   (ci + startCI));
              }
              Arr2DIdxRowM(outputArr, RRows, RCols,
                           ((((fh * FW) * CIG) + (fw * CIG)) + ci),
                           linIdxFilterMult) = val;
            }
          }
        }
        linIdxFilterMult = (linIdxFilterMult + 1);
        leftTopCornerW = (leftTopCornerW + strideW);
      }

      leftTopCornerH = (leftTopCornerH + strideH);
    }
  }
}

void Conv2DGroup(int64_t N, int64_t H, int64_t W, int64_t CI, int64_t FH,
                 int64_t FW, int64_t CO, int64_t zPadHLeft, int64_t zPadHRight,
                 int64_t zPadWLeft, int64_t zPadWRight, int64_t strideH,
                 int64_t strideW, int64_t G, uint64_t *inputArr,
                 uint64_t *filterArr, uint64_t *outArr) {
  int64_t CIG = (CI / G);

  int64_t reshapedFilterRows = (CO / G);

  int64_t reshapedFilterCols = ((FH * FW) * CIG);

  int64_t reshapedIPRows = ((FH * FW) * CIG);

  int64_t outH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + 1);

  int64_t outW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + 1);

  int64_t reshapedIPCols = ((N * outH) * outW);
  for (uint64_t g = 0; g < G; g++) {
    uint64_t *inputReshaped =
        make_array<uint64_t>(reshapedIPRows, reshapedIPCols);

    uint64_t *matmulOP =
        make_array<uint64_t>(reshapedFilterRows, reshapedIPCols);

    uint64_t *filterReshaped =
        make_array<uint64_t>(reshapedFilterRows, reshapedFilterCols);
    Conv2DReshapeFilterGroup(FH, FW, CI, CO, g, G, filterArr, filterReshaped);
    Conv2DReshapeInputGroup(N, H, W, CI, FH, FW, zPadHLeft, zPadHRight,
                            zPadWLeft, zPadWRight, strideH, strideW, g, G,
                            reshapedIPRows, reshapedIPCols, inputArr,
                            inputReshaped);
    MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols,
             filterReshaped, inputReshaped, matmulOP, 1);
    Conv2DReshapeMatMulOPGroup(N, outH, outW, CO, g, G, matmulOP, outArr);
    ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped);
    ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped);
    ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP);
  }
}

void Conv3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW, int64_t CI,
                         int64_t CO, uint64_t *inputArr, uint64_t *outputArr) {
  for (uint64_t co = 0; co < CO; co++) {
    for (uint64_t fd = 0; fd < FD; fd++) {
      for (uint64_t fh = 0; fh < FH; fh++) {
        for (uint64_t fw = 0; fw < FW; fw++) {
          for (uint64_t ci = 0; ci < CI; ci++) {
            int64_t linIdx =
                ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) +
                 ci);
            Arr2DIdxRowM(outputArr, CO, (((FD * FH) * FW) * CI), co, linIdx) =
                Arr5DIdxRowM(inputArr, FD, FH, FW, CI, CO, fd, fh, fw, ci, co);
          }
        }
      }
    }
  }
}

void Conv3DReshapeMatMulOP(int64_t N, int64_t finalD, int64_t finalH,
                           int64_t finalW, int64_t CO, uint64_t *inputArr,
                           uint64_t *outputArr) {
  for (uint64_t co = 0; co < CO; co++) {
    for (uint64_t n = 0; n < N; n++) {
      for (uint64_t d = 0; d < finalD; d++) {
        for (uint64_t h = 0; h < finalH; h++) {
          for (uint64_t w = 0; w < finalW; w++) {
            Arr5DIdxRowM(outputArr, N, finalD, finalH, finalW, CO, n, d, h, w,
                         co) =
                Arr2DIdxRowM(inputArr, CO, (((N * finalD) * finalH) * finalW),
                             co,
                             ((((((n * finalD) * finalH) * finalW) +
                                ((d * finalH) * finalW)) +
                               (h * finalW)) +
                              w));
          }
        }
      }
    }
  }
}

void Conv3DReshapeInput(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI,
                        int64_t FD, int64_t FH, int64_t FW, int64_t zPadDLeft,
                        int64_t zPadDRight, int64_t zPadHLeft,
                        int64_t zPadHRight, int64_t zPadWLeft,
                        int64_t zPadWRight, int64_t strideD, int64_t strideH,
                        int64_t strideW, int64_t RRows, int64_t RCols,
                        uint64_t *inputArr, uint64_t *outputArr) {
  int64_t linIdxFilterMult = 0;
  for (uint64_t n = 0; n < N; n++) {
    int64_t leftTopCornerD = (0 - zPadDLeft);

    int64_t extremeRightBottomCornerD = ((D - 1) + zPadDRight);
    while ((((leftTopCornerD + FD) - 1) <= extremeRightBottomCornerD)) {
      int64_t leftTopCornerH = (0 - zPadHLeft);

      int64_t extremeRightBottomCornerH = ((H - 1) + zPadHRight);
      while ((((leftTopCornerH + FH) - 1) <= extremeRightBottomCornerH)) {
        int64_t leftTopCornerW = (0 - zPadWLeft);

        int64_t extremeRightBottomCornerW = ((W - 1) + zPadWRight);
        while ((((leftTopCornerW + FW) - 1) <= extremeRightBottomCornerW)) {
          for (uint64_t fd = 0; fd < FD; fd++) {
            for (uint64_t fh = 0; fh < FH; fh++) {
              for (uint64_t fw = 0; fw < FW; fw++) {
                int64_t curPosD = (leftTopCornerD + fd);

                int64_t curPosH = (leftTopCornerH + fh);

                int64_t curPosW = (leftTopCornerW + fw);

                uint64_t val = funcSSCons((int64_t)0);
                for (uint64_t ci = 0; ci < CI; ci++) {
                  if (((((curPosD < 0) || (curPosD >= D)) ||
                        ((curPosH < 0) || (curPosH >= H))) ||
                       ((curPosW < 0) || (curPosW >= W)))) {
                    val = funcSSCons((int64_t)0);
                  } else {
                    val = Arr5DIdxRowM(inputArr, N, D, H, W, CI, n, curPosD,
                                       curPosH, curPosW, ci);
                  }
                  Arr2DIdxRowM(outputArr, RRows, RCols,
                               ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) +
                                 (fw * CI)) +
                                ci),
                               linIdxFilterMult) = val;
                }
              }
            }
          }
          linIdxFilterMult = (linIdxFilterMult + 1);
          leftTopCornerW = (leftTopCornerW + strideW);
        }

        leftTopCornerH = (leftTopCornerH + strideH);
      }

      leftTopCornerD = (leftTopCornerD + strideD);
    }
  }
}

void Conv3D(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI, int64_t FD,
            int64_t FH, int64_t FW, int64_t CO, int64_t zPadDLeft,
            int64_t zPadDRight, int64_t zPadHLeft, int64_t zPadHRight,
            int64_t zPadWLeft, int64_t zPadWRight, int64_t strideD,
            int64_t strideH, int64_t strideW, uint64_t *inputArr,
            uint64_t *filterArr, uint64_t *outArr) {
  int64_t reshapedFilterRows = CO;

  int64_t reshapedFilterCols = (((FD * FH) * FW) * CI);

  int64_t reshapedIPRows = (((FD * FH) * FW) * CI);

  int64_t newD = ((((D + (zPadDLeft + zPadDRight)) - FD) / strideD) + 1);

  int64_t newH = ((((H + (zPadHLeft + zPadHRight)) - FH) / strideH) + 1);

  int64_t newW = ((((W + (zPadWLeft + zPadWRight)) - FW) / strideW) + 1);

  int64_t reshapedIPCols = (((N * newD) * newH) * newW);

  uint64_t *filterReshaped =
      make_array<uint64_t>(reshapedFilterRows, reshapedFilterCols);

  uint64_t *inputReshaped =
      make_array<uint64_t>(reshapedIPRows, reshapedIPCols);

  uint64_t *matmulOP = make_array<uint64_t>(reshapedFilterRows, reshapedIPCols);
  Conv3DReshapeFilter(FD, FH, FW, CI, CO, filterArr, filterReshaped);
  Conv3DReshapeInput(N, D, H, W, CI, FD, FH, FW, zPadDLeft, zPadDRight,
                     zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD,
                     strideH, strideW, reshapedIPRows, reshapedIPCols, inputArr,
                     inputReshaped);
  MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols,
           filterReshaped, inputReshaped, matmulOP, 1);
  Conv3DReshapeMatMulOP(N, newD, newH, newW, CO, matmulOP, outArr);
  ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped);
  ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped);
  ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP);
}

void Conv3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI,
                     int64_t FD, int64_t FH, int64_t FW, int64_t CO,
                     int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft,
                     int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight,
                     int64_t strideD, int64_t strideH, int64_t strideW,
                     int64_t outD, int64_t outH, int64_t outW,
                     uint64_t *inputArr, uint64_t *filterArr,
                     uint64_t *outArr) {
  for (uint64_t n = 0; n < N; n++) {
    for (uint64_t co = 0; co < CO; co++) {
      for (uint64_t d = 0; d < outD; d++) {
        for (uint64_t h = 0; h < outH; h++) {
          for (uint64_t w = 0; w < outW; w++) {
            for (uint64_t ci = 0; ci < CI; ci++) {
              uint64_t val = funcSSCons((int64_t)0);
              for (uint64_t fd = (d * strideD); fd < ((d * strideD) + FD);
                   fd++) {
                for (uint64_t fh = (h * strideH); fh < ((h * strideH) + FH);
                     fh++) {
                  for (uint64_t fw = (w * strideW); fw < ((w * strideW) + FW);
                       fw++) {
                    int64_t curPosD = (fd - zPadDLeft);

                    int64_t curPosH = (fh - zPadHLeft);

                    int64_t curPosW = (fw - zPadWLeft);
                    if (((((((curPosD >= 0) && (curPosH >= 0)) &&
                            (curPosW >= 0)) &&
                           (curPosD < D)) &&
                          (curPosH < H)) &&
                         (curPosW < W))) {
                      int64_t curFilterPosD = (fd - (d * strideD));

                      int64_t curFilterPosH = (fh - (h * strideH));

                      int64_t curFilterPosW = (fw - (w * strideW));
                      val = SecretAdd(
                          val, SecretMult(
                                   Arr5DIdxRowM(inputArr, N, D, H, W, CI, n,
                                                curPosD, curPosH, curPosW, ci),
                                   Arr5DIdxRowM(filterArr, FD, FH, FW, CI, CO,
                                                curFilterPosD, curFilterPosH,
                                                curFilterPosW, ci, co)));
                    }
                  }
                }
              }
              Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, h, w, co) =
                  SecretAdd(Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d,
                                         h, w, co),
                            val);
            }
          }
        }
      }
    }
  }
}

void Conv3DLoop(int64_t N, int64_t D, int64_t H, int64_t W, int64_t CI,
                int64_t FD, int64_t FH, int64_t FW, int64_t CO,
                int64_t zPadDLeft, int64_t zPadDRight, int64_t zPadHLeft,
                int64_t zPadHRight, int64_t zPadWLeft, int64_t zPadWRight,
                int64_t strideD, int64_t strideH, int64_t strideW,
                uint64_t *inputArr, uint64_t *filterArr, uint64_t *outArr) {
  int64_t outD = ((((D - FD) + (zPadDLeft + zPadDRight)) / strideD) + 1);

  int64_t outH = ((((H - FH) + (zPadHLeft + zPadHRight)) / strideH) + 1);

  int64_t outW = ((((W - FW) + (zPadWLeft + zPadWRight)) / strideW) + 1);
  Conv3DLoopInner(N, D, H, W, CI, FD, FH, FW, CO, zPadDLeft, zPadDRight,
                  zPadHLeft, zPadHRight, zPadWLeft, zPadWRight, strideD,
                  strideH, strideW, outD, outH, outW, inputArr, filterArr,
                  outArr);
}

void ConvTranspose2DReshapeMatMulOP(int64_t N, int64_t finalH, int64_t finalW,
                                    int64_t CO, uint64_t *inputArr,
                                    uint64_t *outputArr) {
  for (uint64_t co = 0; co < CO; co++) {
    for (uint64_t n = 0; n < N; n++) {
      for (uint64_t h = 0; h < finalH; h++) {
        for (uint64_t w = 0; w < finalW; w++) {
          Arr4DIdxRowM(outputArr, N, finalH, finalW, CO, n, h, w, co) =
              Arr2DIdxRowM(inputArr, CO, ((N * finalH) * finalW), co,
                           ((((n * finalH) * finalW) + (h * finalW)) + w));
        }
      }
    }
  }
}

void ConvTranspose2DReshapeFilter(int64_t FH, int64_t FW, int64_t CO,
                                  int64_t CI, uint64_t *inputArr,
                                  uint64_t *outputArr) {
  for (uint64_t co = 0; co < CO; co++) {
    for (uint64_t fh = 0; fh < FH; fh++) {
      for (uint64_t fw = 0; fw < FW; fw++) {
        for (uint64_t ci = 0; ci < CI; ci++) {
          int64_t linIdx = ((((fh * FW) * CI) + (fw * CI)) + ci);
          Arr2DIdxRowM(outputArr, CO, ((FH * FW) * CI), co, linIdx) =
              Arr4DIdxRowM(inputArr, FH, FW, CO, CI, ((FH - 1) - fh),
                           ((FW - 1) - fw), co, ci);
        }
      }
    }
  }
}

void ConvTranspose2DReshapeInput(int64_t N, int64_t HPrime, int64_t WPrime,
                                 int64_t CI, int64_t FH, int64_t FW,
                                 int64_t zPadTrHLeft, int64_t zPadTrHRight,
                                 int64_t zPadTrWLeft, int64_t zPadTrWRight,
                                 int64_t strideH, int64_t strideW,
                                 int64_t RRows, int64_t RCols,
                                 uint64_t *inputArr, uint64_t *outputArr) {
  int64_t linIdxFilterMult = 0;
  for (uint64_t n = 0; n < N; n++) {
    int64_t leftTopCornerH = (0 - zPadTrHLeft);

    int64_t HPrimeTilde = (HPrime + ((HPrime - 1) * (strideH - 1)));

    int64_t extremeRightBottomCornerH = ((HPrimeTilde - 1) + zPadTrHRight);
    while ((((leftTopCornerH + FH) - 1) <= extremeRightBottomCornerH)) {
      int64_t leftTopCornerW = (0 - zPadTrWLeft);

      int64_t WPrimeTilde = (WPrime + ((WPrime - 1) * (strideW - 1)));

      int64_t extremeRightBottomCornerW = ((WPrimeTilde - 1) + zPadTrWRight);
      while ((((leftTopCornerW + FW) - 1) <= extremeRightBottomCornerW)) {
        for (uint64_t fh = 0; fh < FH; fh++) {
          for (uint64_t fw = 0; fw < FW; fw++) {
            int64_t curPosH = (leftTopCornerH + fh);

            int64_t curPosW = (leftTopCornerW + fw);

            uint64_t val = funcSSCons((int64_t)0);
            for (uint64_t ci = 0; ci < CI; ci++) {
              if ((((curPosH < 0) || (curPosH >= HPrimeTilde)) ||
                   ((curPosW < 0) || (curPosW >= WPrimeTilde)))) {
                val = funcSSCons((int64_t)0);
              } else {
                if ((((curPosH % strideH) == 0) &&
                     ((curPosW % strideW) == 0))) {
                  int64_t idxInputH = (curPosH / strideH);

                  int64_t idxInputW = (curPosW / strideW);
                  val = Arr4DIdxRowM(inputArr, N, HPrime, WPrime, CI, n,
                                     idxInputH, idxInputW, ci);
                } else {
                  val = funcSSCons((int64_t)0);
                }
              }
              Arr2DIdxRowM(outputArr, RRows, RCols,
                           ((((fh * FW) * CI) + (fw * CI)) + ci),
                           linIdxFilterMult) = val;
            }
          }
        }
        linIdxFilterMult = (linIdxFilterMult + 1);
        leftTopCornerW = (leftTopCornerW + 1);
      }

      leftTopCornerH = (leftTopCornerH + 1);
    }
  }
}

void ConvTranspose2D(int64_t N, int64_t HPrime, int64_t WPrime, int64_t CI,
                     int64_t FH, int64_t FW, int64_t CO, int64_t H, int64_t W,
                     int64_t zPadTrHLeft, int64_t zPadTrHRight,
                     int64_t zPadTrWLeft, int64_t zPadTrWRight, int64_t strideH,
                     int64_t strideW, uint64_t *inputArr, uint64_t *filterArr,
                     uint64_t *outArr) {
  int64_t reshapedFilterRows = CO;

  int64_t reshapedFilterCols = ((FH * FW) * CI);

  int64_t reshapedIPRows = ((FH * FW) * CI);

  int64_t reshapedIPCols = ((N * H) * W);

  uint64_t *filterReshaped =
      make_array<uint64_t>(reshapedFilterRows, reshapedFilterCols);

  uint64_t *inputReshaped =
      make_array<uint64_t>(reshapedIPRows, reshapedIPCols);

  uint64_t *matmulOP = make_array<uint64_t>(reshapedFilterRows, reshapedIPCols);
  ConvTranspose2DReshapeFilter(FH, FW, CO, CI, filterArr, filterReshaped);
  ConvTranspose2DReshapeInput(N, HPrime, WPrime, CI, FH, FW, zPadTrHLeft,
                              zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideH,
                              strideW, reshapedIPRows, reshapedIPCols, inputArr,
                              inputReshaped);
  MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols,
           filterReshaped, inputReshaped, matmulOP, 1);
  ConvTranspose2DReshapeMatMulOP(N, H, W, CO, matmulOP, outArr);
  ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped);
  ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped);
  ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP);
}

void ConvTranspose3DReshapeFilter(int64_t FD, int64_t FH, int64_t FW,
                                  int64_t CO, int64_t CI, uint64_t *inputArr,
                                  uint64_t *outputArr) {
  for (uint64_t co = 0; co < CO; co++) {
    for (uint64_t fd = 0; fd < FD; fd++) {
      for (uint64_t fh = 0; fh < FH; fh++) {
        for (uint64_t fw = 0; fw < FW; fw++) {
          for (uint64_t ci = 0; ci < CI; ci++) {
            int64_t linIdx =
                ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) + (fw * CI)) +
                 ci);
            Arr2DIdxRowM(outputArr, CO, (((FD * FH) * FW) * CI), co, linIdx) =
                Arr5DIdxRowM(inputArr, FD, FH, FW, CO, CI, ((FD - 1) - fd),
                             ((FH - 1) - fh), ((FW - 1) - fw), co, ci);
          }
        }
      }
    }
  }
}

void ConvTranspose3DReshapeInput(int64_t N, int64_t DPrime, int64_t HPrime,
                                 int64_t WPrime, int64_t CI, int64_t FD,
                                 int64_t FH, int64_t FW, int64_t zPadTrDLeft,
                                 int64_t zPadTrDRight, int64_t zPadTrHLeft,
                                 int64_t zPadTrHRight, int64_t zPadTrWLeft,
                                 int64_t zPadTrWRight, int64_t strideD,
                                 int64_t strideH, int64_t strideW,
                                 int64_t RRows, int64_t RCols,
                                 uint64_t *inputArr, uint64_t *outputArr) {
  int64_t linIdxFilterMult = 0;
  for (uint64_t n = 0; n < N; n++) {
    int64_t leftTopCornerD = (0 - zPadTrDLeft);

    int64_t DPrimeTilde = (DPrime + ((DPrime - 1) * (strideD - 1)));

    int64_t extremeRightBottomCornerD = ((DPrimeTilde - 1) + zPadTrDRight);
    while ((((leftTopCornerD + FD) - 1) <= extremeRightBottomCornerD)) {
      int64_t leftTopCornerH = (0 - zPadTrHLeft);

      int64_t HPrimeTilde = (HPrime + ((HPrime - 1) * (strideH - 1)));

      int64_t extremeRightBottomCornerH = ((HPrimeTilde - 1) + zPadTrHRight);
      while ((((leftTopCornerH + FH) - 1) <= extremeRightBottomCornerH)) {
        int64_t leftTopCornerW = (0 - zPadTrWLeft);

        int64_t WPrimeTilde = (WPrime + ((WPrime - 1) * (strideW - 1)));

        int64_t extremeRightBottomCornerW = ((WPrimeTilde - 1) + zPadTrWRight);
        while ((((leftTopCornerW + FW) - 1) <= extremeRightBottomCornerW)) {
          for (uint64_t fd = 0; fd < FD; fd++) {
            for (uint64_t fh = 0; fh < FH; fh++) {
              for (uint64_t fw = 0; fw < FW; fw++) {
                int64_t curPosD = (leftTopCornerD + fd);

                int64_t curPosH = (leftTopCornerH + fh);

                int64_t curPosW = (leftTopCornerW + fw);

                uint64_t val = funcSSCons((int64_t)0);
                for (uint64_t ci = 0; ci < CI; ci++) {
                  if (((((curPosD < 0) || (curPosD >= DPrimeTilde)) ||
                        ((curPosH < 0) || (curPosH >= HPrimeTilde))) ||
                       ((curPosW < 0) || (curPosW >= WPrimeTilde)))) {
                    val = funcSSCons((int64_t)0);
                  } else {
                    if (((((curPosD % strideD) == 0) &&
                          ((curPosH % strideH) == 0)) &&
                         ((curPosW % strideW) == 0))) {
                      int64_t idxInputD = (curPosD / strideD);

                      int64_t idxInputH = (curPosH / strideH);

                      int64_t idxInputW = (curPosW / strideW);
                      val =
                          Arr5DIdxRowM(inputArr, N, DPrime, HPrime, WPrime, CI,
                                       n, idxInputD, idxInputH, idxInputW, ci);
                    } else {
                      val = funcSSCons((int64_t)0);
                    }
                  }
                  Arr2DIdxRowM(outputArr, RRows, RCols,
                               ((((((fd * FH) * FW) * CI) + ((fh * FW) * CI)) +
                                 (fw * CI)) +
                                ci),
                               linIdxFilterMult) = val;
                }
              }
            }
          }
          linIdxFilterMult = (linIdxFilterMult + 1);
          leftTopCornerW = (leftTopCornerW + 1);
        }

        leftTopCornerH = (leftTopCornerH + 1);
      }

      leftTopCornerD = (leftTopCornerD + 1);
    }
  }
}

void ConvTranspose3D(int64_t N, int64_t DPrime, int64_t HPrime, int64_t WPrime,
                     int64_t CI, int64_t FD, int64_t FH, int64_t FW, int64_t CO,
                     int64_t D, int64_t H, int64_t W, int64_t zPadTrDLeft,
                     int64_t zPadTrDRight, int64_t zPadTrHLeft,
                     int64_t zPadTrHRight, int64_t zPadTrWLeft,
                     int64_t zPadTrWRight, int64_t strideD, int64_t strideH,
                     int64_t strideW, uint64_t *inputArr, uint64_t *filterArr,
                     uint64_t *outArr) {
  int64_t reshapedFilterRows = CO;

  int64_t reshapedFilterCols = (((FD * FH) * FW) * CI);

  int64_t reshapedIPRows = (((FD * FH) * FW) * CI);

  int64_t reshapedIPCols = (((N * D) * H) * W);

  uint64_t *filterReshaped =
      make_array<uint64_t>(reshapedFilterRows, reshapedFilterCols);

  uint64_t *inputReshaped =
      make_array<uint64_t>(reshapedIPRows, reshapedIPCols);

  uint64_t *matmulOP = make_array<uint64_t>(reshapedFilterRows, reshapedIPCols);
  ConvTranspose3DReshapeFilter(FD, FH, FW, CO, CI, filterArr, filterReshaped);
  ConvTranspose3DReshapeInput(
      N, DPrime, HPrime, WPrime, CI, FD, FH, FW, zPadTrDLeft, zPadTrDRight,
      zPadTrHLeft, zPadTrHRight, zPadTrWLeft, zPadTrWRight, strideD, strideH,
      strideW, reshapedIPRows, reshapedIPCols, inputArr, inputReshaped);
  MatMul2D(reshapedFilterRows, reshapedFilterCols, reshapedIPCols,
           filterReshaped, inputReshaped, matmulOP, 1);
  Conv3DReshapeMatMulOP(N, D, H, W, CO, matmulOP, outArr);
  ClearMemSecret2(reshapedFilterRows, reshapedFilterCols, filterReshaped);
  ClearMemSecret2(reshapedIPRows, reshapedIPCols, inputReshaped);
  ClearMemSecret2(reshapedFilterRows, reshapedIPCols, matmulOP);
}

void ConvTranspose3DLoopInner(int64_t N, int64_t D, int64_t H, int64_t W,
                              int64_t CI, int64_t FD, int64_t FH, int64_t FW,
                              int64_t CO, int64_t zPadDLeft, int64_t zPadDRight,
                              int64_t zPadHLeft, int64_t zPadHRight,
                              int64_t zPadWLeft, int64_t zPadWRight,
                              int64_t strideD, int64_t strideH, int64_t strideW,
                              int64_t outD, int64_t outH, int64_t outW,
                              uint64_t *inputArr, uint64_t *filterArr,
                              uint64_t *outArr) {
  for (uint64_t n = 0; n < N; n++) {
    for (uint64_t co = 0; co < CO; co++) {
      for (uint64_t d = 0; d < outD; d++) {
        for (uint64_t h = 0; h < outH; h++) {
          for (uint64_t w = 0; w < outW; w++) {
            for (uint64_t ci = 0; ci < CI; ci++) {
              uint64_t val = funcSSCons((int64_t)0);
              for (uint64_t fd = d; fd < (d + FD); fd++) {
                for (uint64_t fh = h; fh < (h + FH); fh++) {
                  for (uint64_t fw = w; fw < (w + FW); fw++) {
                    int64_t curPosD = ((fd - zPadDLeft) / strideD);

                    int64_t curPosH = ((fh - zPadHLeft) / strideD);

                    int64_t curPosW = ((fw - zPadWLeft) / strideD);
                    if ((((((((((curPosD >= 0) && (curPosH >= 0)) &&
                               (curPosW >= 0)) &&
                              (curPosD < D)) &&
                             (curPosH < H)) &&
                            (curPosW < W)) &&
                           (((fd - zPadDLeft) % strideD) == 0)) &&
                          (((fh - zPadHLeft) % strideH) == 0)) &&
                         (((fw - zPadWLeft) % strideW) == 0))) {
                      int64_t curFilterPosD = (((FD + d) - fd) - 1);

                      int64_t curFilterPosH = (((FH + h) - fh) - 1);

                      int64_t curFilterPosW = (((FW + w) - fw) - 1);
                      val = SecretAdd(
                          val, SecretMult(
                                   Arr5DIdxRowM(inputArr, N, D, H, W, CI, n,
                                                curPosD, curPosH, curPosW, ci),
                                   Arr5DIdxRowM(filterArr, FD, FH, FW, CO, CI,
                                                curFilterPosD, curFilterPosH,
                                                curFilterPosW, co, ci)));
                    }
                  }
                }
              }
              Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d, h, w, co) =
                  SecretAdd(Arr5DIdxRowM(outArr, N, outD, outH, outW, CO, n, d,
                                         h, w, co),
                            val);
            }
          }
        }
      }
    }
  }
}

void ConvTranspose3DLoop(int64_t N, int64_t DPrime, int64_t HPrime,
                         int64_t WPrime, int64_t CI, int64_t FD, int64_t FH,
                         int64_t FW, int64_t CO, int64_t D, int64_t H,
                         int64_t W, int64_t zPadTrDLeft, int64_t zPadTrDRight,
                         int64_t zPadTrHLeft, int64_t zPadTrHRight,
                         int64_t zPadTrWLeft, int64_t zPadTrWRight,
                         int64_t strideD, int64_t strideH, int64_t strideW,
                         uint64_t *inputArr, uint64_t *filterArr,
                         uint64_t *outArr) {
  ConvTranspose3DLoopInner(N, DPrime, HPrime, WPrime, CI, FD, FH, FW, CO,
                           zPadTrDLeft, zPadTrDRight, zPadTrHLeft, zPadTrHRight,
                           zPadTrWLeft, zPadTrWRight, strideD, strideH, strideW,
                           D, H, W, inputArr, filterArr, outArr);
}

void Transpose2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr) {
  for (uint64_t i = 0; i < s1; i++) {
    for (uint64_t j = 0; j < s2; j++) {
      Arr2DIdxRowM(outArr, s1, s2, i, j) = Arr2DIdxRowM(inArr, s2, s1, j, i);
    }
  }
}

void Pad442(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t inps1,
            int64_t inps2, int64_t inps3, int64_t inps4, uint64_t *inpArr,
            int64_t pads1, int64_t pads2, int64_t *paddings, uint64_t *outArr) {
  int64_t lbounds1 = Arr2DIdxRowM(paddings, pads1, pads2, 0, 0);

  int64_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings, pads1, pads2, 0, 1));

  int64_t lbounds2 = Arr2DIdxRowM(paddings, pads1, pads2, 1, 0);

  int64_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings, pads1, pads2, 1, 1));

  int64_t lbounds3 = Arr2DIdxRowM(paddings, pads1, pads2, 2, 0);

  int64_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings, pads1, pads2, 2, 1));

  int64_t lbounds4 = Arr2DIdxRowM(paddings, pads1, pads2, 3, 0);

  int64_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings, pads1, pads2, 3, 1));
  for (uint64_t i = 0; i < s1; i++) {
    for (uint64_t j = 0; j < s2; j++) {
      for (uint64_t k = 0; k < s3; k++) {
        for (uint64_t l = 0; l < s4; l++) {
          if (((((((((i >= lbounds1) && (i < rbounds1excl)) &&
                    (j >= lbounds2)) &&
                   (j < rbounds2excl)) &&
                  (k >= lbounds3)) &&
                 (k < rbounds3excl)) &&
                (l >= lbounds4)) &&
               (l < rbounds4excl))) {
            Arr4DIdxRowM(outArr, s1, s2, s3, s4, i, j, k, l) =
                Arr4DIdxRowM(inpArr, inps1, inps2, inps3, inps4,
                             (i - Arr2DIdxRowM(paddings, pads1, pads2, 0, 0)),
                             (j - Arr2DIdxRowM(paddings, pads1, pads2, 1, 0)),
                             (k - Arr2DIdxRowM(paddings, pads1, pads2, 2, 0)),
                             (l - Arr2DIdxRowM(paddings, pads1, pads2, 3, 0)));
          } else {
            Arr4DIdxRowM(outArr, s1, s2, s3, s4, i, j, k, l) =
                funcSSCons((int64_t)0);
          }
        }
      }
    }
  }
}

void Pad552(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5,
            int64_t inps1, int64_t inps2, int64_t inps3, int64_t inps4,
            int64_t inps5, uint64_t *inpArr, int64_t pads1, int64_t pads2,
            int64_t *paddings, uint64_t *outArr) {
  int64_t lbounds1 = Arr2DIdxRowM(paddings, pads1, pads2, 0, 0);

  int64_t rbounds1excl = (s1 - Arr2DIdxRowM(paddings, pads1, pads2, 0, 1));

  int64_t lbounds2 = Arr2DIdxRowM(paddings, pads1, pads2, 1, 0);

  int64_t rbounds2excl = (s2 - Arr2DIdxRowM(paddings, pads1, pads2, 1, 1));

  int64_t lbounds3 = Arr2DIdxRowM(paddings, pads1, pads2, 2, 0);

  int64_t rbounds3excl = (s3 - Arr2DIdxRowM(paddings, pads1, pads2, 2, 1));

  int64_t lbounds4 = Arr2DIdxRowM(paddings, pads1, pads2, 3, 0);

  int64_t rbounds4excl = (s4 - Arr2DIdxRowM(paddings, pads1, pads2, 3, 1));

  int64_t lbounds5 = Arr2DIdxRowM(paddings, pads1, pads2, 4, 0);

  int64_t rbounds5excl = (s5 - Arr2DIdxRowM(paddings, pads1, pads2, 4, 1));
  for (uint64_t i = 0; i < s1; i++) {
    for (uint64_t j = 0; j < s2; j++) {
      for (uint64_t k = 0; k < s3; k++) {
        for (uint64_t l = 0; l < s4; l++) {
          for (uint64_t m = 0; m < s5; m++) {
            if (((((((((((i >= lbounds1) && (i < rbounds1excl)) &&
                        (j >= lbounds2)) &&
                       (j < rbounds2excl)) &&
                      (k >= lbounds3)) &&
                     (k < rbounds3excl)) &&
                    (l >= lbounds4)) &&
                   (l < rbounds4excl)) &&
                  (m >= lbounds5)) &&
                 (m < rbounds5excl))) {
              Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) =
                  Arr5DIdxRowM(
                      inpArr, inps1, inps2, inps3, inps4, inps5,
                      (i - Arr2DIdxRowM(paddings, pads1, pads2, 0, 0)),
                      (j - Arr2DIdxRowM(paddings, pads1, pads2, 1, 0)),
                      (k - Arr2DIdxRowM(paddings, pads1, pads2, 2, 0)),
                      (l - Arr2DIdxRowM(paddings, pads1, pads2, 3, 0)),
                      (m - Arr2DIdxRowM(paddings, pads1, pads2, 4, 0)));
            } else {
              Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i, j, k, l, m) =
                  funcSSCons((int64_t)0);
            }
          }
        }
      }
    }
  }
}

void PadONNX441(int64_t o1, int64_t o2, int64_t o3, int64_t o4, int64_t i1,
                int64_t i2, int64_t i3, int64_t i4, uint64_t *inpArr,
                int64_t pads, int64_t *paddings, uint64_t *outArr) {
  int64_t lbounds1 = Arr1DIdxRowM(paddings, pads, 0);

  int64_t rbounds1excl = (o1 - Arr1DIdxRowM(paddings, pads, 4));

  int64_t lbounds2 = Arr1DIdxRowM(paddings, pads, 1);

  int64_t rbounds2excl = (o2 - Arr1DIdxRowM(paddings, pads, 5));

  int64_t lbounds3 = Arr1DIdxRowM(paddings, pads, 2);

  int64_t rbounds3excl = (o3 - Arr1DIdxRowM(paddings, pads, 6));

  int64_t lbounds4 = Arr1DIdxRowM(paddings, pads, 3);

  int64_t rbounds4excl = (o4 - Arr1DIdxRowM(paddings, pads, 7));
  for (uint64_t i = 0; i < o1; i++) {
    for (uint64_t j = 0; j < o2; j++) {
      for (uint64_t k = 0; k < o3; k++) {
        for (uint64_t l = 0; l < o4; l++) {
          if (((((((((i >= lbounds1) && (i < rbounds1excl)) &&
                    (j >= lbounds2)) &&
                   (j < rbounds2excl)) &&
                  (k >= lbounds3)) &&
                 (k < rbounds3excl)) &&
                (l >= lbounds4)) &&
               (l < rbounds4excl))) {
            Arr4DIdxRowM(outArr, o1, o2, o3, o4, i, j, k, l) = Arr4DIdxRowM(
                inpArr, i1, i2, i3, i4, (i - Arr1DIdxRowM(paddings, pads, 0)),
                (j - Arr1DIdxRowM(paddings, pads, 1)),
                (k - Arr1DIdxRowM(paddings, pads, 2)),
                (l - Arr1DIdxRowM(paddings, pads, 3)));
          } else {
            Arr4DIdxRowM(outArr, o1, o2, o3, o4, i, j, k, l) =
                funcSSCons((int64_t)0);
          }
        }
      }
    }
  }
}

void Squeeze24(int64_t s1, int64_t s2, int64_t dim1, int64_t dim2, int64_t ins1,
               int64_t ins2, int64_t ins3, int64_t ins4, uint64_t *inArr,
               uint64_t *outArr) {
  for (uint64_t i = 0; i < ins1; i++) {
    for (uint64_t j = 0; j < ins2; j++) {
      for (uint64_t k = 0; k < ins3; k++) {
        for (uint64_t l = 0; l < ins4; l++) {
          int64_t linIdx =
              ((((((i * ins2) * ins3) * ins4) + ((j * ins3) * ins4)) +
                (k * ins4)) +
               l);

          int64_t outIdx1 = (linIdx / s2);

          int64_t outIdx2 = (linIdx % s2);
          Arr2DIdxRowM(outArr, s1, s2, outIdx1, outIdx2) =
              Arr4DIdxRowM(inArr, ins1, ins2, ins3, ins4, i, j, k, l);
        }
      }
    }
  }
}

void FusedBatchNorm4411(int64_t s1, int64_t s2, int64_t s3, int64_t s4,
                        uint64_t *inArr, uint64_t *multArr, uint64_t *biasArr,
                        int64_t multExprScaleDownSf, int64_t biasExprScaleUpSf,
                        uint64_t *outputArr) {
  uint64_t *biasArrScaledUp = make_array<uint64_t>(s4);
  for (uint64_t ii = 0; ii < s4; ii++) {
    Arr1DIdxRowM(biasArrScaledUp, s4, ii) = Arr1DIdxRowM(biasArr, s4, ii);
  }
  if ((biasExprScaleUpSf > 0)) {
    ScaleUp(s4, biasArrScaledUp, biasExprScaleUpSf);
  }

#if USE_CHEETAH
  if (gemini::IsTwoPower(prime_mod)) {
    int64_t n_ct_coeff_packing  = ((s2 * s3 + 4095) / 4096) * s4;
    int64_t n_ct_bfv_packing  = ((s2 * s3 * s4 + 4095) / 4096) * 3;
    if (n_ct_coeff_packing < n_ct_bfv_packing) {
      BatchNorm(s1, s2, s3, s4, inArr, multArr, biasArrScaledUp, outputArr);
      ClearMemSecret1(s4, biasArrScaledUp);
      return;
    }
  }
#endif
  int64_t inpSize = (((s1 * s2) * s3) * s4);
  uint64_t *inArrReshaped = make_array<uint64_t>(inpSize);

  uint64_t *multArrReshaped = make_array<uint64_t>(inpSize);

  uint64_t *multExprAns = make_array<uint64_t>(inpSize);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          int64_t linIdx =
              ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4);
          Arr1DIdxRowM(inArrReshaped, inpSize, linIdx) =
              Arr4DIdxRowM(inArr, s1, s2, s3, s4, i1, i2, i3, i4);
          Arr1DIdxRowM(multArrReshaped, inpSize, linIdx) =
              Arr1DIdxRowM(multArr, s4, i4);
        }
      }
    }
  }
  ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped,
                             multExprAns);
  if ((multExprScaleDownSf > 0)) {
    ScaleDown(inpSize, multExprAns, multExprScaleDownSf);
  }


  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          int64_t linIdx =
              ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4);
          Arr4DIdxRowM(outputArr, s1, s2, s3, s4, i1, i2, i3, i4) =
              SecretAdd(Arr1DIdxRowM(multExprAns, inpSize, linIdx),
                        Arr1DIdxRowM(biasArrScaledUp, s4, i4));
        }
      }
    }
  }
  ClearMemSecret1(inpSize, inArrReshaped);
  ClearMemSecret1(inpSize, multArrReshaped);
  ClearMemSecret1(inpSize, multExprAns);
  ClearMemSecret1(s4, biasArrScaledUp);

  // std::cout << "Not use fused: ";
  // for (int m = 0; m < 10; ++m) {
  //   std::cout << funcReconstruct2PCCons(outputArr[m], 2) / std::pow(2.,
  //   kScale) << " ";
  // }
  // std::cout << "\n";
}

void FusedBatchNorm5511(int64_t s1, int64_t s2, int64_t s3, int64_t s4,
                        int64_t s5, uint64_t *inArr, uint64_t *multArr,
                        uint64_t *biasArr, int64_t multExprScaleDownSf,
                        int64_t biasExprScaleUpSf, uint64_t *outputArr) {
  int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5);

  uint64_t *inArrReshaped = make_array<uint64_t>(inpSize);

  uint64_t *multArrReshaped = make_array<uint64_t>(inpSize);

  uint64_t *multExprAns = make_array<uint64_t>(inpSize);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          for (uint64_t i5 = 0; i5 < s5; i5++) {
            int64_t linIdx =
                ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) +
                   ((i3 * s4) * s5)) +
                  (i4 * s5)) +
                 i5);
            Arr1DIdxRowM(inArrReshaped, inpSize, linIdx) =
                Arr5DIdxRowM(inArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5);
            Arr1DIdxRowM(multArrReshaped, inpSize, linIdx) =
                Arr1DIdxRowM(multArr, s5, i5);
          }
        }
      }
    }
  }
  ElemWiseActModelVectorMult(inpSize, inArrReshaped, multArrReshaped,
                             multExprAns);
  if ((multExprScaleDownSf > 0)) {
    ScaleDown(inpSize, multExprAns, multExprScaleDownSf);
  }

  uint64_t *biasArrScaledUp = make_array<uint64_t>(s5);
  for (uint64_t ii = 0; ii < s5; ii++) {
    Arr1DIdxRowM(biasArrScaledUp, s5, ii) = Arr1DIdxRowM(biasArr, s5, ii);
  }
  if ((biasExprScaleUpSf > 0)) {
    ScaleUp(s5, biasArrScaledUp, biasExprScaleUpSf);
  }
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          for (uint64_t i5 = 0; i5 < s5; i5++) {
            int64_t linIdx =
                ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) +
                   ((i3 * s4) * s5)) +
                  (i4 * s5)) +
                 i5);
            Arr5DIdxRowM(outputArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) =
                SecretAdd(Arr1DIdxRowM(multExprAns, inpSize, linIdx),
                          Arr1DIdxRowM(biasArrScaledUp, s5, i5));
          }
        }
      }
    }
  }
  ClearMemSecret1(inpSize, inArrReshaped);
  ClearMemSecret1(inpSize, multArrReshaped);
  ClearMemSecret1(inpSize, multExprAns);
  ClearMemSecret1(s5, biasArrScaledUp);
}

void ElemWiseMul2(int64_t s1, int64_t s2, uint64_t *arr1, uint64_t *arr2,
                  uint64_t *outArr) {
  int64_t inpSize = (s1 * s2);

  uint64_t *arr1Reshaped = make_array<uint64_t>(inpSize);

  uint64_t *arr2Reshaped = make_array<uint64_t>(inpSize);

  uint64_t *outArrReshaped = make_array<uint64_t>(inpSize);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      int64_t linIdx = ((i1 * s2) + i2);
      Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) =
          Arr2DIdxRowM(arr1, s1, s2, i1, i2);
      Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) =
          Arr2DIdxRowM(arr2, s1, s2, i1, i2);
    }
  }
  ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped,
                                 outArrReshaped);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      int64_t linIdx = ((i1 * s2) + i2);
      Arr2DIdxRowM(outArr, s1, s2, i1, i2) =
          Arr1DIdxRowM(outArrReshaped, inpSize, linIdx);
    }
  }
  ClearMemSecret1(inpSize, arr1Reshaped);
  ClearMemSecret1(inpSize, arr2Reshaped);
  ClearMemSecret1(inpSize, outArrReshaped);
}

void ElemWiseMul4(int64_t s1, int64_t s2, int64_t s3, int64_t s4,
                  uint64_t *arr1, uint64_t *arr2, uint64_t *outArr) {
  int64_t inpSize = (((s1 * s2) * s3) * s4);

  uint64_t *arr1Reshaped = make_array<uint64_t>(inpSize);

  uint64_t *arr2Reshaped = make_array<uint64_t>(inpSize);

  uint64_t *outArrReshaped = make_array<uint64_t>(inpSize);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          int64_t linIdx =
              ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4);
          Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) =
              Arr4DIdxRowM(arr1, s1, s2, s3, s4, i1, i2, i3, i4);
          Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) =
              Arr4DIdxRowM(arr2, s1, s2, s3, s4, i1, i2, i3, i4);
        }
      }
    }
  }
  ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped,
                                 outArrReshaped);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          int64_t linIdx =
              ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4);
          Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) =
              Arr1DIdxRowM(outArrReshaped, inpSize, linIdx);
        }
      }
    }
  }
  ClearMemSecret1(inpSize, arr1Reshaped);
  ClearMemSecret1(inpSize, arr2Reshaped);
  ClearMemSecret1(inpSize, outArrReshaped);
}

void ElemWiseMul5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5,
                  uint64_t *arr1, uint64_t *arr2, uint64_t *outArr) {
  int64_t inpSize = ((((s1 * s2) * s3) * s4) * s5);

  uint64_t *arr1Reshaped = make_array<uint64_t>(inpSize);

  uint64_t *arr2Reshaped = make_array<uint64_t>(inpSize);

  uint64_t *outArrReshaped = make_array<uint64_t>(inpSize);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          for (uint64_t i5 = 0; i5 < s5; i5++) {
            int64_t linIdx =
                ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) +
                   ((i3 * s4) * s5)) +
                  (i4 * s5)) +
                 i5);
            Arr1DIdxRowM(arr1Reshaped, inpSize, linIdx) =
                Arr5DIdxRowM(arr1, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5);
            Arr1DIdxRowM(arr2Reshaped, inpSize, linIdx) =
                Arr5DIdxRowM(arr2, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5);
          }
        }
      }
    }
  }
  ElemWiseSecretSharedVectorMult(inpSize, arr1Reshaped, arr2Reshaped,
                                 outArrReshaped);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          for (uint64_t i5 = 0; i5 < s5; i5++) {
            int64_t linIdx =
                ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) +
                   ((i3 * s4) * s5)) +
                  (i4 * s5)) +
                 i5);
            Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) =
                Arr1DIdxRowM(outArrReshaped, inpSize, linIdx);
          }
        }
      }
    }
  }
  ClearMemSecret1(inpSize, arr1Reshaped);
  ClearMemSecret1(inpSize, arr2Reshaped);
  ClearMemSecret1(inpSize, outArrReshaped);
}

void ReduceMean24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2,
                  int64_t inS3, int64_t inS4, uint64_t *inputArr, int64_t *axes,
                  uint64_t *outputArr) {
  int64_t divisor = (inS2 * inS3);

  int64_t outputSize = (outS1 * outS2);

  uint64_t *sumArr = make_array<uint64_t>(outputSize);

  uint64_t *outputArrReshaped = make_array<uint64_t>(outputSize);
  for (uint64_t i1 = 0; i1 < outS1; i1++) {
    for (uint64_t i2 = 0; i2 < outS2; i2++) {
      uint64_t summ = funcSSCons((int64_t)0);
      for (uint64_t i = 0; i < inS2; i++) {
        for (uint64_t j = 0; j < inS3; j++) {
          summ = SecretAdd(summ, Arr4DIdxRowM(inputArr, inS1, inS2, inS3, inS4,
                                              i1, i, j, i2));
        }
      }
      Arr1DIdxRowM(sumArr, outputSize, ((i1 * outS2) + i2)) = summ;
    }
  }
  ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped);
  for (uint64_t i1 = 0; i1 < outS1; i1++) {
    for (uint64_t i2 = 0; i2 < outS2; i2++) {
      Arr2DIdxRowM(outputArr, outS1, outS2, i1, i2) =
          Arr1DIdxRowM(outputArrReshaped, outputSize, ((i1 * outS2) + i2));
    }
  }
  ClearMemSecret1(outputSize, sumArr);
  ClearMemSecret1(outputSize, outputArrReshaped);
}

void ReduceMeanONNX24(int64_t outS1, int64_t outS2, int64_t inS1, int64_t inS2,
                      int64_t inS3, int64_t inS4, uint64_t *inputArr,
                      int64_t axis1, int64_t axis2, uint64_t *outputArr) {
  int64_t divisor = (inS3 * inS4);

  int64_t outputSize = (outS1 * outS2);

  uint64_t *sumArr = make_array<uint64_t>(outputSize);

  uint64_t *outputArrReshaped = make_array<uint64_t>(outputSize);
  for (uint64_t i1 = 0; i1 < outS1; i1++) {
    for (uint64_t i2 = 0; i2 < outS2; i2++) {
      uint64_t summ = funcSSCons((int64_t)0);
      for (uint64_t i = 0; i < inS3; i++) {
        for (uint64_t j = 0; j < inS4; j++) {
          summ = SecretAdd(summ, Arr4DIdxRowM(inputArr, inS1, inS2, inS3, inS4,
                                              i1, i2, i, j));
        }
      }
      Arr1DIdxRowM(sumArr, outputSize, ((i1 * outS2) + i2)) = summ;
    }
  }
  ElemWiseVectorPublicDiv(outputSize, sumArr, divisor, outputArrReshaped);
  for (uint64_t i1 = 0; i1 < outS1; i1++) {
    for (uint64_t i2 = 0; i2 < outS2; i2++) {
      Arr2DIdxRowM(outputArr, outS1, outS2, i1, i2) =
          Arr1DIdxRowM(outputArrReshaped, outputSize, ((i1 * outS2) + i2));
    }
  }
  ClearMemSecret1(outputSize, sumArr);
  ClearMemSecret1(outputSize, outputArrReshaped);
}

void ArgMax1(int64_t outArrS1, int64_t inArrS1, int64_t inArrS2,
             uint64_t *inArr, int64_t dim, uint64_t *outArr) {
  ArgMax(inArrS1, inArrS2, inArr, outArr);
}

void ArgMax3(int64_t outs1, int64_t outs2, int64_t outs3, int64_t ins1,
             int64_t ins2, int64_t ins3, int64_t ins4, uint64_t *inArr,
             int64_t dim, uint64_t *outArr) {
  int64_t size = ((ins1 * ins2) * ins3);

  uint64_t *reshapedInArr = make_array<uint64_t>(size, ins4);

  uint64_t *reshapedOutArr = make_array<uint64_t>(size);
  for (uint64_t i1 = 0; i1 < ins1; i1++) {
    for (uint64_t i2 = 0; i2 < ins2; i2++) {
      for (uint64_t i3 = 0; i3 < ins3; i3++) {
        for (uint64_t i4 = 0; i4 < ins4; i4++) {
          int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3);
          Arr2DIdxRowM(reshapedInArr, size, ins4, linIdx, i4) =
              Arr4DIdxRowM(inArr, ins1, ins2, ins3, ins4, i1, i2, i3, i4);
        }
      }
    }
  }
  ArgMax(size, ins4, reshapedInArr, reshapedOutArr);
  for (uint64_t i1 = 0; i1 < ins1; i1++) {
    for (uint64_t i2 = 0; i2 < ins2; i2++) {
      for (uint64_t i3 = 0; i3 < ins3; i3++) {
        int64_t linIdx = ((((i1 * ins2) * ins3) + (i2 * ins3)) + i3);
        Arr3DIdxRowM(outArr, outs1, outs2, outs3, i1, i2, i3) =
            Arr1DIdxRowM(reshapedOutArr, size, linIdx);
      }
    }
  }
  ClearMemSecret2(size, ins4, reshapedInArr);
  ClearMemSecret1(size, reshapedOutArr);
}

void Relu2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr,
           int64_t sf, uint64_t doTruncation) {
  int64_t size = (s1 * s2);

  uint64_t *reshapedInArr = make_array<uint64_t>(size);

  uint64_t *reshapedOutArr = make_array<uint64_t>(size);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      int64_t linIdx = ((i1 * s2) + i2);
      Arr1DIdxRowM(reshapedInArr, size, linIdx) =
          Arr2DIdxRowM(inArr, s1, s2, i1, i2);
    }
  }
  Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      int64_t linIdx = ((i1 * s2) + i2);
      Arr2DIdxRowM(outArr, s1, s2, i1, i2) =
          Arr1DIdxRowM(reshapedOutArr, size, linIdx);
    }
  }
  ClearMemSecret1(size, reshapedInArr);
  ClearMemSecret1(size, reshapedOutArr);
}

void Relu4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *inArr,
           uint64_t *outArr, int64_t sf, uint64_t doTruncation) {
  int64_t size = (((s1 * s2) * s3) * s4);

  uint64_t *reshapedInArr = make_array<uint64_t>(size);

  uint64_t *reshapedOutArr = make_array<uint64_t>(size);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          int64_t linIdx =
              ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4);
          Arr1DIdxRowM(reshapedInArr, size, linIdx) =
              Arr4DIdxRowM(inArr, s1, s2, s3, s4, i1, i2, i3, i4);
        }
      }
    }
  }

  Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation);

  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          int64_t linIdx =
              ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4);
          Arr4DIdxRowM(outArr, s1, s2, s3, s4, i1, i2, i3, i4) =
              Arr1DIdxRowM(reshapedOutArr, size, linIdx);
        }
      }
    }
  }
  ClearMemSecret1(size, reshapedInArr);
  ClearMemSecret1(size, reshapedOutArr);
}

void Relu5(int64_t s1, int64_t s2, int64_t s3, int64_t s4, int64_t s5,
           uint64_t *inArr, uint64_t *outArr, int64_t sf,
           uint64_t doTruncation) {
  int64_t size = ((((s1 * s2) * s3) * s4) * s5);

  uint64_t *reshapedInArr = make_array<uint64_t>(size);

  uint64_t *reshapedOutArr = make_array<uint64_t>(size);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          for (uint64_t i5 = 0; i5 < s5; i5++) {
            int64_t linIdx =
                ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) +
                   ((i3 * s4) * s5)) +
                  (i4 * s5)) +
                 i5);
            Arr1DIdxRowM(reshapedInArr, size, linIdx) =
                Arr5DIdxRowM(inArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5);
          }
        }
      }
    }
  }
  Relu(size, reshapedInArr, reshapedOutArr, sf, doTruncation);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          for (uint64_t i5 = 0; i5 < s5; i5++) {
            int64_t linIdx =
                ((((((((i1 * s2) * s3) * s4) * s5) + (((i2 * s3) * s4) * s5)) +
                   ((i3 * s4) * s5)) +
                  (i4 * s5)) +
                 i5);
            Arr5DIdxRowM(outArr, s1, s2, s3, s4, s5, i1, i2, i3, i4, i5) =
                Arr1DIdxRowM(reshapedOutArr, size, linIdx);
          }
        }
      }
    }
  }
  ClearMemSecret1(size, reshapedInArr);
  ClearMemSecret1(size, reshapedOutArr);
}

void Floor2(int64_t s1, int64_t s2, uint64_t *inArr, uint64_t *outArr,
            int64_t sf) {
  int64_t size = (s1 * s2);

  uint64_t *reshapedInArr = make_array<uint64_t>(size);

  uint64_t *reshapedOutArr = make_array<uint64_t>(size);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      int64_t linIdx = ((i1 * s2) + i2);
      Arr1DIdxRowM(reshapedInArr, size, linIdx) =
          Arr2DIdxRowM(inArr, s1, s2, i1, i2);
    }
  }
  Floor(size, reshapedInArr, reshapedOutArr, sf);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      int64_t linIdx = ((i1 * s2) + i2);
      Arr2DIdxRowM(outArr, s1, s2, i1, i2) =
          Arr1DIdxRowM(reshapedOutArr, size, linIdx);
    }
  }
  ClearMemSecret1(size, reshapedInArr);
  ClearMemSecret1(size, reshapedOutArr);
}

void ScaleUp1(int64_t s1, uint64_t *arr, int64_t sf) { ScaleUp(s1, arr, sf); }

void ScaleUp2(int64_t s1, int64_t s2, uint64_t *arr, int64_t sf) {
  int64_t size = (s1 * s2);

  uint64_t *reshapedArr = make_array<uint64_t>(size);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      int64_t linIdx = ((i1 * s2) + i2);
      Arr1DIdxRowM(reshapedArr, size, linIdx) =
          Arr2DIdxRowM(arr, s1, s2, i1, i2);
    }
  }
  ScaleUp(size, reshapedArr, sf);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      int64_t linIdx = ((i1 * s2) + i2);
      Arr2DIdxRowM(arr, s1, s2, i1, i2) =
          Arr1DIdxRowM(reshapedArr, size, linIdx);
    }
  }
  ClearMemSecret1(size, reshapedArr);
}

void ScaleUp3(int64_t s1, int64_t s2, int64_t s3, uint64_t *arr, int64_t sf) {
  int64_t size = ((s1 * s2) * s3);

  uint64_t *reshapedArr = make_array<uint64_t>(size);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3);
        Arr1DIdxRowM(reshapedArr, size, linIdx) =
            Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3);
      }
    }
  }
  ScaleUp(size, reshapedArr, sf);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3);
        Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) =
            Arr1DIdxRowM(reshapedArr, size, linIdx);
      }
    }
  }
  ClearMemSecret1(size, reshapedArr);
}

void ScaleUp4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *arr,
              int64_t sf) {
  int64_t size = (((s1 * s2) * s3) * s4);

  uint64_t *reshapedArr = make_array<uint64_t>(size);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          int64_t linIdx =
              ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4);
          Arr1DIdxRowM(reshapedArr, size, linIdx) =
              Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4);
        }
      }
    }
  }
  ScaleUp(size, reshapedArr, sf);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          int64_t linIdx =
              ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4);
          Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) =
              Arr1DIdxRowM(reshapedArr, size, linIdx);
        }
      }
    }
  }
  ClearMemSecret1(size, reshapedArr);
}

void ScaleDown1(int64_t s1, uint64_t *arr, int64_t sf) {
  ScaleDown(s1, arr, sf);
}

void ScaleDown2(int64_t s1, int64_t s2, uint64_t *arr, int64_t sf) {
  int64_t size = (s1 * s2);

  uint64_t *reshapedArr = make_array<uint64_t>(size);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      int64_t linIdx = ((i1 * s2) + i2);
      Arr1DIdxRowM(reshapedArr, size, linIdx) =
          Arr2DIdxRowM(arr, s1, s2, i1, i2);
    }
  }
  ScaleDown(size, reshapedArr, sf);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      int64_t linIdx = ((i1 * s2) + i2);
      Arr2DIdxRowM(arr, s1, s2, i1, i2) =
          Arr1DIdxRowM(reshapedArr, size, linIdx);
    }
  }
  ClearMemSecret1(size, reshapedArr);
}

void ScaleDown3(int64_t s1, int64_t s2, int64_t s3, uint64_t *arr, int64_t sf) {
  int64_t size = ((s1 * s2) * s3);

  uint64_t *reshapedArr = make_array<uint64_t>(size);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3);
        Arr1DIdxRowM(reshapedArr, size, linIdx) =
            Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3);
      }
    }
  }
  ScaleDown(size, reshapedArr, sf);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        int64_t linIdx = ((((i1 * s2) * s3) + (i2 * s3)) + i3);
        Arr3DIdxRowM(arr, s1, s2, s3, i1, i2, i3) =
            Arr1DIdxRowM(reshapedArr, size, linIdx);
      }
    }
  }
  ClearMemSecret1(size, reshapedArr);
}

void ScaleDown4(int64_t s1, int64_t s2, int64_t s3, int64_t s4, uint64_t *arr,
                int64_t sf) {
  int64_t size = (((s1 * s2) * s3) * s4);

  uint64_t *reshapedArr = make_array<uint64_t>(size);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          int64_t linIdx =
              ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4);
          Arr1DIdxRowM(reshapedArr, size, linIdx) =
              Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4);
        }
      }
    }
  }
  ScaleDown(size, reshapedArr, sf);
  for (uint64_t i1 = 0; i1 < s1; i1++) {
    for (uint64_t i2 = 0; i2 < s2; i2++) {
      for (uint64_t i3 = 0; i3 < s3; i3++) {
        for (uint64_t i4 = 0; i4 < s4; i4++) {
          int64_t linIdx =
              ((((((i1 * s2) * s3) * s4) + ((i2 * s3) * s4)) + (i3 * s4)) + i4);
          Arr4DIdxRowM(arr, s1, s2, s3, s4, i1, i2, i3, i4) =
              Arr1DIdxRowM(reshapedArr, size, linIdx);
        }
      }
    }
  }
  ClearMemSecret1(size, reshapedArr);
}

void FusedBN(int32_t N, int32_t H, int32_t W, int32_t CI, int32_t fh,
             int32_t fw, int32_t CO, int32_t padHLeft, int32_t padHRight,
             int32_t padWLeft, int32_t padWRight, int32_t strideH,
             int32_t strideW, uint64_t *in_tensor, 
             const uint64_t *filters,
             const uint64_t *bn_scales, 
             const uint64_t *bn_bias,
             uint64_t *out_tensor) {
  const double _scale = std::pow(2., kScale);

  uint64_t *scaled_filters = make_array<uint64_t>(fh, fw, CI, CO);
  if (party == SERVER) {
    std::vector<double>bn_scales_f64(CO);
    std::transform(bn_scales, bn_scales + CO, bn_scales_f64.data(), [_scale](uint64_t v) -> double { return getSignValue(v) / _scale; });
    for (int32_t h = 0; h < fh; ++h) {
      for (int32_t w = 0; w < fw; ++w) {
        for (int32_t c = 0; c < CI; ++c) {
          for (int32_t m = 0; m < CO; ++m) {
            const double bn_scale = bn_scales_f64[m];
            double fval = getSignValue(Arr4DIdxRowM(filters, fh, fw, CI, CO, h, w, c, m)) / _scale;
            int64_t f64 = static_cast<int64_t>(std::round(fval * bn_scale * _scale));
            Arr4DIdxRowM(scaled_filters, fh, fw, CI, CO, h, w, c, m) = sci::neg_mod(f64, prime_mod);
          }
        }
      }
    }
    bool allz = std::all_of(scaled_filters, scaled_filters + fh * fw * CI * CO, [](uint64_t v) { return 0 == v; });
    if (allz) {
      for (int i = 0; i < 8; ++i) {
        double fval = getSignValue(filters[i]) / _scale;
        std::cout << bn_scales_f64[i]  << " * " << fval << "\n";
      }
      printf("warning! fusedBN result at all zero filter!\n");
      exit(0);
    }
  } else {
    std::fill_n(scaled_filters, fh * fw * CI * CO, 0);
  }

  Conv2DWrapper(N, H, W, CI, fh, fw, CO, padHLeft, padHRight, padWLeft, padWRight, strideH, strideW, in_tensor, scaled_filters, out_tensor);

  int32_t newH = (((H + (padHLeft + padHRight)) - fh) / strideH) + 1;
  int32_t newW = (((W + (padWLeft + padWRight)) - fw) / strideW) + 1;
  if (party == SERVER) {
    uint64_t *scaled_bias = make_array<uint64_t>(CO);
    std::copy_n(bn_bias, CO, scaled_bias);
    ScaleUp1(CO, scaled_bias, kScale);
    for (int32_t n = 0; n < N; ++n) {
      for (int32_t h = 0; h < newH; ++h) {
        for (int32_t w = 0; w < newW; ++w) {
          for (int32_t m = 0; m < CO; ++m) {
            uint64_t val = Arr4DIdxRowM(out_tensor, N, newH, newW, CO, n, h, w, m);
            Arr4DIdxRowM(out_tensor, N, newH, newW, CO, n, h, w, m) = SecretAdd(val, scaled_bias[m]);
          }
        }
      }
    }
    ClearMemSecret1(CO, scaled_bias);
  }
  ClearMemSecret1(CO * CI * fh * fw, scaled_filters);
}

#define gINPUT std::cin
#define gINPUTCLOSE
int main(int argc, char **argv) {
  ArgMapping amap;

  amap.arg("r", party, "Role of party: ALICE/SERVER = 1; BOB/CLIENT = 2");
  amap.arg("p", port, "Port Number");
  amap.arg("ip", address, "IP Address of server (ALICE)");
  amap.arg("nt", num_threads, "Number of Threads");
  amap.arg("ell", bitlength, "Uniform Bitwidth");
  amap.arg("k", kScale, "bits of scale");
  amap.parse(argc, argv);

  assert(party == SERVER || party == CLIENT);
  std::cerr << "Loading input from stdin..." << std::endl;
  uint64_t *tmp0 = make_array<uint64_t>(1, 224, 224, 3);
  /* Variable to read the clear value corresponding to the input variable tmp0
   * at (1930,1-1930,46) */
  uint64_t __tmp_in_tmp0;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 224; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 224; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 3; i3++) {
          if (party == CLIENT) {
            gINPUT>> __tmp_in_tmp0;
          }
          Arr4DIdxRowM(tmp0, 1, 224, 224, 3, i0, i1, i2, i3) =
              (party == CLIENT) ? __tmp_in_tmp0 : 0;
        }
      }
    }
  }

  uint64_t *tmp1 = make_array<uint64_t>(7, 7, 3, 64);
  /* Variable to read the clear value corresponding to the input variable tmp1
   * at (1933,1-1933,43) */
  uint64_t __tmp_in_tmp1;
  for (uint64_t i0 = (uint64_t)0; i0 < 7; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 7; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 3; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 64; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp1;
          }
          Arr4DIdxRowM(tmp1, 7, 7, 3, 64, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp1 : 0;
        }
      }
    }
  }

  uint64_t *tmp2 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp2
   * at (1936,1-1936,34) */
  uint64_t __tmp_in_tmp2;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp2;
    }
    Arr1DIdxRowM(tmp2, 64, i0) = (party == SERVER) ? __tmp_in_tmp2 : 0;
  }

  uint64_t *tmp3 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp3
   * at (1939,1-1939,34) */
  uint64_t __tmp_in_tmp3;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp3;
    }
    Arr1DIdxRowM(tmp3, 64, i0) = (party == SERVER) ? __tmp_in_tmp3 : 0;
  }

  uint64_t *tmp4 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp4
   * at (1942,1-1942,34) */
  uint64_t __tmp_in_tmp4;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp4;
    }
    Arr1DIdxRowM(tmp4, 64, i0) = (party == SERVER) ? __tmp_in_tmp4 : 0;
  }

  uint64_t *tmp5 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp5
   * at (1945,1-1945,34) */
  uint64_t __tmp_in_tmp5;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp5;
    }
    Arr1DIdxRowM(tmp5, 64, i0) = (party == SERVER) ? __tmp_in_tmp5 : 0;
  }

  uint64_t *tmp6 = make_array<uint64_t>(1, 1, 64, 256);
  /* Variable to read the clear value corresponding to the input variable tmp6
   * at (1948,1-1948,45) */
  uint64_t __tmp_in_tmp6;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 64; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp6;
          }
          Arr4DIdxRowM(tmp6, 1, 1, 64, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp6 : 0;
        }
      }
    }
  }

  uint64_t *tmp7 = make_array<uint64_t>(1, 1, 64, 64);
  /* Variable to read the clear value corresponding to the input variable tmp7
   * at (1951,1-1951,44) */
  uint64_t __tmp_in_tmp7;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 64; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 64; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp7;
          }
          Arr4DIdxRowM(tmp7, 1, 1, 64, 64, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp7 : 0;
        }
      }
    }
  }


  uint64_t *tmp8 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp8
   * at (1954,1-1954,34) */
  uint64_t __tmp_in_tmp8;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp8;
    }
    Arr1DIdxRowM(tmp8, 64, i0) = (party == SERVER) ? __tmp_in_tmp8 : 0;
  }

  uint64_t *tmp9 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp9
   * at (1957,1-1957,34) */
  uint64_t __tmp_in_tmp9;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp9;
    }
    Arr1DIdxRowM(tmp9, 64, i0) = (party == SERVER) ? __tmp_in_tmp9 : 0;
  }

  uint64_t *tmp10 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp10
   * at (1960,1-1960,35) */
  uint64_t __tmp_in_tmp10;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp10;
    }
    Arr1DIdxRowM(tmp10, 64, i0) = (party == SERVER) ? __tmp_in_tmp10 : 0;
  }

  uint64_t *tmp11 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp11
   * at (1963,1-1963,35) */
  uint64_t __tmp_in_tmp11;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp11;
    }
    Arr1DIdxRowM(tmp11, 64, i0) = (party == SERVER) ? __tmp_in_tmp11 : 0;
  }

  uint64_t *tmp12 = make_array<uint64_t>(3, 3, 64, 64);
  /* Variable to read the clear value corresponding to the input variable tmp12
   * at (1966,1-1966,45) */
  uint64_t __tmp_in_tmp12;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 64; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 64; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp12;
          }
          Arr4DIdxRowM(tmp12, 3, 3, 64, 64, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp12 : 0;
        }
      }
    }
  }

  uint64_t *tmp13 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp13
   * at (1969,1-1969,35) */
  uint64_t __tmp_in_tmp13;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp13;
    }
    Arr1DIdxRowM(tmp13, 64, i0) = (party == SERVER) ? __tmp_in_tmp13 : 0;
  }

  uint64_t *tmp14 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp14
   * at (1972,1-1972,35) */
  uint64_t __tmp_in_tmp14;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp14;
    }
    Arr1DIdxRowM(tmp14, 64, i0) = (party == SERVER) ? __tmp_in_tmp14 : 0;
  }

  uint64_t *tmp15 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp15
   * at (1975,1-1975,35) */
  uint64_t __tmp_in_tmp15;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp15;
    }
    Arr1DIdxRowM(tmp15, 64, i0) = (party == SERVER) ? __tmp_in_tmp15 : 0;
  }

  uint64_t *tmp16 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp16
   * at (1978,1-1978,35) */
  uint64_t __tmp_in_tmp16;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp16;
    }
    Arr1DIdxRowM(tmp16, 64, i0) = (party == SERVER) ? __tmp_in_tmp16 : 0;
  }

  uint64_t *tmp17 = make_array<uint64_t>(1, 1, 64, 256);
  /* Variable to read the clear value corresponding to the input variable tmp17
   * at (1981,1-1981,46) */
  uint64_t __tmp_in_tmp17;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 64; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp17;
          }
          Arr4DIdxRowM(tmp17, 1, 1, 64, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp17 : 0;
        }
      }
    }
  }

  uint64_t *tmp18 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp18
   * at (1984,1-1984,36) */
  uint64_t __tmp_in_tmp18;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp18;
    }
    Arr1DIdxRowM(tmp18, 256, i0) = (party == SERVER) ? __tmp_in_tmp18 : 0;
  }

  uint64_t *tmp19 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp19
   * at (1987,1-1987,36) */
  uint64_t __tmp_in_tmp19;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp19;
    }
    Arr1DIdxRowM(tmp19, 256, i0) = (party == SERVER) ? __tmp_in_tmp19 : 0;
  }

  uint64_t *tmp20 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp20
   * at (1990,1-1990,36) */
  uint64_t __tmp_in_tmp20;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp20;
    }
    Arr1DIdxRowM(tmp20, 256, i0) = (party == SERVER) ? __tmp_in_tmp20 : 0;
  }

  uint64_t *tmp21 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp21
   * at (1993,1-1993,36) */
  uint64_t __tmp_in_tmp21;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp21;
    }
    Arr1DIdxRowM(tmp21, 256, i0) = (party == SERVER) ? __tmp_in_tmp21 : 0;
  }

  uint64_t *tmp22 = make_array<uint64_t>(1, 1, 256, 64);
  /* Variable to read the clear value corresponding to the input variable tmp22
   * at (1996,1-1996,46) */
  uint64_t __tmp_in_tmp22;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 64; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp22;
          }
          Arr4DIdxRowM(tmp22, 1, 1, 256, 64, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp22 : 0;
        }
      }
    }
  }

  uint64_t *tmp23 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp23
   * at (1999,1-1999,35) */
  uint64_t __tmp_in_tmp23;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp23;
    }
    Arr1DIdxRowM(tmp23, 64, i0) = (party == SERVER) ? __tmp_in_tmp23 : 0;
  }

  uint64_t *tmp24 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp24
   * at (2002,1-2002,35) */
  uint64_t __tmp_in_tmp24;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp24;
    }
    Arr1DIdxRowM(tmp24, 64, i0) = (party == SERVER) ? __tmp_in_tmp24 : 0;
  }

  uint64_t *tmp25 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp25
   * at (2005,1-2005,35) */
  uint64_t __tmp_in_tmp25;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp25;
    }
    Arr1DIdxRowM(tmp25, 64, i0) = (party == SERVER) ? __tmp_in_tmp25 : 0;
  }

  uint64_t *tmp26 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp26
   * at (2008,1-2008,35) */
  uint64_t __tmp_in_tmp26;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp26;
    }
    Arr1DIdxRowM(tmp26, 64, i0) = (party == SERVER) ? __tmp_in_tmp26 : 0;
  }

  uint64_t *tmp27 = make_array<uint64_t>(3, 3, 64, 64);
  /* Variable to read the clear value corresponding to the input variable tmp27
   * at (2011,1-2011,45) */
  uint64_t __tmp_in_tmp27;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 64; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 64; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp27;
          }
          Arr4DIdxRowM(tmp27, 3, 3, 64, 64, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp27 : 0;
        }
      }
    }
  }

  uint64_t *tmp28 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp28
   * at (2014,1-2014,35) */
  uint64_t __tmp_in_tmp28;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp28;
    }
    Arr1DIdxRowM(tmp28, 64, i0) = (party == SERVER) ? __tmp_in_tmp28 : 0;
  }

  uint64_t *tmp29 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp29
   * at (2017,1-2017,35) */
  uint64_t __tmp_in_tmp29;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp29;
    }
    Arr1DIdxRowM(tmp29, 64, i0) = (party == SERVER) ? __tmp_in_tmp29 : 0;
  }

  uint64_t *tmp30 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp30
   * at (2020,1-2020,35) */
  uint64_t __tmp_in_tmp30;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp30;
    }
    Arr1DIdxRowM(tmp30, 64, i0) = (party == SERVER) ? __tmp_in_tmp30 : 0;
  }

  uint64_t *tmp31 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp31
   * at (2023,1-2023,35) */
  uint64_t __tmp_in_tmp31;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp31;
    }
    Arr1DIdxRowM(tmp31, 64, i0) = (party == SERVER) ? __tmp_in_tmp31 : 0;
  }

  uint64_t *tmp32 = make_array<uint64_t>(1, 1, 64, 256);
  /* Variable to read the clear value corresponding to the input variable tmp32
   * at (2026,1-2026,46) */
  uint64_t __tmp_in_tmp32;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 64; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp32;
          }
          Arr4DIdxRowM(tmp32, 1, 1, 64, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp32 : 0;
        }
      }
    }
  }

  uint64_t *tmp33 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp33
   * at (2029,1-2029,36) */
  uint64_t __tmp_in_tmp33;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp33;
    }
    Arr1DIdxRowM(tmp33, 256, i0) = (party == SERVER) ? __tmp_in_tmp33 : 0;
  }

  uint64_t *tmp34 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp34
   * at (2032,1-2032,36) */
  uint64_t __tmp_in_tmp34;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp34;
    }
    Arr1DIdxRowM(tmp34, 256, i0) = (party == SERVER) ? __tmp_in_tmp34 : 0;
  }

  uint64_t *tmp35 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp35
   * at (2035,1-2035,36) */
  uint64_t __tmp_in_tmp35;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp35;
    }
    Arr1DIdxRowM(tmp35, 256, i0) = (party == SERVER) ? __tmp_in_tmp35 : 0;
  }

  uint64_t *tmp36 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp36
   * at (2038,1-2038,36) */
  uint64_t __tmp_in_tmp36;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp36;
    }
    Arr1DIdxRowM(tmp36, 256, i0) = (party == SERVER) ? __tmp_in_tmp36 : 0;
  }

  uint64_t *tmp37 = make_array<uint64_t>(1, 1, 256, 64);
  /* Variable to read the clear value corresponding to the input variable tmp37
   * at (2041,1-2041,46) */
  uint64_t __tmp_in_tmp37;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 64; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp37;
          }
          Arr4DIdxRowM(tmp37, 1, 1, 256, 64, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp37 : 0;
        }
      }
    }
  }

  uint64_t *tmp38 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp38
   * at (2044,1-2044,35) */
  uint64_t __tmp_in_tmp38;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp38;
    }
    Arr1DIdxRowM(tmp38, 64, i0) = (party == SERVER) ? __tmp_in_tmp38 : 0;
  }

  uint64_t *tmp39 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp39
   * at (2047,1-2047,35) */
  uint64_t __tmp_in_tmp39;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp39;
    }
    Arr1DIdxRowM(tmp39, 64, i0) = (party == SERVER) ? __tmp_in_tmp39 : 0;
  }

  uint64_t *tmp40 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp40
   * at (2050,1-2050,35) */
  uint64_t __tmp_in_tmp40;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp40;
    }
    Arr1DIdxRowM(tmp40, 64, i0) = (party == SERVER) ? __tmp_in_tmp40 : 0;
  }

  uint64_t *tmp41 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp41
   * at (2053,1-2053,35) */
  uint64_t __tmp_in_tmp41;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp41;
    }
    Arr1DIdxRowM(tmp41, 64, i0) = (party == SERVER) ? __tmp_in_tmp41 : 0;
  }

  uint64_t *tmp42 = make_array<uint64_t>(3, 3, 64, 64);
  /* Variable to read the clear value corresponding to the input variable tmp42
   * at (2056,1-2056,45) */
  uint64_t __tmp_in_tmp42;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 64; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 64; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp42;
          }
          Arr4DIdxRowM(tmp42, 3, 3, 64, 64, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp42 : 0;
        }
      }
    }
  }

  uint64_t *tmp43 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp43
   * at (2059,1-2059,35) */
  uint64_t __tmp_in_tmp43;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp43;
    }
    Arr1DIdxRowM(tmp43, 64, i0) = (party == SERVER) ? __tmp_in_tmp43 : 0;
  }

  uint64_t *tmp44 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp44
   * at (2062,1-2062,35) */
  uint64_t __tmp_in_tmp44;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp44;
    }
    Arr1DIdxRowM(tmp44, 64, i0) = (party == SERVER) ? __tmp_in_tmp44 : 0;
  }

  uint64_t *tmp45 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp45
   * at (2065,1-2065,35) */
  uint64_t __tmp_in_tmp45;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp45;
    }
    Arr1DIdxRowM(tmp45, 64, i0) = (party == SERVER) ? __tmp_in_tmp45 : 0;
  }

  uint64_t *tmp46 = make_array<uint64_t>(64);
  /* Variable to read the clear value corresponding to the input variable tmp46
   * at (2068,1-2068,35) */
  uint64_t __tmp_in_tmp46;
  for (uint64_t i0 = (uint64_t)0; i0 < 64; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp46;
    }
    Arr1DIdxRowM(tmp46, 64, i0) = (party == SERVER) ? __tmp_in_tmp46 : 0;
  }

  uint64_t *tmp47 = make_array<uint64_t>(1, 1, 64, 256);
  /* Variable to read the clear value corresponding to the input variable tmp47
   * at (2071,1-2071,46) */
  uint64_t __tmp_in_tmp47;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 64; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp47;
          }
          Arr4DIdxRowM(tmp47, 1, 1, 64, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp47 : 0;
        }
      }
    }
  }

  uint64_t *tmp48 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp48
   * at (2074,1-2074,36) */
  uint64_t __tmp_in_tmp48;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp48;
    }
    Arr1DIdxRowM(tmp48, 256, i0) = (party == SERVER) ? __tmp_in_tmp48 : 0;
  }

  uint64_t *tmp49 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp49
   * at (2077,1-2077,36) */
  uint64_t __tmp_in_tmp49;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp49;
    }
    Arr1DIdxRowM(tmp49, 256, i0) = (party == SERVER) ? __tmp_in_tmp49 : 0;
  }

  uint64_t *tmp50 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp50
   * at (2080,1-2080,36) */
  uint64_t __tmp_in_tmp50;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp50;
    }
    Arr1DIdxRowM(tmp50, 256, i0) = (party == SERVER) ? __tmp_in_tmp50 : 0;
  }

  uint64_t *tmp51 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp51
   * at (2083,1-2083,36) */
  uint64_t __tmp_in_tmp51;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp51;
    }
    Arr1DIdxRowM(tmp51, 256, i0) = (party == SERVER) ? __tmp_in_tmp51 : 0;
  }

  uint64_t *tmp52 = make_array<uint64_t>(1, 1, 256, 512);
  /* Variable to read the clear value corresponding to the input variable tmp52
   * at (2086,1-2086,47) */
  uint64_t __tmp_in_tmp52;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 512; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp52;
          }
          Arr4DIdxRowM(tmp52, 1, 1, 256, 512, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp52 : 0;
        }
      }
    }
  }

  uint64_t *tmp53 = make_array<uint64_t>(1, 1, 256, 128);
  /* Variable to read the clear value corresponding to the input variable tmp53
   * at (2089,1-2089,47) */
  uint64_t __tmp_in_tmp53;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 128; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp53;
          }
          Arr4DIdxRowM(tmp53, 1, 1, 256, 128, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp53 : 0;
        }
      }
    }
  }

  uint64_t *tmp54 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp54
   * at (2092,1-2092,36) */
  uint64_t __tmp_in_tmp54;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp54;
    }
    Arr1DIdxRowM(tmp54, 128, i0) = (party == SERVER) ? __tmp_in_tmp54 : 0;
  }

  uint64_t *tmp55 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp55
   * at (2095,1-2095,36) */
  uint64_t __tmp_in_tmp55;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp55;
    }
    Arr1DIdxRowM(tmp55, 128, i0) = (party == SERVER) ? __tmp_in_tmp55 : 0;
  }

  uint64_t *tmp56 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp56
   * at (2098,1-2098,36) */
  uint64_t __tmp_in_tmp56;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp56;
    }
    Arr1DIdxRowM(tmp56, 128, i0) = (party == SERVER) ? __tmp_in_tmp56 : 0;
  }

  uint64_t *tmp57 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp57
   * at (2101,1-2101,36) */
  uint64_t __tmp_in_tmp57;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp57;
    }
    Arr1DIdxRowM(tmp57, 128, i0) = (party == SERVER) ? __tmp_in_tmp57 : 0;
  }

  uint64_t *tmp58 = make_array<uint64_t>(3, 3, 128, 128);
  /* Variable to read the clear value corresponding to the input variable tmp58
   * at (2104,1-2104,47) */
  uint64_t __tmp_in_tmp58;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 128; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 128; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp58;
          }
          Arr4DIdxRowM(tmp58, 3, 3, 128, 128, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp58 : 0;
        }
      }
    }
  }

  uint64_t *tmp59 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp59
   * at (2107,1-2107,36) */
  uint64_t __tmp_in_tmp59;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp59;
    }
    Arr1DIdxRowM(tmp59, 128, i0) = (party == SERVER) ? __tmp_in_tmp59 : 0;
  }

  uint64_t *tmp60 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp60
   * at (2110,1-2110,36) */
  uint64_t __tmp_in_tmp60;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp60;
    }
    Arr1DIdxRowM(tmp60, 128, i0) = (party == SERVER) ? __tmp_in_tmp60 : 0;
  }

  uint64_t *tmp61 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp61
   * at (2113,1-2113,36) */
  uint64_t __tmp_in_tmp61;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp61;
    }
    Arr1DIdxRowM(tmp61, 128, i0) = (party == SERVER) ? __tmp_in_tmp61 : 0;
  }

  uint64_t *tmp62 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp62
   * at (2116,1-2116,36) */
  uint64_t __tmp_in_tmp62;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp62;
    }
    Arr1DIdxRowM(tmp62, 128, i0) = (party == SERVER) ? __tmp_in_tmp62 : 0;
  }

  uint64_t *tmp63 = make_array<uint64_t>(1, 1, 128, 512);
  /* Variable to read the clear value corresponding to the input variable tmp63
   * at (2119,1-2119,47) */
  uint64_t __tmp_in_tmp63;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 128; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 512; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp63;
          }
          Arr4DIdxRowM(tmp63, 1, 1, 128, 512, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp63 : 0;
        }
      }
    }
  }

  uint64_t *tmp64 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp64
   * at (2122,1-2122,36) */
  uint64_t __tmp_in_tmp64;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp64;
    }
    Arr1DIdxRowM(tmp64, 512, i0) = (party == SERVER) ? __tmp_in_tmp64 : 0;
  }

  uint64_t *tmp65 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp65
   * at (2125,1-2125,36) */
  uint64_t __tmp_in_tmp65;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp65;
    }
    Arr1DIdxRowM(tmp65, 512, i0) = (party == SERVER) ? __tmp_in_tmp65 : 0;
  }

  uint64_t *tmp66 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp66
   * at (2128,1-2128,36) */
  uint64_t __tmp_in_tmp66;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp66;
    }
    Arr1DIdxRowM(tmp66, 512, i0) = (party == SERVER) ? __tmp_in_tmp66 : 0;
  }

  uint64_t *tmp67 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp67
   * at (2131,1-2131,36) */
  uint64_t __tmp_in_tmp67;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp67;
    }
    Arr1DIdxRowM(tmp67, 512, i0) = (party == SERVER) ? __tmp_in_tmp67 : 0;
  }

  uint64_t *tmp68 = make_array<uint64_t>(1, 1, 512, 128);
  /* Variable to read the clear value corresponding to the input variable tmp68
   * at (2134,1-2134,47) */
  uint64_t __tmp_in_tmp68;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 512; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 128; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp68;
          }
          Arr4DIdxRowM(tmp68, 1, 1, 512, 128, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp68 : 0;
        }
      }
    }
  }

  uint64_t *tmp69 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp69
   * at (2137,1-2137,36) */
  uint64_t __tmp_in_tmp69;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp69;
    }
    Arr1DIdxRowM(tmp69, 128, i0) = (party == SERVER) ? __tmp_in_tmp69 : 0;
  }

  uint64_t *tmp70 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp70
   * at (2140,1-2140,36) */
  uint64_t __tmp_in_tmp70;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp70;
    }
    Arr1DIdxRowM(tmp70, 128, i0) = (party == SERVER) ? __tmp_in_tmp70 : 0;
  }

  uint64_t *tmp71 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp71
   * at (2143,1-2143,36) */
  uint64_t __tmp_in_tmp71;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp71;
    }
    Arr1DIdxRowM(tmp71, 128, i0) = (party == SERVER) ? __tmp_in_tmp71 : 0;
  }

  uint64_t *tmp72 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp72
   * at (2146,1-2146,36) */
  uint64_t __tmp_in_tmp72;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp72;
    }
    Arr1DIdxRowM(tmp72, 128, i0) = (party == SERVER) ? __tmp_in_tmp72 : 0;
  }

  uint64_t *tmp73 = make_array<uint64_t>(3, 3, 128, 128);
  /* Variable to read the clear value corresponding to the input variable tmp73
   * at (2149,1-2149,47) */
  uint64_t __tmp_in_tmp73;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 128; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 128; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp73;
          }
          Arr4DIdxRowM(tmp73, 3, 3, 128, 128, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp73 : 0;
        }
      }
    }
  }

  uint64_t *tmp74 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp74
   * at (2152,1-2152,36) */
  uint64_t __tmp_in_tmp74;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp74;
    }
    Arr1DIdxRowM(tmp74, 128, i0) = (party == SERVER) ? __tmp_in_tmp74 : 0;
  }

  uint64_t *tmp75 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp75
   * at (2155,1-2155,36) */
  uint64_t __tmp_in_tmp75;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp75;
    }
    Arr1DIdxRowM(tmp75, 128, i0) = (party == SERVER) ? __tmp_in_tmp75 : 0;
  }

  uint64_t *tmp76 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp76
   * at (2158,1-2158,36) */
  uint64_t __tmp_in_tmp76;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp76;
    }
    Arr1DIdxRowM(tmp76, 128, i0) = (party == SERVER) ? __tmp_in_tmp76 : 0;
  }

  uint64_t *tmp77 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp77
   * at (2161,1-2161,36) */
  uint64_t __tmp_in_tmp77;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp77;
    }
    Arr1DIdxRowM(tmp77, 128, i0) = (party == SERVER) ? __tmp_in_tmp77 : 0;
  }

  uint64_t *tmp78 = make_array<uint64_t>(1, 1, 128, 512);
  /* Variable to read the clear value corresponding to the input variable tmp78
   * at (2164,1-2164,47) */
  uint64_t __tmp_in_tmp78;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 128; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 512; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp78;
          }
          Arr4DIdxRowM(tmp78, 1, 1, 128, 512, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp78 : 0;
        }
      }
    }
  }

  uint64_t *tmp79 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp79
   * at (2167,1-2167,36) */
  uint64_t __tmp_in_tmp79;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp79;
    }
    Arr1DIdxRowM(tmp79, 512, i0) = (party == SERVER) ? __tmp_in_tmp79 : 0;
  }

  uint64_t *tmp80 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp80
   * at (2170,1-2170,36) */
  uint64_t __tmp_in_tmp80;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp80;
    }
    Arr1DIdxRowM(tmp80, 512, i0) = (party == SERVER) ? __tmp_in_tmp80 : 0;
  }

  uint64_t *tmp81 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp81
   * at (2173,1-2173,36) */
  uint64_t __tmp_in_tmp81;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp81;
    }
    Arr1DIdxRowM(tmp81, 512, i0) = (party == SERVER) ? __tmp_in_tmp81 : 0;
  }

  uint64_t *tmp82 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp82
   * at (2176,1-2176,36) */
  uint64_t __tmp_in_tmp82;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp82;
    }
    Arr1DIdxRowM(tmp82, 512, i0) = (party == SERVER) ? __tmp_in_tmp82 : 0;
  }

  uint64_t *tmp83 = make_array<uint64_t>(1, 1, 512, 128);
  /* Variable to read the clear value corresponding to the input variable tmp83
   * at (2179,1-2179,47) */
  uint64_t __tmp_in_tmp83;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 512; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 128; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp83;
          }
          Arr4DIdxRowM(tmp83, 1, 1, 512, 128, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp83 : 0;
        }
      }
    }
  }

  uint64_t *tmp84 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp84
   * at (2182,1-2182,36) */
  uint64_t __tmp_in_tmp84;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp84;
    }
    Arr1DIdxRowM(tmp84, 128, i0) = (party == SERVER) ? __tmp_in_tmp84 : 0;
  }

  uint64_t *tmp85 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp85
   * at (2185,1-2185,36) */
  uint64_t __tmp_in_tmp85;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp85;
    }
    Arr1DIdxRowM(tmp85, 128, i0) = (party == SERVER) ? __tmp_in_tmp85 : 0;
  }

  uint64_t *tmp86 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp86
   * at (2188,1-2188,36) */
  uint64_t __tmp_in_tmp86;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp86;
    }
    Arr1DIdxRowM(tmp86, 128, i0) = (party == SERVER) ? __tmp_in_tmp86 : 0;
  }

  uint64_t *tmp87 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp87
   * at (2191,1-2191,36) */
  uint64_t __tmp_in_tmp87;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp87;
    }
    Arr1DIdxRowM(tmp87, 128, i0) = (party == SERVER) ? __tmp_in_tmp87 : 0;
  }

  uint64_t *tmp88 = make_array<uint64_t>(3, 3, 128, 128);
  /* Variable to read the clear value corresponding to the input variable tmp88
   * at (2194,1-2194,47) */
  uint64_t __tmp_in_tmp88;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 128; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 128; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp88;
          }
          Arr4DIdxRowM(tmp88, 3, 3, 128, 128, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp88 : 0;
        }
      }
    }
  }

  uint64_t *tmp89 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp89
   * at (2197,1-2197,36) */
  uint64_t __tmp_in_tmp89;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp89;
    }
    Arr1DIdxRowM(tmp89, 128, i0) = (party == SERVER) ? __tmp_in_tmp89 : 0;
  }

  uint64_t *tmp90 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp90
   * at (2200,1-2200,36) */
  uint64_t __tmp_in_tmp90;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp90;
    }
    Arr1DIdxRowM(tmp90, 128, i0) = (party == SERVER) ? __tmp_in_tmp90 : 0;
  }

  uint64_t *tmp91 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp91
   * at (2203,1-2203,36) */
  uint64_t __tmp_in_tmp91;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp91;
    }
    Arr1DIdxRowM(tmp91, 128, i0) = (party == SERVER) ? __tmp_in_tmp91 : 0;
  }

  uint64_t *tmp92 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp92
   * at (2206,1-2206,36) */
  uint64_t __tmp_in_tmp92;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp92;
    }
    Arr1DIdxRowM(tmp92, 128, i0) = (party == SERVER) ? __tmp_in_tmp92 : 0;
  }

  uint64_t *tmp93 = make_array<uint64_t>(1, 1, 128, 512);
  /* Variable to read the clear value corresponding to the input variable tmp93
   * at (2209,1-2209,47) */
  uint64_t __tmp_in_tmp93;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 128; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 512; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp93;
          }
          Arr4DIdxRowM(tmp93, 1, 1, 128, 512, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp93 : 0;
        }
      }
    }
  }

  uint64_t *tmp94 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp94
   * at (2212,1-2212,36) */
  uint64_t __tmp_in_tmp94;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp94;
    }
    Arr1DIdxRowM(tmp94, 512, i0) = (party == SERVER) ? __tmp_in_tmp94 : 0;
  }

  uint64_t *tmp95 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp95
   * at (2215,1-2215,36) */
  uint64_t __tmp_in_tmp95;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp95;
    }
    Arr1DIdxRowM(tmp95, 512, i0) = (party == SERVER) ? __tmp_in_tmp95 : 0;
  }

  uint64_t *tmp96 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp96
   * at (2218,1-2218,36) */
  uint64_t __tmp_in_tmp96;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp96;
    }
    Arr1DIdxRowM(tmp96, 512, i0) = (party == SERVER) ? __tmp_in_tmp96 : 0;
  }

  uint64_t *tmp97 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp97
   * at (2221,1-2221,36) */
  uint64_t __tmp_in_tmp97;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp97;
    }
    Arr1DIdxRowM(tmp97, 512, i0) = (party == SERVER) ? __tmp_in_tmp97 : 0;
  }

  uint64_t *tmp98 = make_array<uint64_t>(1, 1, 512, 128);
  /* Variable to read the clear value corresponding to the input variable tmp98
   * at (2224,1-2224,47) */
  uint64_t __tmp_in_tmp98;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 512; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 128; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp98;
          }
          Arr4DIdxRowM(tmp98, 1, 1, 512, 128, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp98 : 0;
        }
      }
    }
  }

  uint64_t *tmp99 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp99
   * at (2227,1-2227,36) */
  uint64_t __tmp_in_tmp99;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp99;
    }
    Arr1DIdxRowM(tmp99, 128, i0) = (party == SERVER) ? __tmp_in_tmp99 : 0;
  }

  uint64_t *tmp100 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp100
   * at (2230,1-2230,37) */
  uint64_t __tmp_in_tmp100;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp100;
    }
    Arr1DIdxRowM(tmp100, 128, i0) = (party == SERVER) ? __tmp_in_tmp100 : 0;
  }

  uint64_t *tmp101 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp101
   * at (2233,1-2233,37) */
  uint64_t __tmp_in_tmp101;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp101;
    }
    Arr1DIdxRowM(tmp101, 128, i0) = (party == SERVER) ? __tmp_in_tmp101 : 0;
  }

  uint64_t *tmp102 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp102
   * at (2236,1-2236,37) */
  uint64_t __tmp_in_tmp102;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp102;
    }
    Arr1DIdxRowM(tmp102, 128, i0) = (party == SERVER) ? __tmp_in_tmp102 : 0;
  }

  uint64_t *tmp103 = make_array<uint64_t>(3, 3, 128, 128);
  /* Variable to read the clear value corresponding to the input variable tmp103
   * at (2239,1-2239,48) */
  uint64_t __tmp_in_tmp103;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 128; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 128; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp103;
          }
          Arr4DIdxRowM(tmp103, 3, 3, 128, 128, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp103 : 0;
        }
      }
    }
  }

  uint64_t *tmp104 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp104
   * at (2242,1-2242,37) */
  uint64_t __tmp_in_tmp104;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp104;
    }
    Arr1DIdxRowM(tmp104, 128, i0) = (party == SERVER) ? __tmp_in_tmp104 : 0;
  }

  uint64_t *tmp105 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp105
   * at (2245,1-2245,37) */
  uint64_t __tmp_in_tmp105;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp105;
    }
    Arr1DIdxRowM(tmp105, 128, i0) = (party == SERVER) ? __tmp_in_tmp105 : 0;
  }

  uint64_t *tmp106 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp106
   * at (2248,1-2248,37) */
  uint64_t __tmp_in_tmp106;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp106;
    }
    Arr1DIdxRowM(tmp106, 128, i0) = (party == SERVER) ? __tmp_in_tmp106 : 0;
  }

  uint64_t *tmp107 = make_array<uint64_t>(128);
  /* Variable to read the clear value corresponding to the input variable tmp107
   * at (2251,1-2251,37) */
  uint64_t __tmp_in_tmp107;
  for (uint64_t i0 = (uint64_t)0; i0 < 128; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp107;
    }
    Arr1DIdxRowM(tmp107, 128, i0) = (party == SERVER) ? __tmp_in_tmp107 : 0;
  }

  uint64_t *tmp108 = make_array<uint64_t>(1, 1, 128, 512);
  /* Variable to read the clear value corresponding to the input variable tmp108
   * at (2254,1-2254,48) */
  uint64_t __tmp_in_tmp108;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 128; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 512; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp108;
          }
          Arr4DIdxRowM(tmp108, 1, 1, 128, 512, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp108 : 0;
        }
      }
    }
  }

  uint64_t *tmp109 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp109
   * at (2257,1-2257,37) */
  uint64_t __tmp_in_tmp109;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp109;
    }
    Arr1DIdxRowM(tmp109, 512, i0) = (party == SERVER) ? __tmp_in_tmp109 : 0;
  }

  uint64_t *tmp110 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp110
   * at (2260,1-2260,37) */
  uint64_t __tmp_in_tmp110;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp110;
    }
    Arr1DIdxRowM(tmp110, 512, i0) = (party == SERVER) ? __tmp_in_tmp110 : 0;
  }

  uint64_t *tmp111 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp111
   * at (2263,1-2263,37) */
  uint64_t __tmp_in_tmp111;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp111;
    }
    Arr1DIdxRowM(tmp111, 512, i0) = (party == SERVER) ? __tmp_in_tmp111 : 0;
  }

  uint64_t *tmp112 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp112
   * at (2266,1-2266,37) */
  uint64_t __tmp_in_tmp112;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp112;
    }
    Arr1DIdxRowM(tmp112, 512, i0) = (party == SERVER) ? __tmp_in_tmp112 : 0;
  }

  uint64_t *tmp113 = make_array<uint64_t>(1, 1, 512, 1024);
  /* Variable to read the clear value corresponding to the input variable tmp113
   * at (2269,1-2269,49) */
  uint64_t __tmp_in_tmp113;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 512; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 1024; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp113;
          }
          Arr4DIdxRowM(tmp113, 1, 1, 512, 1024, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp113 : 0;
        }
      }
    }
  }

  uint64_t *tmp114 = make_array<uint64_t>(1, 1, 512, 256);
  /* Variable to read the clear value corresponding to the input variable tmp114
   * at (2272,1-2272,48) */
  uint64_t __tmp_in_tmp114;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 512; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp114;
          }
          Arr4DIdxRowM(tmp114, 1, 1, 512, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp114 : 0;
        }
      }
    }
  }

  uint64_t *tmp115 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp115
   * at (2275,1-2275,37) */
  uint64_t __tmp_in_tmp115;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp115;
    }
    Arr1DIdxRowM(tmp115, 256, i0) = (party == SERVER) ? __tmp_in_tmp115 : 0;
  }

  uint64_t *tmp116 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp116
   * at (2278,1-2278,37) */
  uint64_t __tmp_in_tmp116;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp116;
    }
    Arr1DIdxRowM(tmp116, 256, i0) = (party == SERVER) ? __tmp_in_tmp116 : 0;
  }

  uint64_t *tmp117 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp117
   * at (2281,1-2281,37) */
  uint64_t __tmp_in_tmp117;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp117;
    }
    Arr1DIdxRowM(tmp117, 256, i0) = (party == SERVER) ? __tmp_in_tmp117 : 0;
  }

  uint64_t *tmp118 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp118
   * at (2284,1-2284,37) */
  uint64_t __tmp_in_tmp118;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp118;
    }
    Arr1DIdxRowM(tmp118, 256, i0) = (party == SERVER) ? __tmp_in_tmp118 : 0;
  }

  uint64_t *tmp119 = make_array<uint64_t>(3, 3, 256, 256);
  /* Variable to read the clear value corresponding to the input variable tmp119
   * at (2287,1-2287,48) */
  uint64_t __tmp_in_tmp119;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp119;
          }
          Arr4DIdxRowM(tmp119, 3, 3, 256, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp119 : 0;
        }
      }
    }
  }

  uint64_t *tmp120 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp120
   * at (2290,1-2290,37) */
  uint64_t __tmp_in_tmp120;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp120;
    }
    Arr1DIdxRowM(tmp120, 256, i0) = (party == SERVER) ? __tmp_in_tmp120 : 0;
  }

  uint64_t *tmp121 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp121
   * at (2293,1-2293,37) */
  uint64_t __tmp_in_tmp121;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp121;
    }
    Arr1DIdxRowM(tmp121, 256, i0) = (party == SERVER) ? __tmp_in_tmp121 : 0;
  }

  uint64_t *tmp122 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp122
   * at (2296,1-2296,37) */
  uint64_t __tmp_in_tmp122;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp122;
    }
    Arr1DIdxRowM(tmp122, 256, i0) = (party == SERVER) ? __tmp_in_tmp122 : 0;
  }

  uint64_t *tmp123 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp123
   * at (2299,1-2299,37) */
  uint64_t __tmp_in_tmp123;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp123;
    }
    Arr1DIdxRowM(tmp123, 256, i0) = (party == SERVER) ? __tmp_in_tmp123 : 0;
  }

  uint64_t *tmp124 = make_array<uint64_t>(1, 1, 256, 1024);
  /* Variable to read the clear value corresponding to the input variable tmp124
   * at (2302,1-2302,49) */
  uint64_t __tmp_in_tmp124;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 1024; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp124;
          }
          Arr4DIdxRowM(tmp124, 1, 1, 256, 1024, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp124 : 0;
        }
      }
    }
  }

  uint64_t *tmp125 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp125
   * at (2305,1-2305,38) */
  uint64_t __tmp_in_tmp125;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp125;
    }
    Arr1DIdxRowM(tmp125, 1024, i0) = (party == SERVER) ? __tmp_in_tmp125 : 0;
  }

  uint64_t *tmp126 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp126
   * at (2308,1-2308,38) */
  uint64_t __tmp_in_tmp126;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp126;
    }
    Arr1DIdxRowM(tmp126, 1024, i0) = (party == SERVER) ? __tmp_in_tmp126 : 0;
  }

  uint64_t *tmp127 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp127
   * at (2311,1-2311,38) */
  uint64_t __tmp_in_tmp127;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp127;
    }
    Arr1DIdxRowM(tmp127, 1024, i0) = (party == SERVER) ? __tmp_in_tmp127 : 0;
  }

  uint64_t *tmp128 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp128
   * at (2314,1-2314,38) */
  uint64_t __tmp_in_tmp128;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp128;
    }
    Arr1DIdxRowM(tmp128, 1024, i0) = (party == SERVER) ? __tmp_in_tmp128 : 0;
  }

  uint64_t *tmp129 = make_array<uint64_t>(1, 1, 1024, 256);
  /* Variable to read the clear value corresponding to the input variable tmp129
   * at (2317,1-2317,49) */
  uint64_t __tmp_in_tmp129;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 1024; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp129;
          }
          Arr4DIdxRowM(tmp129, 1, 1, 1024, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp129 : 0;
        }
      }
    }
  }

  uint64_t *tmp130 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp130
   * at (2320,1-2320,37) */
  uint64_t __tmp_in_tmp130;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp130;
    }
    Arr1DIdxRowM(tmp130, 256, i0) = (party == SERVER) ? __tmp_in_tmp130 : 0;
  }

  uint64_t *tmp131 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp131
   * at (2323,1-2323,37) */
  uint64_t __tmp_in_tmp131;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp131;
    }
    Arr1DIdxRowM(tmp131, 256, i0) = (party == SERVER) ? __tmp_in_tmp131 : 0;
  }

  uint64_t *tmp132 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp132
   * at (2326,1-2326,37) */
  uint64_t __tmp_in_tmp132;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp132;
    }
    Arr1DIdxRowM(tmp132, 256, i0) = (party == SERVER) ? __tmp_in_tmp132 : 0;
  }

  uint64_t *tmp133 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp133
   * at (2329,1-2329,37) */
  uint64_t __tmp_in_tmp133;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp133;
    }
    Arr1DIdxRowM(tmp133, 256, i0) = (party == SERVER) ? __tmp_in_tmp133 : 0;
  }

  uint64_t *tmp134 = make_array<uint64_t>(3, 3, 256, 256);
  /* Variable to read the clear value corresponding to the input variable tmp134
   * at (2332,1-2332,48) */
  uint64_t __tmp_in_tmp134;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp134;
          }
          Arr4DIdxRowM(tmp134, 3, 3, 256, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp134 : 0;
        }
      }
    }
  }

  uint64_t *tmp135 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp135
   * at (2335,1-2335,37) */
  uint64_t __tmp_in_tmp135;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp135;
    }
    Arr1DIdxRowM(tmp135, 256, i0) = (party == SERVER) ? __tmp_in_tmp135 : 0;
  }

  uint64_t *tmp136 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp136
   * at (2338,1-2338,37) */
  uint64_t __tmp_in_tmp136;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp136;
    }
    Arr1DIdxRowM(tmp136, 256, i0) = (party == SERVER) ? __tmp_in_tmp136 : 0;
  }

  uint64_t *tmp137 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp137
   * at (2341,1-2341,37) */
  uint64_t __tmp_in_tmp137;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp137;
    }
    Arr1DIdxRowM(tmp137, 256, i0) = (party == SERVER) ? __tmp_in_tmp137 : 0;
  }

  uint64_t *tmp138 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp138
   * at (2344,1-2344,37) */
  uint64_t __tmp_in_tmp138;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp138;
    }
    Arr1DIdxRowM(tmp138, 256, i0) = (party == SERVER) ? __tmp_in_tmp138 : 0;
  }

  uint64_t *tmp139 = make_array<uint64_t>(1, 1, 256, 1024);
  /* Variable to read the clear value corresponding to the input variable tmp139
   * at (2347,1-2347,49) */
  uint64_t __tmp_in_tmp139;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 1024; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp139;
          }
          Arr4DIdxRowM(tmp139, 1, 1, 256, 1024, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp139 : 0;
        }
      }
    }
  }

  uint64_t *tmp140 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp140
   * at (2350,1-2350,38) */
  uint64_t __tmp_in_tmp140;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp140;
    }
    Arr1DIdxRowM(tmp140, 1024, i0) = (party == SERVER) ? __tmp_in_tmp140 : 0;
  }

  uint64_t *tmp141 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp141
   * at (2353,1-2353,38) */
  uint64_t __tmp_in_tmp141;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp141;
    }
    Arr1DIdxRowM(tmp141, 1024, i0) = (party == SERVER) ? __tmp_in_tmp141 : 0;
  }

  uint64_t *tmp142 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp142
   * at (2356,1-2356,38) */
  uint64_t __tmp_in_tmp142;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp142;
    }
    Arr1DIdxRowM(tmp142, 1024, i0) = (party == SERVER) ? __tmp_in_tmp142 : 0;
  }

  uint64_t *tmp143 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp143
   * at (2359,1-2359,38) */
  uint64_t __tmp_in_tmp143;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp143;
    }
    Arr1DIdxRowM(tmp143, 1024, i0) = (party == SERVER) ? __tmp_in_tmp143 : 0;
  }

  uint64_t *tmp144 = make_array<uint64_t>(1, 1, 1024, 256);
  /* Variable to read the clear value corresponding to the input variable tmp144
   * at (2362,1-2362,49) */
  uint64_t __tmp_in_tmp144;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 1024; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp144;
          }
          Arr4DIdxRowM(tmp144, 1, 1, 1024, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp144 : 0;
        }
      }
    }
  }

  uint64_t *tmp145 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp145
   * at (2365,1-2365,37) */
  uint64_t __tmp_in_tmp145;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp145;
    }
    Arr1DIdxRowM(tmp145, 256, i0) = (party == SERVER) ? __tmp_in_tmp145 : 0;
  }

  uint64_t *tmp146 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp146
   * at (2368,1-2368,37) */
  uint64_t __tmp_in_tmp146;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp146;
    }
    Arr1DIdxRowM(tmp146, 256, i0) = (party == SERVER) ? __tmp_in_tmp146 : 0;
  }

  uint64_t *tmp147 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp147
   * at (2371,1-2371,37) */
  uint64_t __tmp_in_tmp147;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp147;
    }
    Arr1DIdxRowM(tmp147, 256, i0) = (party == SERVER) ? __tmp_in_tmp147 : 0;
  }

  uint64_t *tmp148 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp148
   * at (2374,1-2374,37) */
  uint64_t __tmp_in_tmp148;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp148;
    }
    Arr1DIdxRowM(tmp148, 256, i0) = (party == SERVER) ? __tmp_in_tmp148 : 0;
  }

  uint64_t *tmp149 = make_array<uint64_t>(3, 3, 256, 256);
  /* Variable to read the clear value corresponding to the input variable tmp149
   * at (2377,1-2377,48) */
  uint64_t __tmp_in_tmp149;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp149;
          }
          Arr4DIdxRowM(tmp149, 3, 3, 256, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp149 : 0;
        }
      }
    }
  }

  uint64_t *tmp150 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp150
   * at (2380,1-2380,37) */
  uint64_t __tmp_in_tmp150;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp150;
    }
    Arr1DIdxRowM(tmp150, 256, i0) = (party == SERVER) ? __tmp_in_tmp150 : 0;
  }

  uint64_t *tmp151 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp151
   * at (2383,1-2383,37) */
  uint64_t __tmp_in_tmp151;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp151;
    }
    Arr1DIdxRowM(tmp151, 256, i0) = (party == SERVER) ? __tmp_in_tmp151 : 0;
  }

  uint64_t *tmp152 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp152
   * at (2386,1-2386,37) */
  uint64_t __tmp_in_tmp152;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp152;
    }
    Arr1DIdxRowM(tmp152, 256, i0) = (party == SERVER) ? __tmp_in_tmp152 : 0;
  }

  uint64_t *tmp153 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp153
   * at (2389,1-2389,37) */
  uint64_t __tmp_in_tmp153;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp153;
    }
    Arr1DIdxRowM(tmp153, 256, i0) = (party == SERVER) ? __tmp_in_tmp153 : 0;
  }

  uint64_t *tmp154 = make_array<uint64_t>(1, 1, 256, 1024);
  /* Variable to read the clear value corresponding to the input variable tmp154
   * at (2392,1-2392,49) */
  uint64_t __tmp_in_tmp154;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 1024; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp154;
          }
          Arr4DIdxRowM(tmp154, 1, 1, 256, 1024, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp154 : 0;
        }
      }
    }
  }

  uint64_t *tmp155 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp155
   * at (2395,1-2395,38) */
  uint64_t __tmp_in_tmp155;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp155;
    }
    Arr1DIdxRowM(tmp155, 1024, i0) = (party == SERVER) ? __tmp_in_tmp155 : 0;
  }

  uint64_t *tmp156 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp156
   * at (2398,1-2398,38) */
  uint64_t __tmp_in_tmp156;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp156;
    }
    Arr1DIdxRowM(tmp156, 1024, i0) = (party == SERVER) ? __tmp_in_tmp156 : 0;
  }

  uint64_t *tmp157 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp157
   * at (2401,1-2401,38) */
  uint64_t __tmp_in_tmp157;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp157;
    }
    Arr1DIdxRowM(tmp157, 1024, i0) = (party == SERVER) ? __tmp_in_tmp157 : 0;
  }

  uint64_t *tmp158 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp158
   * at (2404,1-2404,38) */
  uint64_t __tmp_in_tmp158;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp158;
    }
    Arr1DIdxRowM(tmp158, 1024, i0) = (party == SERVER) ? __tmp_in_tmp158 : 0;
  }

  uint64_t *tmp159 = make_array<uint64_t>(1, 1, 1024, 256);
  /* Variable to read the clear value corresponding to the input variable tmp159
   * at (2407,1-2407,49) */
  uint64_t __tmp_in_tmp159;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 1024; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp159;
          }
          Arr4DIdxRowM(tmp159, 1, 1, 1024, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp159 : 0;
        }
      }
    }
  }

  uint64_t *tmp160 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp160
   * at (2410,1-2410,37) */
  uint64_t __tmp_in_tmp160;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp160;
    }
    Arr1DIdxRowM(tmp160, 256, i0) = (party == SERVER) ? __tmp_in_tmp160 : 0;
  }

  uint64_t *tmp161 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp161
   * at (2413,1-2413,37) */
  uint64_t __tmp_in_tmp161;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp161;
    }
    Arr1DIdxRowM(tmp161, 256, i0) = (party == SERVER) ? __tmp_in_tmp161 : 0;
  }

  uint64_t *tmp162 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp162
   * at (2416,1-2416,37) */
  uint64_t __tmp_in_tmp162;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp162;
    }
    Arr1DIdxRowM(tmp162, 256, i0) = (party == SERVER) ? __tmp_in_tmp162 : 0;
  }

  uint64_t *tmp163 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp163
   * at (2419,1-2419,37) */
  uint64_t __tmp_in_tmp163;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp163;
    }
    Arr1DIdxRowM(tmp163, 256, i0) = (party == SERVER) ? __tmp_in_tmp163 : 0;
  }

  uint64_t *tmp164 = make_array<uint64_t>(3, 3, 256, 256);
  /* Variable to read the clear value corresponding to the input variable tmp164
   * at (2422,1-2422,48) */
  uint64_t __tmp_in_tmp164;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp164;
          }
          Arr4DIdxRowM(tmp164, 3, 3, 256, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp164 : 0;
        }
      }
    }
  }

  uint64_t *tmp165 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp165
   * at (2425,1-2425,37) */
  uint64_t __tmp_in_tmp165;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp165;
    }
    Arr1DIdxRowM(tmp165, 256, i0) = (party == SERVER) ? __tmp_in_tmp165 : 0;
  }

  uint64_t *tmp166 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp166
   * at (2428,1-2428,37) */
  uint64_t __tmp_in_tmp166;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp166;
    }
    Arr1DIdxRowM(tmp166, 256, i0) = (party == SERVER) ? __tmp_in_tmp166 : 0;
  }

  uint64_t *tmp167 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp167
   * at (2431,1-2431,37) */
  uint64_t __tmp_in_tmp167;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp167;
    }
    Arr1DIdxRowM(tmp167, 256, i0) = (party == SERVER) ? __tmp_in_tmp167 : 0;
  }

  uint64_t *tmp168 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp168
   * at (2434,1-2434,37) */
  uint64_t __tmp_in_tmp168;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp168;
    }
    Arr1DIdxRowM(tmp168, 256, i0) = (party == SERVER) ? __tmp_in_tmp168 : 0;
  }

  uint64_t *tmp169 = make_array<uint64_t>(1, 1, 256, 1024);
  /* Variable to read the clear value corresponding to the input variable tmp169
   * at (2437,1-2437,49) */
  uint64_t __tmp_in_tmp169;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 1024; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp169;
          }
          Arr4DIdxRowM(tmp169, 1, 1, 256, 1024, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp169 : 0;
        }
      }
    }
  }

  uint64_t *tmp170 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp170
   * at (2440,1-2440,38) */
  uint64_t __tmp_in_tmp170;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp170;
    }
    Arr1DIdxRowM(tmp170, 1024, i0) = (party == SERVER) ? __tmp_in_tmp170 : 0;
  }

  uint64_t *tmp171 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp171
   * at (2443,1-2443,38) */
  uint64_t __tmp_in_tmp171;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp171;
    }
    Arr1DIdxRowM(tmp171, 1024, i0) = (party == SERVER) ? __tmp_in_tmp171 : 0;
  }

  uint64_t *tmp172 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp172
   * at (2446,1-2446,38) */
  uint64_t __tmp_in_tmp172;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp172;
    }
    Arr1DIdxRowM(tmp172, 1024, i0) = (party == SERVER) ? __tmp_in_tmp172 : 0;
  }

  uint64_t *tmp173 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp173
   * at (2449,1-2449,38) */
  uint64_t __tmp_in_tmp173;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp173;
    }
    Arr1DIdxRowM(tmp173, 1024, i0) = (party == SERVER) ? __tmp_in_tmp173 : 0;
  }

  uint64_t *tmp174 = make_array<uint64_t>(1, 1, 1024, 256);
  /* Variable to read the clear value corresponding to the input variable tmp174
   * at (2452,1-2452,49) */
  uint64_t __tmp_in_tmp174;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 1024; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp174;
          }
          Arr4DIdxRowM(tmp174, 1, 1, 1024, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp174 : 0;
        }
      }
    }
  }

  uint64_t *tmp175 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp175
   * at (2455,1-2455,37) */
  uint64_t __tmp_in_tmp175;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp175;
    }
    Arr1DIdxRowM(tmp175, 256, i0) = (party == SERVER) ? __tmp_in_tmp175 : 0;
  }

  uint64_t *tmp176 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp176
   * at (2458,1-2458,37) */
  uint64_t __tmp_in_tmp176;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp176;
    }
    Arr1DIdxRowM(tmp176, 256, i0) = (party == SERVER) ? __tmp_in_tmp176 : 0;
  }

  uint64_t *tmp177 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp177
   * at (2461,1-2461,37) */
  uint64_t __tmp_in_tmp177;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp177;
    }
    Arr1DIdxRowM(tmp177, 256, i0) = (party == SERVER) ? __tmp_in_tmp177 : 0;
  }

  uint64_t *tmp178 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp178
   * at (2464,1-2464,37) */
  uint64_t __tmp_in_tmp178;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp178;
    }
    Arr1DIdxRowM(tmp178, 256, i0) = (party == SERVER) ? __tmp_in_tmp178 : 0;
  }

  uint64_t *tmp179 = make_array<uint64_t>(3, 3, 256, 256);
  /* Variable to read the clear value corresponding to the input variable tmp179
   * at (2467,1-2467,48) */
  uint64_t __tmp_in_tmp179;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp179;
          }
          Arr4DIdxRowM(tmp179, 3, 3, 256, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp179 : 0;
        }
      }
    }
  }

  uint64_t *tmp180 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp180
   * at (2470,1-2470,37) */
  uint64_t __tmp_in_tmp180;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp180;
    }
    Arr1DIdxRowM(tmp180, 256, i0) = (party == SERVER) ? __tmp_in_tmp180 : 0;
  }

  uint64_t *tmp181 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp181
   * at (2473,1-2473,37) */
  uint64_t __tmp_in_tmp181;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp181;
    }
    Arr1DIdxRowM(tmp181, 256, i0) = (party == SERVER) ? __tmp_in_tmp181 : 0;
  }

  uint64_t *tmp182 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp182
   * at (2476,1-2476,37) */
  uint64_t __tmp_in_tmp182;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp182;
    }
    Arr1DIdxRowM(tmp182, 256, i0) = (party == SERVER) ? __tmp_in_tmp182 : 0;
  }

  uint64_t *tmp183 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp183
   * at (2479,1-2479,37) */
  uint64_t __tmp_in_tmp183;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp183;
    }
    Arr1DIdxRowM(tmp183, 256, i0) = (party == SERVER) ? __tmp_in_tmp183 : 0;
  }

  uint64_t *tmp184 = make_array<uint64_t>(1, 1, 256, 1024);
  /* Variable to read the clear value corresponding to the input variable tmp184
   * at (2482,1-2482,49) */
  uint64_t __tmp_in_tmp184;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 1024; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp184;
          }
          Arr4DIdxRowM(tmp184, 1, 1, 256, 1024, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp184 : 0;
        }
      }
    }
  }

  uint64_t *tmp185 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp185
   * at (2485,1-2485,38) */
  uint64_t __tmp_in_tmp185;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp185;
    }
    Arr1DIdxRowM(tmp185, 1024, i0) = (party == SERVER) ? __tmp_in_tmp185 : 0;
  }

  uint64_t *tmp186 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp186
   * at (2488,1-2488,38) */
  uint64_t __tmp_in_tmp186;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp186;
    }
    Arr1DIdxRowM(tmp186, 1024, i0) = (party == SERVER) ? __tmp_in_tmp186 : 0;
  }

  uint64_t *tmp187 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp187
   * at (2491,1-2491,38) */
  uint64_t __tmp_in_tmp187;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp187;
    }
    Arr1DIdxRowM(tmp187, 1024, i0) = (party == SERVER) ? __tmp_in_tmp187 : 0;
  }

  uint64_t *tmp188 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp188
   * at (2494,1-2494,38) */
  uint64_t __tmp_in_tmp188;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp188;
    }
    Arr1DIdxRowM(tmp188, 1024, i0) = (party == SERVER) ? __tmp_in_tmp188 : 0;
  }

  uint64_t *tmp189 = make_array<uint64_t>(1, 1, 1024, 256);
  /* Variable to read the clear value corresponding to the input variable tmp189
   * at (2497,1-2497,49) */
  uint64_t __tmp_in_tmp189;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 1024; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp189;
          }
          Arr4DIdxRowM(tmp189, 1, 1, 1024, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp189 : 0;
        }
      }
    }
  }

  uint64_t *tmp190 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp190
   * at (2500,1-2500,37) */
  uint64_t __tmp_in_tmp190;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp190;
    }
    Arr1DIdxRowM(tmp190, 256, i0) = (party == SERVER) ? __tmp_in_tmp190 : 0;
  }

  uint64_t *tmp191 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp191
   * at (2503,1-2503,37) */
  uint64_t __tmp_in_tmp191;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp191;
    }
    Arr1DIdxRowM(tmp191, 256, i0) = (party == SERVER) ? __tmp_in_tmp191 : 0;
  }

  uint64_t *tmp192 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp192
   * at (2506,1-2506,37) */
  uint64_t __tmp_in_tmp192;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp192;
    }
    Arr1DIdxRowM(tmp192, 256, i0) = (party == SERVER) ? __tmp_in_tmp192 : 0;
  }

  uint64_t *tmp193 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp193
   * at (2509,1-2509,37) */
  uint64_t __tmp_in_tmp193;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp193;
    }
    Arr1DIdxRowM(tmp193, 256, i0) = (party == SERVER) ? __tmp_in_tmp193 : 0;
  }

  uint64_t *tmp194 = make_array<uint64_t>(3, 3, 256, 256);
  /* Variable to read the clear value corresponding to the input variable tmp194
   * at (2512,1-2512,48) */
  uint64_t __tmp_in_tmp194;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 256; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp194;
          }
          Arr4DIdxRowM(tmp194, 3, 3, 256, 256, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp194 : 0;
        }
      }
    }
  }

  uint64_t *tmp195 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp195
   * at (2515,1-2515,37) */
  uint64_t __tmp_in_tmp195;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp195;
    }
    Arr1DIdxRowM(tmp195, 256, i0) = (party == SERVER) ? __tmp_in_tmp195 : 0;
  }

  uint64_t *tmp196 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp196
   * at (2518,1-2518,37) */
  uint64_t __tmp_in_tmp196;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp196;
    }
    Arr1DIdxRowM(tmp196, 256, i0) = (party == SERVER) ? __tmp_in_tmp196 : 0;
  }

  uint64_t *tmp197 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp197
   * at (2521,1-2521,37) */
  uint64_t __tmp_in_tmp197;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp197;
    }
    Arr1DIdxRowM(tmp197, 256, i0) = (party == SERVER) ? __tmp_in_tmp197 : 0;
  }

  uint64_t *tmp198 = make_array<uint64_t>(256);
  /* Variable to read the clear value corresponding to the input variable tmp198
   * at (2524,1-2524,37) */
  uint64_t __tmp_in_tmp198;
  for (uint64_t i0 = (uint64_t)0; i0 < 256; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp198;
    }
    Arr1DIdxRowM(tmp198, 256, i0) = (party == SERVER) ? __tmp_in_tmp198 : 0;
  }

  uint64_t *tmp199 = make_array<uint64_t>(1, 1, 256, 1024);
  /* Variable to read the clear value corresponding to the input variable tmp199
   * at (2527,1-2527,49) */
  uint64_t __tmp_in_tmp199;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 256; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 1024; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp199;
          }
          Arr4DIdxRowM(tmp199, 1, 1, 256, 1024, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp199 : 0;
        }
      }
    }
  }

  uint64_t *tmp200 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp200
   * at (2530,1-2530,38) */
  uint64_t __tmp_in_tmp200;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp200;
    }
    Arr1DIdxRowM(tmp200, 1024, i0) = (party == SERVER) ? __tmp_in_tmp200 : 0;
  }

  uint64_t *tmp201 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp201
   * at (2533,1-2533,38) */
  uint64_t __tmp_in_tmp201;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp201;
    }
    Arr1DIdxRowM(tmp201, 1024, i0) = (party == SERVER) ? __tmp_in_tmp201 : 0;
  }

  uint64_t *tmp202 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp202
   * at (2536,1-2536,38) */
  uint64_t __tmp_in_tmp202;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp202;
    }
    Arr1DIdxRowM(tmp202, 1024, i0) = (party == SERVER) ? __tmp_in_tmp202 : 0;
  }

  uint64_t *tmp203 = make_array<uint64_t>(1024);
  /* Variable to read the clear value corresponding to the input variable tmp203
   * at (2539,1-2539,38) */
  uint64_t __tmp_in_tmp203;
  for (uint64_t i0 = (uint64_t)0; i0 < 1024; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp203;
    }
    Arr1DIdxRowM(tmp203, 1024, i0) = (party == SERVER) ? __tmp_in_tmp203 : 0;
  }

  uint64_t *tmp204 = make_array<uint64_t>(1, 1, 1024, 2048);
  /* Variable to read the clear value corresponding to the input variable tmp204
   * at (2542,1-2542,50) */
  uint64_t __tmp_in_tmp204;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 1024; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 2048; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp204;
          }
          Arr4DIdxRowM(tmp204, 1, 1, 1024, 2048, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp204 : 0;
        }
      }
    }
  }

  uint64_t *tmp205 = make_array<uint64_t>(1, 1, 1024, 512);
  /* Variable to read the clear value corresponding to the input variable tmp205
   * at (2545,1-2545,49) */
  uint64_t __tmp_in_tmp205;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 1024; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 512; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp205;
          }
          Arr4DIdxRowM(tmp205, 1, 1, 1024, 512, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp205 : 0;
        }
      }
    }
  }

  uint64_t *tmp206 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp206
   * at (2548,1-2548,37) */
  uint64_t __tmp_in_tmp206;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp206;
    }
    Arr1DIdxRowM(tmp206, 512, i0) = (party == SERVER) ? __tmp_in_tmp206 : 0;
  }

  uint64_t *tmp207 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp207
   * at (2551,1-2551,37) */
  uint64_t __tmp_in_tmp207;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp207;
    }
    Arr1DIdxRowM(tmp207, 512, i0) = (party == SERVER) ? __tmp_in_tmp207 : 0;
  }

  uint64_t *tmp208 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp208
   * at (2554,1-2554,37) */
  uint64_t __tmp_in_tmp208;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp208;
    }
    Arr1DIdxRowM(tmp208, 512, i0) = (party == SERVER) ? __tmp_in_tmp208 : 0;
  }

  uint64_t *tmp209 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp209
   * at (2557,1-2557,37) */
  uint64_t __tmp_in_tmp209;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp209;
    }
    Arr1DIdxRowM(tmp209, 512, i0) = (party == SERVER) ? __tmp_in_tmp209 : 0;
  }

  uint64_t *tmp210 = make_array<uint64_t>(3, 3, 512, 512);
  /* Variable to read the clear value corresponding to the input variable tmp210
   * at (2560,1-2560,48) */
  uint64_t __tmp_in_tmp210;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 512; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 512; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp210;
          }
          Arr4DIdxRowM(tmp210, 3, 3, 512, 512, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp210 : 0;
        }
      }
    }
  }

  uint64_t *tmp211 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp211
   * at (2563,1-2563,37) */
  uint64_t __tmp_in_tmp211;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp211;
    }
    Arr1DIdxRowM(tmp211, 512, i0) = (party == SERVER) ? __tmp_in_tmp211 : 0;
  }

  uint64_t *tmp212 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp212
   * at (2566,1-2566,37) */
  uint64_t __tmp_in_tmp212;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp212;
    }
    Arr1DIdxRowM(tmp212, 512, i0) = (party == SERVER) ? __tmp_in_tmp212 : 0;
  }

  uint64_t *tmp213 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp213
   * at (2569,1-2569,37) */
  uint64_t __tmp_in_tmp213;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp213;
    }
    Arr1DIdxRowM(tmp213, 512, i0) = (party == SERVER) ? __tmp_in_tmp213 : 0;
  }

  uint64_t *tmp214 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp214
   * at (2572,1-2572,37) */
  uint64_t __tmp_in_tmp214;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp214;
    }
    Arr1DIdxRowM(tmp214, 512, i0) = (party == SERVER) ? __tmp_in_tmp214 : 0;
  }

  uint64_t *tmp215 = make_array<uint64_t>(1, 1, 512, 2048);
  /* Variable to read the clear value corresponding to the input variable tmp215
   * at (2575,1-2575,49) */
  uint64_t __tmp_in_tmp215;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 512; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 2048; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp215;
          }
          Arr4DIdxRowM(tmp215, 1, 1, 512, 2048, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp215 : 0;
        }
      }
    }
  }

  uint64_t *tmp216 = make_array<uint64_t>(2048);
  /* Variable to read the clear value corresponding to the input variable tmp216
   * at (2578,1-2578,38) */
  uint64_t __tmp_in_tmp216;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp216;
    }
    Arr1DIdxRowM(tmp216, 2048, i0) = (party == SERVER) ? __tmp_in_tmp216 : 0;
  }

  uint64_t *tmp217 = make_array<uint64_t>(2048);
  /* Variable to read the clear value corresponding to the input variable tmp217
   * at (2581,1-2581,38) */
  uint64_t __tmp_in_tmp217;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp217;
    }
    Arr1DIdxRowM(tmp217, 2048, i0) = (party == SERVER) ? __tmp_in_tmp217 : 0;
  }

  uint64_t *tmp218 = make_array<uint64_t>(2048);
  /* Variable to read the clear value corresponding to the input variable tmp218
   * at (2584,1-2584,38) */
  uint64_t __tmp_in_tmp218;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp218;
    }
    Arr1DIdxRowM(tmp218, 2048, i0) = (party == SERVER) ? __tmp_in_tmp218 : 0;
  }

  uint64_t *tmp219 = make_array<uint64_t>(2048);
  /* Variable to read the clear value corresponding to the input variable tmp219
   * at (2587,1-2587,38) */
  uint64_t __tmp_in_tmp219;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp219;
    }
    Arr1DIdxRowM(tmp219, 2048, i0) = (party == SERVER) ? __tmp_in_tmp219 : 0;
  }

  uint64_t *tmp220 = make_array<uint64_t>(1, 1, 2048, 512);
  /* Variable to read the clear value corresponding to the input variable tmp220
   * at (2590,1-2590,49) */
  uint64_t __tmp_in_tmp220;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 2048; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 512; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp220;
          }
          Arr4DIdxRowM(tmp220, 1, 1, 2048, 512, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp220 : 0;
        }
      }
    }
  }

  uint64_t *tmp221 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp221
   * at (2593,1-2593,37) */
  uint64_t __tmp_in_tmp221;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp221;
    }
    Arr1DIdxRowM(tmp221, 512, i0) = (party == SERVER) ? __tmp_in_tmp221 : 0;
  }

  uint64_t *tmp222 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp222
   * at (2596,1-2596,37) */
  uint64_t __tmp_in_tmp222;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp222;
    }
    Arr1DIdxRowM(tmp222, 512, i0) = (party == SERVER) ? __tmp_in_tmp222 : 0;
  }

  uint64_t *tmp223 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp223
   * at (2599,1-2599,37) */
  uint64_t __tmp_in_tmp223;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp223;
    }
    Arr1DIdxRowM(tmp223, 512, i0) = (party == SERVER) ? __tmp_in_tmp223 : 0;
  }

  uint64_t *tmp224 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp224
   * at (2602,1-2602,37) */
  uint64_t __tmp_in_tmp224;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp224;
    }
    Arr1DIdxRowM(tmp224, 512, i0) = (party == SERVER) ? __tmp_in_tmp224 : 0;
  }

  uint64_t *tmp225 = make_array<uint64_t>(3, 3, 512, 512);
  /* Variable to read the clear value corresponding to the input variable tmp225
   * at (2605,1-2605,48) */
  uint64_t __tmp_in_tmp225;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 512; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 512; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp225;
          }
          Arr4DIdxRowM(tmp225, 3, 3, 512, 512, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp225 : 0;
        }
      }
    }
  }

  uint64_t *tmp226 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp226
   * at (2608,1-2608,37) */
  uint64_t __tmp_in_tmp226;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp226;
    }
    Arr1DIdxRowM(tmp226, 512, i0) = (party == SERVER) ? __tmp_in_tmp226 : 0;
  }

  uint64_t *tmp227 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp227
   * at (2611,1-2611,37) */
  uint64_t __tmp_in_tmp227;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp227;
    }
    Arr1DIdxRowM(tmp227, 512, i0) = (party == SERVER) ? __tmp_in_tmp227 : 0;
  }

  uint64_t *tmp228 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp228
   * at (2614,1-2614,37) */
  uint64_t __tmp_in_tmp228;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp228;
    }
    Arr1DIdxRowM(tmp228, 512, i0) = (party == SERVER) ? __tmp_in_tmp228 : 0;
  }

  uint64_t *tmp229 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp229
   * at (2617,1-2617,37) */
  uint64_t __tmp_in_tmp229;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp229;
    }
    Arr1DIdxRowM(tmp229, 512, i0) = (party == SERVER) ? __tmp_in_tmp229 : 0;
  }

  uint64_t *tmp230 = make_array<uint64_t>(1, 1, 512, 2048);
  /* Variable to read the clear value corresponding to the input variable tmp230
   * at (2620,1-2620,49) */
  uint64_t __tmp_in_tmp230;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 512; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 2048; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp230;
          }
          Arr4DIdxRowM(tmp230, 1, 1, 512, 2048, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp230 : 0;
        }
      }
    }
  }

  uint64_t *tmp231 = make_array<uint64_t>(2048);
  /* Variable to read the clear value corresponding to the input variable tmp231
   * at (2623,1-2623,38) */
  uint64_t __tmp_in_tmp231;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp231;
    }
    Arr1DIdxRowM(tmp231, 2048, i0) = (party == SERVER) ? __tmp_in_tmp231 : 0;
  }

  uint64_t *tmp232 = make_array<uint64_t>(2048);
  /* Variable to read the clear value corresponding to the input variable tmp232
   * at (2626,1-2626,38) */
  uint64_t __tmp_in_tmp232;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp232;
    }
    Arr1DIdxRowM(tmp232, 2048, i0) = (party == SERVER) ? __tmp_in_tmp232 : 0;
  }

  uint64_t *tmp233 = make_array<uint64_t>(2048);
  /* Variable to read the clear value corresponding to the input variable tmp233
   * at (2629,1-2629,38) */
  uint64_t __tmp_in_tmp233;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp233;
    }
    Arr1DIdxRowM(tmp233, 2048, i0) = (party == SERVER) ? __tmp_in_tmp233 : 0;
  }

  uint64_t *tmp234 = make_array<uint64_t>(2048);
  /* Variable to read the clear value corresponding to the input variable tmp234
   * at (2632,1-2632,38) */
  uint64_t __tmp_in_tmp234;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp234;
    }
    Arr1DIdxRowM(tmp234, 2048, i0) = (party == SERVER) ? __tmp_in_tmp234 : 0;
  }

  uint64_t *tmp235 = make_array<uint64_t>(1, 1, 2048, 512);
  /* Variable to read the clear value corresponding to the input variable tmp235
   * at (2635,1-2635,49) */
  uint64_t __tmp_in_tmp235;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 2048; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 512; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp235;
          }
          Arr4DIdxRowM(tmp235, 1, 1, 2048, 512, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp235 : 0;
        }
      }
    }
  }

  uint64_t *tmp236 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp236
   * at (2638,1-2638,37) */
  uint64_t __tmp_in_tmp236;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp236;
    }
    Arr1DIdxRowM(tmp236, 512, i0) = (party == SERVER) ? __tmp_in_tmp236 : 0;
  }

  uint64_t *tmp237 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp237
   * at (2641,1-2641,37) */
  uint64_t __tmp_in_tmp237;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp237;
    }
    Arr1DIdxRowM(tmp237, 512, i0) = (party == SERVER) ? __tmp_in_tmp237 : 0;
  }

  uint64_t *tmp238 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp238
   * at (2644,1-2644,37) */
  uint64_t __tmp_in_tmp238;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp238;
    }
    Arr1DIdxRowM(tmp238, 512, i0) = (party == SERVER) ? __tmp_in_tmp238 : 0;
  }

  uint64_t *tmp239 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp239
   * at (2647,1-2647,37) */
  uint64_t __tmp_in_tmp239;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp239;
    }
    Arr1DIdxRowM(tmp239, 512, i0) = (party == SERVER) ? __tmp_in_tmp239 : 0;
  }

  uint64_t *tmp240 = make_array<uint64_t>(3, 3, 512, 512);
  /* Variable to read the clear value corresponding to the input variable tmp240
   * at (2650,1-2650,48) */
  uint64_t __tmp_in_tmp240;
  for (uint64_t i0 = (uint64_t)0; i0 < 3; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 3; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 512; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 512; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp240;
          }
          Arr4DIdxRowM(tmp240, 3, 3, 512, 512, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp240 : 0;
        }
      }
    }
  }

  uint64_t *tmp241 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp241
   * at (2653,1-2653,37) */
  uint64_t __tmp_in_tmp241;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp241;
    }
    Arr1DIdxRowM(tmp241, 512, i0) = (party == SERVER) ? __tmp_in_tmp241 : 0;
  }

  uint64_t *tmp242 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp242
   * at (2656,1-2656,37) */
  uint64_t __tmp_in_tmp242;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp242;
    }
    Arr1DIdxRowM(tmp242, 512, i0) = (party == SERVER) ? __tmp_in_tmp242 : 0;
  }

  uint64_t *tmp243 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp243
   * at (2659,1-2659,37) */
  uint64_t __tmp_in_tmp243;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp243;
    }
    Arr1DIdxRowM(tmp243, 512, i0) = (party == SERVER) ? __tmp_in_tmp243 : 0;
  }

  uint64_t *tmp244 = make_array<uint64_t>(512);
  /* Variable to read the clear value corresponding to the input variable tmp244
   * at (2662,1-2662,37) */
  uint64_t __tmp_in_tmp244;
  for (uint64_t i0 = (uint64_t)0; i0 < 512; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp244;
    }
    Arr1DIdxRowM(tmp244, 512, i0) = (party == SERVER) ? __tmp_in_tmp244 : 0;
  }

  uint64_t *tmp245 = make_array<uint64_t>(1, 1, 512, 2048);
  /* Variable to read the clear value corresponding to the input variable tmp245
   * at (2665,1-2665,49) */
  uint64_t __tmp_in_tmp245;
  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1; i1++) {
      for (uint64_t i2 = (uint64_t)0; i2 < 512; i2++) {
        for (uint64_t i3 = (uint64_t)0; i3 < 2048; i3++) {
          if (party == SERVER) {
            gINPUT>> __tmp_in_tmp245;
          }
          Arr4DIdxRowM(tmp245, 1, 1, 512, 2048, i0, i1, i2, i3) =
              (party == SERVER) ? __tmp_in_tmp245 : 0;
        }
      }
    }
  }

  uint64_t *tmp246 = make_array<uint64_t>(2048);
  /* Variable to read the clear value corresponding to the input variable tmp246
   * at (2668,1-2668,38) */
  uint64_t __tmp_in_tmp246;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp246;
    }
    Arr1DIdxRowM(tmp246, 2048, i0) = (party == SERVER) ? __tmp_in_tmp246 : 0;
  }

  uint64_t *tmp247 = make_array<uint64_t>(2048);
  /* Variable to read the clear value corresponding to the input variable tmp247
   * at (2671,1-2671,38) */
  uint64_t __tmp_in_tmp247;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp247;
    }
    Arr1DIdxRowM(tmp247, 2048, i0) = (party == SERVER) ? __tmp_in_tmp247 : 0;
  }

  uint64_t *tmp248 = make_array<uint64_t>(2048);
  /* Variable to read the clear value corresponding to the input variable tmp248
   * at (2674,1-2674,38) */
  uint64_t __tmp_in_tmp248;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp248;
    }
    Arr1DIdxRowM(tmp248, 2048, i0) = (party == SERVER) ? __tmp_in_tmp248 : 0;
  }

  uint64_t *tmp249 = make_array<uint64_t>(2048);
  /* Variable to read the clear value corresponding to the input variable tmp249
   * at (2677,1-2677,38) */
  uint64_t __tmp_in_tmp249;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp249;
    }
    Arr1DIdxRowM(tmp249, 2048, i0) = (party == SERVER) ? __tmp_in_tmp249 : 0;
  }

  uint64_t *tmp250 = make_array<uint64_t>(2048, 1001);
  /* Variable to read the clear value corresponding to the input variable tmp250
   * at (2680,1-2680,44) */
  uint64_t __tmp_in_tmp250;
  for (uint64_t i0 = (uint64_t)0; i0 < 2048; i0++) {
    for (uint64_t i1 = (uint64_t)0; i1 < 1001; i1++) {
      if (party == SERVER) {
        gINPUT>> __tmp_in_tmp250;
      }
      Arr2DIdxRowM(tmp250, 2048, 1001, i0, i1) =
          (party == SERVER) ? __tmp_in_tmp250 : 0;
    }
  }

  uint64_t *tmp251 = make_array<uint64_t>(1001);
  /* Variable to read the clear value corresponding to the input variable tmp251
   * at (2683,1-2683,38) */
  uint64_t __tmp_in_tmp251;
  for (uint64_t i0 = (uint64_t)0; i0 < 1001; i0++) {
    if (party == SERVER) {
      gINPUT>> __tmp_in_tmp251;
    }
    Arr1DIdxRowM(tmp251, 1001, i0) = (party == SERVER) ? __tmp_in_tmp251 : 0;
  }
  std::cerr << "input loaded, starting computation..." << std::endl;
  gINPUTCLOSE;
  StartComputation();

  int64_t *tmp252 = make_array<int64_t>(4, 2);
  Arr2DIdxRowM(tmp252, 4, 2, (int64_t)0, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp252, 4, 2, (int64_t)0, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp252, 4, 2, (int64_t)1, (int64_t)0) = 3;
  Arr2DIdxRowM(tmp252, 4, 2, (int64_t)1, (int64_t)1) = 3;
  Arr2DIdxRowM(tmp252, 4, 2, (int64_t)2, (int64_t)0) = 3;
  Arr2DIdxRowM(tmp252, 4, 2, (int64_t)2, (int64_t)1) = 3;
  Arr2DIdxRowM(tmp252, 4, 2, (int64_t)3, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp252, 4, 2, (int64_t)3, (int64_t)1) = 0;

  uint64_t *tmp253 = make_array<uint64_t>(1, 230, 230, 3);
  Pad442(1, 230, 230, 3, 1, 224, 224, 3, tmp0, 4, 2, tmp252, tmp253);
  ClearMemPublic2(4, 2, tmp252);
  ClearMemSecret4(1, 224, 224, 3, tmp0);

  uint64_t *tmp256 = make_array<uint64_t>(1, 112, 112, 64);
#if USE_CHEETAH
  kIsSharedInput = false;
#endif
  Conv2DWrapper(1, 230, 230, 3, 7, 7, 64, 0, 0, 0, 0, 2, 2, tmp253, tmp1,
                tmp256);
  ClearMemSecret4(1, 230, 230, 3, tmp253);
  ClearMemSecret4(7, 7, 3, 64, tmp1);
#if USE_CHEETAH
  kIsSharedInput = true;
#endif

  uint64_t *tmp259 = make_array<uint64_t>(1, 56, 56, 64);
  MaxPool(1, 56, 56, 64, 3, 3, 0, 1, 0, 1, 2, 2, 1, 112, 112, 64, tmp256,
          tmp259);
  ClearMemSecret4(1, 112, 112, 64, tmp256);

  uint64_t *tmp261 = make_array<uint64_t>(1, 56, 56, 64);
  ScaleDown4(1, 56, 56, 64, tmp259, kScale);
  FusedBatchNorm4411(1, 56, 56, 64, tmp259, tmp2, tmp3, 0, kScale, tmp261);
  ClearMemSecret1(64, tmp3);
  ClearMemSecret4(1, 56, 56, 64, tmp259);
  ClearMemSecret1(64, tmp2);

  uint64_t *tmp265 = make_array<uint64_t>(1, 56, 56, 64);
  Relu4(1, 56, 56, 64, tmp261, tmp265, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 56, 56, 64, tmp261);

  uint64_t *tmp267 = make_array<uint64_t>(1, 56, 56, 256);
  Conv2DWrapper(1, 56, 56, 64, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp265, tmp6,
                tmp267);
  ClearMemSecret4(1, 1, 64, 256, tmp6);

#if USE_FUSED_BN
  uint64_t *tmp272 = make_array<uint64_t>(1, 56, 56, 64);
  FusedBN(1, 56, 56, 64, 1, 1, 64, 0, 0, 0, 0, 1, 1, tmp265, tmp7, tmp8, tmp9, tmp272);
  ClearMemSecret4(1, 56, 56, 64, tmp265);
  ClearMemSecret4(1, 1, 64, 64, tmp7);
  ClearMemSecret1(64, tmp8);
  ClearMemSecret1(64, tmp9);
#else
  uint64_t *tmp269 = make_array<uint64_t>(1, 56, 56, 64);
  Conv2DWrapper(1, 56, 56, 64, 1, 1, 64, 0, 0, 0, 0, 1, 1, tmp265, tmp7, tmp269);
  ClearMemSecret4(1, 56, 56, 64, tmp265);
  ClearMemSecret4(1, 1, 64, 64, tmp7);

  uint64_t *tmp272 = make_array<uint64_t>(1, 56, 56, 64);
  ScaleDown4(1, 56, 56, 64, tmp269, kScale);

  FusedBatchNorm4411(1, 56, 56, 64, tmp269, tmp8, tmp9, 0, kScale, tmp272);

  ClearMemSecret4(1, 56, 56, 64, tmp269);
  ClearMemSecret1(64, tmp8);
  ClearMemSecret1(64, tmp9);
#endif

  uint64_t *tmp276 = make_array<uint64_t>(1, 56, 56, 64);
  Relu4(1, 56, 56, 64, tmp272, tmp276, kScale, kDoExtractTruncate);

  ClearMemSecret4(1, 56, 56, 64, tmp272);

#if USE_FUSED_BN
  uint64_t *tmp281 = make_array<uint64_t>(1, 56, 56, 64);
  FusedBN(1, 56, 56, 64, 3, 3, 64, 1, 1, 1, 1, 1, 1, tmp276, tmp12, tmp13,
          tmp14, tmp281);
  ClearMemSecret4(1, 56, 56, 64, tmp276);
  ClearMemSecret4(3, 3, 64, 64, tmp12);
  ClearMemSecret1(64, tmp13);
  ClearMemSecret1(64, tmp14);
#else
  uint64_t *tmp278 = make_array<uint64_t>(1, 56, 56, 64);
  Conv2DWrapper(1, 56, 56, 64, 3, 3, 64, 1, 1, 1, 1, 1, 1, tmp276, tmp12,
                tmp278);
  ClearMemSecret4(1, 56, 56, 64, tmp276);
  ClearMemSecret4(3, 3, 64, 64, tmp12);

  uint64_t *tmp281 = make_array<uint64_t>(1, 56, 56, 64);
  ScaleDown4(1, 56, 56, 64, tmp278, kScale);
  FusedBatchNorm4411(1, 56, 56, 64, tmp278, tmp13, tmp14, 0, kScale, tmp281);
  ClearMemSecret4(1, 56, 56, 64, tmp278);
  ClearMemSecret1(64, tmp13);
  ClearMemSecret1(64, tmp14);
#endif
  uint64_t *tmp285 = make_array<uint64_t>(1, 56, 56, 64);
  Relu4(1, 56, 56, 64, tmp281, tmp285, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 56, 56, 64, tmp281);

  uint64_t *tmp287 = make_array<uint64_t>(1, 56, 56, 256);
  Conv2DWrapper(1, 56, 56, 64, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp285, tmp17,
                tmp287);

  uint64_t *tmp290 = make_array<uint64_t>(1, 56, 56, 256);
  MatAdd4(1, 56, 56, 256, tmp287, tmp267, tmp290);
  uint64_t *tmp293 = make_array<uint64_t>(1, 56, 56, 256);
  ScaleDown4(1, 56, 56, 256, tmp290, kScale);
  FusedBatchNorm4411(1, 56, 56, 256, tmp290, tmp18, tmp19, 0, kScale, tmp293);
  ClearMemSecret4(1, 56, 56, 64, tmp285);
  ClearMemSecret4(1, 56, 56, 256, tmp287);
  ClearMemSecret4(1, 56, 56, 256, tmp267);
  ClearMemSecret4(1, 1, 64, 256, tmp17);
  ClearMemSecret1(256, tmp18);
  ClearMemSecret1(256, tmp19);

  uint64_t *tmp296 = make_array<uint64_t>(1, 56, 56, 256);
  Relu4(1, 56, 56, 256, tmp293, tmp296, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 56, 56, 256, tmp293);

#if USE_FUSED_BN
  uint64_t *tmp301 = make_array<uint64_t>(1, 56, 56, 64);
  FusedBN(1, 56, 56, 256, 1, 1, 64, 0, 0, 0, 0, 1, 1, tmp296, tmp22, tmp23,
          tmp24, tmp301);
  ClearMemSecret4(1, 56, 56, 256, tmp296);
  ClearMemSecret4(1, 1, 256, 64, tmp22);
  ClearMemSecret1(64, tmp23);
  ClearMemSecret1(64, tmp24);
#else
  uint64_t *tmp298 = make_array<uint64_t>(1, 56, 56, 64);
  Conv2DWrapper(1, 56, 56, 256, 1, 1, 64, 0, 0, 0, 0, 1, 1, tmp296, tmp22,
                tmp298);
  ClearMemSecret4(1, 1, 256, 64, tmp22);
  ClearMemSecret4(1, 56, 56, 256, tmp296);

  uint64_t *tmp301 = make_array<uint64_t>(1, 56, 56, 64);
  ScaleDown4(1, 56, 56, 64, tmp298, kScale);
  FusedBatchNorm4411(1, 56, 56, 64, tmp298, tmp23, tmp24, 0, kScale, tmp301);
  ClearMemSecret1(64, tmp24);
  ClearMemSecret1(64, tmp23);
  ClearMemSecret4(1, 56, 56, 64, tmp298);
#endif

  uint64_t *tmp305 = make_array<uint64_t>(1, 56, 56, 64);
  Relu4(1, 56, 56, 64, tmp301, tmp305, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 56, 56, 64, tmp301);

#if USE_FUSED_BN
  uint64_t *tmp310 = make_array<uint64_t>(1, 56, 56, 64);
  FusedBN(1, 56, 56, 64, 3, 3, 64, 1, 1, 1, 1, 1, 1, tmp305, tmp27, tmp28,
          tmp29, tmp310);
  ClearMemSecret4(1, 56, 56, 64, tmp305);
  ClearMemSecret4(3, 3, 64, 64, tmp27);
  ClearMemSecret1(64, tmp28);
  ClearMemSecret1(64, tmp29);
#else
  uint64_t *tmp307 = make_array<uint64_t>(1, 56, 56, 64);
  Conv2DWrapper(1, 56, 56, 64, 3, 3, 64, 1, 1, 1, 1, 1, 1, tmp305, tmp27,
                tmp307);
  ClearMemSecret4(1, 56, 56, 64, tmp305);
  ClearMemSecret4(3, 3, 64, 64, tmp27);

  uint64_t *tmp310 = make_array<uint64_t>(1, 56, 56, 64);
  ScaleDown4(1, 56, 56, 64, tmp307, kScale);
  FusedBatchNorm4411(1, 56, 56, 64, tmp307, tmp28, tmp29, 0, kScale, tmp310);
  ClearMemSecret1(64, tmp29);
  ClearMemSecret4(1, 56, 56, 64, tmp307);
  ClearMemSecret1(64, tmp28);
#endif

  uint64_t *tmp314 = make_array<uint64_t>(1, 56, 56, 64);
  Relu4(1, 56, 56, 64, tmp310, tmp314, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 56, 56, 64, tmp310);

  uint64_t *tmp316 = make_array<uint64_t>(1, 56, 56, 256);
  Conv2DWrapper(1, 56, 56, 64, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp314, tmp32,
                tmp316);
  ClearMemSecret4(1, 56, 56, 64, tmp314);
  ClearMemSecret4(1, 1, 64, 256, tmp32);

  uint64_t *tmp319 = make_array<uint64_t>(1, 56, 56, 256);
  ScaleUp4(1, 56, 56, 256, tmp290, kScale);
  MatAdd4(1, 56, 56, 256, tmp316, tmp290, tmp319);
  ClearMemSecret4(1, 56, 56, 256, tmp316);
  ClearMemSecret4(1, 56, 56, 256, tmp290);

  uint64_t *tmp322 = make_array<uint64_t>(1, 56, 56, 256);
  ScaleDown4(1, 56, 56, 256, tmp319, kScale);
  FusedBatchNorm4411(1, 56, 56, 256, tmp319, tmp33, tmp34, 0, kScale, tmp322);
  ClearMemSecret1(256, tmp34);
  ClearMemSecret1(256, tmp33);

  uint64_t *tmp325 = make_array<uint64_t>(1, 56, 56, 256);
  Relu4(1, 56, 56, 256, tmp322, tmp325, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 56, 56, 256, tmp322);

#if USE_FUSED_BN
  uint64_t *tmp330 = make_array<uint64_t>(1, 56, 56, 64);
  FusedBN(1, 56, 56, 256, 1, 1, 64, 0, 0, 0, 0, 1, 1, tmp325, tmp37, tmp38,
          tmp39, tmp330);
  ClearMemSecret4(1, 56, 56, 256, tmp325);
  ClearMemSecret4(1, 1, 256, 64, tmp37);
  ClearMemSecret1(64, tmp38);
  ClearMemSecret1(64, tmp39);
#else
  uint64_t *tmp327 = make_array<uint64_t>(1, 56, 56, 64);
  Conv2DWrapper(1, 56, 56, 256, 1, 1, 64, 0, 0, 0, 0, 1, 1, tmp325, tmp37,
                tmp327);
  ClearMemSecret4(1, 1, 256, 64, tmp37);
  ClearMemSecret4(1, 56, 56, 256, tmp325);

  uint64_t *tmp330 = make_array<uint64_t>(1, 56, 56, 64);
  ScaleDown4(1, 56, 56, 64, tmp327, kScale);
  FusedBatchNorm4411(1, 56, 56, 64, tmp327, tmp38, tmp39, 0, kScale, tmp330);
  ClearMemSecret1(64, tmp38);
  ClearMemSecret1(64, tmp39);
  ClearMemSecret4(1, 56, 56, 64, tmp327);
#endif

  uint64_t *tmp334 = make_array<uint64_t>(1, 56, 56, 64);
  Relu4(1, 56, 56, 64, tmp330, tmp334, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 56, 56, 64, tmp330);

#if USE_FUSED_BN
  uint64_t *tmp339 = make_array<uint64_t>(1, 56, 56, 64);
  FusedBN(1, 56, 56, 64, 3, 3, 64, 1, 1, 1, 1, 1, 1, tmp334, tmp42, tmp43,
          tmp44, tmp339);
  ClearMemSecret4(1, 56, 56, 64, tmp334);
  ClearMemSecret4(3, 3, 64, 64, tmp42);
  ClearMemSecret1(64, tmp43);
  ClearMemSecret1(64, tmp44);
#else
  uint64_t *tmp336 = make_array<uint64_t>(1, 56, 56, 64);
  Conv2DWrapper(1, 56, 56, 64, 3, 3, 64, 1, 1, 1, 1, 1, 1, tmp334, tmp42,
                tmp336);
  ClearMemSecret4(3, 3, 64, 64, tmp42);
  ClearMemSecret4(1, 56, 56, 64, tmp334);

  uint64_t *tmp339 = make_array<uint64_t>(1, 56, 56, 64);
  ScaleDown4(1, 56, 56, 64, tmp336, kScale);
  FusedBatchNorm4411(1, 56, 56, 64, tmp336, tmp43, tmp44, 0, kScale, tmp339);
  ClearMemSecret1(64, tmp44);
  ClearMemSecret1(64, tmp43);
  ClearMemSecret4(1, 56, 56, 64, tmp336);
#endif

  uint64_t *tmp343 = make_array<uint64_t>(1, 56, 56, 64);
  Relu4(1, 56, 56, 64, tmp339, tmp343, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 56, 56, 64, tmp339);

  uint64_t *tmp345 = make_array<uint64_t>(1, 56, 56, 256);
  Conv2DWrapper(1, 56, 56, 64, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp343, tmp47,
                tmp345);
  ClearMemSecret4(1, 1, 64, 256, tmp47);
  ClearMemSecret4(1, 56, 56, 64, tmp343);

  uint64_t *tmp348 = make_array<uint64_t>(1, 56, 56, 256);
  ScaleUp4(1, 56, 56, 256, tmp319, kScale);
  MatAdd4(1, 56, 56, 256, tmp345, tmp319, tmp348);
  ClearMemSecret4(1, 56, 56, 256, tmp319);
  ClearMemSecret4(1, 56, 56, 256, tmp345);

  uint64_t *tmp351 = make_array<uint64_t>(1, 56, 56, 256);
  ScaleDown4(1, 56, 56, 256, tmp348, kScale);
  FusedBatchNorm4411(1, 56, 56, 256, tmp348, tmp48, tmp49, 0, kScale, tmp351);
  ClearMemSecret1(256, tmp48);
  ClearMemSecret4(1, 56, 56, 256, tmp348);
  ClearMemSecret1(256, tmp49);

  uint64_t *tmp355 = make_array<uint64_t>(1, 56, 56, 256);
  Relu4(1, 56, 56, 256, tmp351, tmp355, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 56, 56, 256, tmp351);

  int64_t *tmp357 = make_array<int64_t>(4, 2);
  Arr2DIdxRowM(tmp357, 4, 2, (int64_t)0, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp357, 4, 2, (int64_t)0, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp357, 4, 2, (int64_t)1, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp357, 4, 2, (int64_t)1, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp357, 4, 2, (int64_t)2, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp357, 4, 2, (int64_t)2, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp357, 4, 2, (int64_t)3, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp357, 4, 2, (int64_t)3, (int64_t)1) = 0;

  uint64_t *tmp358 = make_array<uint64_t>(1, 56, 56, 256);
  Pad442(1, 56, 56, 256, 1, 56, 56, 256, tmp355, 4, 2, tmp357, tmp358);
  ClearMemPublic2(4, 2, tmp357);

  uint64_t *tmp360 = make_array<uint64_t>(1, 28, 28, 512);
  Conv2DWrapper(1, 56, 56, 256, 1, 1, 512, 0, 0, 0, 0, 2, 2, tmp358, tmp52,
                tmp360);
  ClearMemSecret4(1, 1, 256, 512, tmp52);
  ClearMemSecret4(1, 56, 56, 256, tmp358);

#if USE_FUSED_BN
  uint64_t *tmp366 = make_array<uint64_t>(1, 56, 56, 128);
  FusedBN(1, 56, 56, 256, 1, 1, 128, 0, 0, 0, 0, 1, 1, tmp355, tmp53, tmp54,
          tmp55, tmp366);
  ClearMemSecret4(1, 56, 56, 256, tmp355);
  ClearMemSecret4(1, 1, 256, 128, tmp53);
  ClearMemSecret1(128, tmp55);
  ClearMemSecret1(128, tmp54);
#else
  uint64_t *tmp363 = make_array<uint64_t>(1, 56, 56, 128);
  Conv2DWrapper(1, 56, 56, 256, 1, 1, 128, 0, 0, 0, 0, 1, 1, tmp355, tmp53,
                tmp363);
  ClearMemSecret4(1, 1, 256, 128, tmp53);
  ClearMemSecret4(1, 56, 56, 256, tmp355);

  uint64_t *tmp366 = make_array<uint64_t>(1, 56, 56, 128);
  ScaleDown4(1, 56, 56, 128, tmp363, kScale);
  FusedBatchNorm4411(1, 56, 56, 128, tmp363, tmp54, tmp55, 0, kScale, tmp366);
  ClearMemSecret4(1, 56, 56, 128, tmp363);
  ClearMemSecret1(128, tmp54);
  ClearMemSecret1(128, tmp55);
#endif

  uint64_t *tmp370 = make_array<uint64_t>(1, 56, 56, 128);
  Relu4(1, 56, 56, 128, tmp366, tmp370, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 56, 56, 128, tmp366);

  int64_t *tmp372 = make_array<int64_t>(4, 2);
  Arr2DIdxRowM(tmp372, 4, 2, (int64_t)0, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp372, 4, 2, (int64_t)0, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp372, 4, 2, (int64_t)1, (int64_t)0) = 1;
  Arr2DIdxRowM(tmp372, 4, 2, (int64_t)1, (int64_t)1) = 1;
  Arr2DIdxRowM(tmp372, 4, 2, (int64_t)2, (int64_t)0) = 1;
  Arr2DIdxRowM(tmp372, 4, 2, (int64_t)2, (int64_t)1) = 1;
  Arr2DIdxRowM(tmp372, 4, 2, (int64_t)3, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp372, 4, 2, (int64_t)3, (int64_t)1) = 0;

  uint64_t *tmp373 = make_array<uint64_t>(1, 58, 58, 128);
  Pad442(1, 58, 58, 128, 1, 56, 56, 128, tmp370, 4, 2, tmp372, tmp373);
  ClearMemPublic2(4, 2, tmp372);
  ClearMemSecret4(1, 56, 56, 128, tmp370);

#if USE_FUSED_BN
  uint64_t *tmp379 = make_array<uint64_t>(1, 28, 28, 128);
  FusedBN(1, 58, 58, 128, 3, 3, 128, 0, 0, 0, 0, 2, 2, tmp373, tmp58, tmp59,
          tmp60, tmp379);
  ClearMemSecret4(1, 58, 58, 128, tmp373);
  ClearMemSecret4(3, 3, 128, 128, tmp58);
  ClearMemSecret1(128, tmp59);
  ClearMemSecret1(128, tmp60);
#else
  uint64_t *tmp376 = make_array<uint64_t>(1, 28, 28, 128);
  Conv2DWrapper(1, 58, 58, 128, 3, 3, 128, 0, 0, 0, 0, 2, 2, tmp373, tmp58,
                tmp376);
  ClearMemSecret4(3, 3, 128, 128, tmp58);
  ClearMemSecret4(1, 58, 58, 128, tmp373);

  uint64_t *tmp379 = make_array<uint64_t>(1, 28, 28, 128);
  ScaleDown4(1, 28, 28, 128, tmp376, kScale);
  FusedBatchNorm4411(1, 28, 28, 128, tmp376, tmp59, tmp60, 0, kScale, tmp379);
  ClearMemSecret1(128, tmp59);
  ClearMemSecret4(1, 28, 28, 128, tmp376);
  ClearMemSecret1(128, tmp60);
#endif

  uint64_t *tmp383 = make_array<uint64_t>(1, 28, 28, 128);
  Relu4(1, 28, 28, 128, tmp379, tmp383, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 28, 28, 128, tmp379);

  uint64_t *tmp385 = make_array<uint64_t>(1, 28, 28, 512);
  Conv2DWrapper(1, 28, 28, 128, 1, 1, 512, 0, 0, 0, 0, 1, 1, tmp383, tmp63,
                tmp385);
  ClearMemSecret4(1, 1, 128, 512, tmp63);
  ClearMemSecret4(1, 28, 28, 128, tmp383);

  uint64_t *tmp388 = make_array<uint64_t>(1, 28, 28, 512);
  MatAdd4(1, 28, 28, 512, tmp385, tmp360, tmp388);
  ClearMemSecret4(1, 28, 28, 512, tmp385);
  ClearMemSecret4(1, 28, 28, 512, tmp360);

  uint64_t *tmp391 = make_array<uint64_t>(1, 28, 28, 512);
  ScaleDown4(1, 28, 28, 512, tmp388, kScale);
  FusedBatchNorm4411(1, 28, 28, 512, tmp388, tmp64, tmp65, 0, kScale, tmp391);
  ClearMemSecret1(512, tmp64);
  ClearMemSecret1(512, tmp65);

  uint64_t *tmp394 = make_array<uint64_t>(1, 28, 28, 512);
  Relu4(1, 28, 28, 512, tmp391, tmp394, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 28, 28, 512, tmp391);

#if USE_FUSED_BN
  uint64_t *tmp399 = make_array<uint64_t>(1, 28, 28, 128);
  FusedBN(1, 28, 28, 512, 1, 1, 128, 0, 0, 0, 0, 1, 1, tmp394, tmp68, tmp69,
          tmp70, tmp399);

  ClearMemSecret4(1, 28, 28, 512, tmp394);
  ClearMemSecret4(1, 1, 512, 128, tmp68);
  ClearMemSecret1(128, tmp69);
  ClearMemSecret1(128, tmp70);
#else
  uint64_t *tmp396 = make_array<uint64_t>(1, 28, 28, 128);
  Conv2DWrapper(1, 28, 28, 512, 1, 1, 128, 0, 0, 0, 0, 1, 1, tmp394, tmp68,
                tmp396);
  ClearMemSecret4(1, 28, 28, 512, tmp394);
  ClearMemSecret4(1, 1, 512, 128, tmp68);

  uint64_t *tmp399 = make_array<uint64_t>(1, 28, 28, 128);
  ScaleDown4(1, 28, 28, 128, tmp396, kScale);
  FusedBatchNorm4411(1, 28, 28, 128, tmp396, tmp69, tmp70, 0, kScale, tmp399);
  ClearMemSecret4(1, 28, 28, 128, tmp396);
  ClearMemSecret1(128, tmp69);
  ClearMemSecret1(128, tmp70);
#endif

  uint64_t *tmp403 = make_array<uint64_t>(1, 28, 28, 128);
  Relu4(1, 28, 28, 128, tmp399, tmp403, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 28, 28, 128, tmp399);

  uint64_t *tmp405 = make_array<uint64_t>(1, 28, 28, 128);
  Conv2DWrapper(1, 28, 28, 128, 3, 3, 128, 1, 1, 1, 1, 1, 1, tmp403, tmp73,
                tmp405);
  ClearMemSecret4(3, 3, 128, 128, tmp73);
  ClearMemSecret4(1, 28, 28, 128, tmp403);

  uint64_t *tmp408 = make_array<uint64_t>(1, 28, 28, 128);
  ScaleDown4(1, 28, 28, 128, tmp405, kScale);
  FusedBatchNorm4411(1, 28, 28, 128, tmp405, tmp74, tmp75, 0, kScale, tmp408);
  ClearMemSecret4(1, 28, 28, 128, tmp405);
  ClearMemSecret1(128, tmp75);
  ClearMemSecret1(128, tmp74);

  uint64_t *tmp412 = make_array<uint64_t>(1, 28, 28, 128);
  Relu4(1, 28, 28, 128, tmp408, tmp412, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 28, 28, 128, tmp408);

  uint64_t *tmp414 = make_array<uint64_t>(1, 28, 28, 512);
  Conv2DWrapper(1, 28, 28, 128, 1, 1, 512, 0, 0, 0, 0, 1, 1, tmp412, tmp78,
                tmp414);
  ClearMemSecret4(1, 1, 128, 512, tmp78);
  ClearMemSecret4(1, 28, 28, 128, tmp412);

  uint64_t *tmp417 = make_array<uint64_t>(1, 28, 28, 512);
  ScaleUp4(1, 28, 28, 512, tmp388, kScale);
  MatAdd4(1, 28, 28, 512, tmp414, tmp388, tmp417);
  ClearMemSecret4(1, 28, 28, 512, tmp388);
  ClearMemSecret4(1, 28, 28, 512, tmp414);

  uint64_t *tmp420 = make_array<uint64_t>(1, 28, 28, 512);
  ScaleDown4(1, 28, 28, 512, tmp417, kScale);
  FusedBatchNorm4411(1, 28, 28, 512, tmp417, tmp79, tmp80, 0, kScale, tmp420);
  ClearMemSecret1(512, tmp80);
  ClearMemSecret1(512, tmp79);

  uint64_t *tmp423 = make_array<uint64_t>(1, 28, 28, 512);
  Relu4(1, 28, 28, 512, tmp420, tmp423, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 28, 28, 512, tmp420);

#if USE_FUSED_BN
  uint64_t *tmp428 = make_array<uint64_t>(1, 28, 28, 128);
  FusedBN(1, 28, 28, 512, 1, 1, 128, 0, 0, 0, 0, 1, 1, tmp423, tmp83, tmp84,
          tmp85, tmp428);
  ClearMemSecret4(1, 28, 28, 512, tmp423);
  ClearMemSecret4(1, 1, 512, 128, tmp83);
  ClearMemSecret1(128, tmp84);
  ClearMemSecret1(128, tmp85);
#else
  uint64_t *tmp425 = make_array<uint64_t>(1, 28, 28, 128);
  Conv2DWrapper(1, 28, 28, 512, 1, 1, 128, 0, 0, 0, 0, 1, 1, tmp423, tmp83,
                tmp425);
  ClearMemSecret4(1, 1, 512, 128, tmp83);
  ClearMemSecret4(1, 28, 28, 512, tmp423);

  uint64_t *tmp428 = make_array<uint64_t>(1, 28, 28, 128);
  ScaleDown4(1, 28, 28, 128, tmp425, kScale);
  FusedBatchNorm4411(1, 28, 28, 128, tmp425, tmp84, tmp85, 0, kScale, tmp428);
  ClearMemSecret4(1, 28, 28, 128, tmp425);
  ClearMemSecret1(128, tmp84);
  ClearMemSecret1(128, tmp85);
#endif

  uint64_t *tmp432 = make_array<uint64_t>(1, 28, 28, 128);
  Relu4(1, 28, 28, 128, tmp428, tmp432, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 28, 28, 128, tmp428);

#if USE_FUSED_BN
  uint64_t *tmp437 = make_array<uint64_t>(1, 28, 28, 128);
  FusedBN(1, 28, 28, 128, 3, 3, 128, 1, 1, 1, 1, 1, 1, tmp432, tmp88, tmp89,
          tmp90, tmp437);
  ClearMemSecret4(3, 3, 128, 128, tmp88);
  ClearMemSecret4(1, 28, 28, 128, tmp432);
  ClearMemSecret1(128, tmp89);
  ClearMemSecret1(128, tmp90);
#else
  uint64_t *tmp434 = make_array<uint64_t>(1, 28, 28, 128);
  Conv2DWrapper(1, 28, 28, 128, 3, 3, 128, 1, 1, 1, 1, 1, 1, tmp432, tmp88,
                tmp434);
  ClearMemSecret4(3, 3, 128, 128, tmp88);
  ClearMemSecret4(1, 28, 28, 128, tmp432);

  uint64_t *tmp437 = make_array<uint64_t>(1, 28, 28, 128);
  ScaleDown4(1, 28, 28, 128, tmp434, kScale);
  FusedBatchNorm4411(1, 28, 28, 128, tmp434, tmp89, tmp90, 0, kScale, tmp437);
  ClearMemSecret4(1, 28, 28, 128, tmp434);
  ClearMemSecret1(128, tmp89);
  ClearMemSecret1(128, tmp90);
#endif

  uint64_t *tmp441 = make_array<uint64_t>(1, 28, 28, 128);
  Relu4(1, 28, 28, 128, tmp437, tmp441, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 28, 28, 128, tmp437);

  uint64_t *tmp443 = make_array<uint64_t>(1, 28, 28, 512);
  Conv2DWrapper(1, 28, 28, 128, 1, 1, 512, 0, 0, 0, 0, 1, 1, tmp441, tmp93,
                tmp443);
  ClearMemSecret4(1, 1, 128, 512, tmp93);
  ClearMemSecret4(1, 28, 28, 128, tmp441);

  uint64_t *tmp446 = make_array<uint64_t>(1, 28, 28, 512);
  ScaleUp4(1, 28, 28, 512, tmp417, kScale);
  MatAdd4(1, 28, 28, 512, tmp443, tmp417, tmp446);
  ClearMemSecret4(1, 28, 28, 512, tmp443);
  ClearMemSecret4(1, 28, 28, 512, tmp417);

  uint64_t *tmp449 = make_array<uint64_t>(1, 28, 28, 512);
  ScaleDown4(1, 28, 28, 512, tmp446, kScale);
  FusedBatchNorm4411(1, 28, 28, 512, tmp446, tmp94, tmp95, 0, kScale, tmp449);
  ClearMemSecret1(512, tmp95);
  ClearMemSecret1(512, tmp94);

  uint64_t *tmp452 = make_array<uint64_t>(1, 28, 28, 512);
  Relu4(1, 28, 28, 512, tmp449, tmp452, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 28, 28, 512, tmp449);

#if USE_FUSED_BN
  uint64_t *tmp457 = make_array<uint64_t>(1, 28, 28, 128);
  FusedBN(1, 28, 28, 512, 1, 1, 128, 0, 0, 0, 0, 1, 1, tmp452, tmp98, tmp99,
          tmp100, tmp457);
  ClearMemSecret4(1, 28, 28, 128, tmp452);
  ClearMemSecret4(1, 1, 512, 128, tmp98);
  ClearMemSecret1(128, tmp99);
  ClearMemSecret1(128, tmp100);
#else
  uint64_t *tmp454 = make_array<uint64_t>(1, 28, 28, 128);
  Conv2DWrapper(1, 28, 28, 512, 1, 1, 128, 0, 0, 0, 0, 1, 1, tmp452, tmp98,
                tmp454);
  ClearMemSecret4(1, 1, 512, 128, tmp98);
  ClearMemSecret4(1, 28, 28, 512, tmp452);

  uint64_t *tmp457 = make_array<uint64_t>(1, 28, 28, 128);
  ScaleDown4(1, 28, 28, 128, tmp454, kScale);
  FusedBatchNorm4411(1, 28, 28, 128, tmp454, tmp99, tmp100, 0, kScale, tmp457);
  ClearMemSecret1(128, tmp99);
  ClearMemSecret4(1, 28, 28, 128, tmp454);
  ClearMemSecret1(128, tmp100);
#endif

  uint64_t *tmp461 = make_array<uint64_t>(1, 28, 28, 128);
  Relu4(1, 28, 28, 128, tmp457, tmp461, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 28, 28, 128, tmp457);

#if USE_FUSED_BN
  uint64_t *tmp466 = make_array<uint64_t>(1, 28, 28, 128);
  FusedBN(1, 28, 28, 128, 3, 3, 128, 1, 1, 1, 1, 1, 1, tmp461, tmp103, tmp104,
          tmp105, tmp466);
  ClearMemSecret4(1, 28, 28, 128, tmp461);
  ClearMemSecret4(3, 3, 128, 128, tmp103);
  ClearMemSecret1(128, tmp104);
  ClearMemSecret1(128, tmp105);
#else
  uint64_t *tmp463 = make_array<uint64_t>(1, 28, 28, 128);
  Conv2DWrapper(1, 28, 28, 128, 3, 3, 128, 1, 1, 1, 1, 1, 1, tmp461, tmp103,
                tmp463);
  ClearMemSecret4(1, 28, 28, 128, tmp461);
  ClearMemSecret4(3, 3, 128, 128, tmp103);

  uint64_t *tmp466 = make_array<uint64_t>(1, 28, 28, 128);
  ScaleDown4(1, 28, 28, 128, tmp463, kScale);
  FusedBatchNorm4411(1, 28, 28, 128, tmp463, tmp104, tmp105, 0, kScale, tmp466);
  ClearMemSecret1(128, tmp105);
  ClearMemSecret4(1, 28, 28, 128, tmp463);
  ClearMemSecret1(128, tmp104);
#endif

  uint64_t *tmp470 = make_array<uint64_t>(1, 28, 28, 128);
  Relu4(1, 28, 28, 128, tmp466, tmp470, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 28, 28, 128, tmp466);

  uint64_t *tmp472 = make_array<uint64_t>(1, 28, 28, 512);
  Conv2DWrapper(1, 28, 28, 128, 1, 1, 512, 0, 0, 0, 0, 1, 1, tmp470, tmp108,
                tmp472);
  ClearMemSecret4(1, 1, 128, 512, tmp108);
  ClearMemSecret4(1, 28, 28, 128, tmp470);

  uint64_t *tmp475 = make_array<uint64_t>(1, 28, 28, 512);
  ScaleUp4(1, 28, 28, 512, tmp446, kScale);
  MatAdd4(1, 28, 28, 512, tmp472, tmp446, tmp475);
  ClearMemSecret4(1, 28, 28, 512, tmp472);
  ClearMemSecret4(1, 28, 28, 512, tmp446);

  uint64_t *tmp478 = make_array<uint64_t>(1, 28, 28, 512);
  ScaleDown4(1, 28, 28, 512, tmp475, kScale);
  FusedBatchNorm4411(1, 28, 28, 512, tmp475, tmp109, tmp110, 0, kScale, tmp478);
  ClearMemSecret1(512, tmp109);
  ClearMemSecret1(512, tmp110);
  ClearMemSecret4(1, 28, 28, 512, tmp475);

  uint64_t *tmp482 = make_array<uint64_t>(1, 28, 28, 512);
  Relu4(1, 28, 28, 512, tmp478, tmp482, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 28, 28, 512, tmp478);

  int64_t *tmp484 = make_array<int64_t>(4, 2);
  Arr2DIdxRowM(tmp484, 4, 2, (int64_t)0, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp484, 4, 2, (int64_t)0, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp484, 4, 2, (int64_t)1, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp484, 4, 2, (int64_t)1, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp484, 4, 2, (int64_t)2, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp484, 4, 2, (int64_t)2, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp484, 4, 2, (int64_t)3, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp484, 4, 2, (int64_t)3, (int64_t)1) = 0;

  uint64_t *tmp485 = make_array<uint64_t>(1, 28, 28, 512);
  Pad442(1, 28, 28, 512, 1, 28, 28, 512, tmp482, 4, 2, tmp484, tmp485);
  ClearMemPublic2(4, 2, tmp484);

  uint64_t *tmp487 = make_array<uint64_t>(1, 14, 14, 1024);
  Conv2DWrapper(1, 28, 28, 512, 1, 1, 1024, 0, 0, 0, 0, 2, 2, tmp485, tmp113,
                tmp487);
  ClearMemSecret4(1, 1, 512, 1024, tmp113);
  ClearMemSecret4(1, 28, 28, 512, tmp485);

#if USE_FUSED_BN
  uint64_t *tmp493 = make_array<uint64_t>(1, 28, 28, 256);
  FusedBN(1, 28, 28, 512, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp482, tmp114, tmp115,
          tmp116, tmp493);
  ClearMemSecret4(1, 1, 512, 256, tmp114);
  ClearMemSecret4(1, 28, 28, 512, tmp482);
  ClearMemSecret1(256, tmp115);
  ClearMemSecret1(256, tmp116);
#else
  uint64_t *tmp490 = make_array<uint64_t>(1, 28, 28, 256);
  Conv2DWrapper(1, 28, 28, 512, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp482, tmp114,
                tmp490);
  ClearMemSecret4(1, 1, 512, 256, tmp114);
  ClearMemSecret4(1, 28, 28, 512, tmp482);

  uint64_t *tmp493 = make_array<uint64_t>(1, 28, 28, 256);
  ScaleDown4(1, 28, 28, 256, tmp490, kScale);
  FusedBatchNorm4411(1, 28, 28, 256, tmp490, tmp115, tmp116, 0, kScale, tmp493);
  ClearMemSecret4(1, 28, 28, 256, tmp490);
  ClearMemSecret1(256, tmp115);
  ClearMemSecret1(256, tmp116);
#endif

  uint64_t *tmp497 = make_array<uint64_t>(1, 28, 28, 256);
  Relu4(1, 28, 28, 256, tmp493, tmp497, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 28, 28, 256, tmp493);

  int64_t *tmp499 = make_array<int64_t>(4, 2);
  Arr2DIdxRowM(tmp499, 4, 2, (int64_t)0, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp499, 4, 2, (int64_t)0, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp499, 4, 2, (int64_t)1, (int64_t)0) = 1;
  Arr2DIdxRowM(tmp499, 4, 2, (int64_t)1, (int64_t)1) = 1;
  Arr2DIdxRowM(tmp499, 4, 2, (int64_t)2, (int64_t)0) = 1;
  Arr2DIdxRowM(tmp499, 4, 2, (int64_t)2, (int64_t)1) = 1;
  Arr2DIdxRowM(tmp499, 4, 2, (int64_t)3, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp499, 4, 2, (int64_t)3, (int64_t)1) = 0;

  uint64_t *tmp500 = make_array<uint64_t>(1, 30, 30, 256);
  Pad442(1, 30, 30, 256, 1, 28, 28, 256, tmp497, 4, 2, tmp499, tmp500);
  ClearMemPublic2(4, 2, tmp499);
  ClearMemSecret4(1, 28, 28, 256, tmp497);

#if USE_FUSED_BN
  uint64_t *tmp506 = make_array<uint64_t>(1, 14, 14, 256);
  FusedBN(1, 30, 30, 256, 3, 3, 256, 0, 0, 0, 0, 2, 2, tmp500, tmp119, tmp120,
          tmp121, tmp506);
  ClearMemSecret4(1, 30, 30, 256, tmp500);
  ClearMemSecret4(3, 3, 256, 256, tmp119);
  ClearMemSecret1(256, tmp120);
  ClearMemSecret1(256, tmp121);
#else
  uint64_t *tmp503 = make_array<uint64_t>(1, 14, 14, 256);
  Conv2DWrapper(1, 30, 30, 256, 3, 3, 256, 0, 0, 0, 0, 2, 2, tmp500, tmp119,
                tmp503);
  ClearMemSecret4(3, 3, 256, 256, tmp119);
  ClearMemSecret4(1, 30, 30, 256, tmp500);

  uint64_t *tmp506 = make_array<uint64_t>(1, 14, 14, 256);
  ScaleDown4(1, 14, 14, 256, tmp503, kScale);
  FusedBatchNorm4411(1, 14, 14, 256, tmp503, tmp120, tmp121, 0, kScale, tmp506);
  ClearMemSecret1(256, tmp120);
  ClearMemSecret1(256, tmp121);
  ClearMemSecret4(1, 14, 14, 256, tmp503);
#endif

  uint64_t *tmp510 = make_array<uint64_t>(1, 14, 14, 256);
  Relu4(1, 14, 14, 256, tmp506, tmp510, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 256, tmp506);

  uint64_t *tmp512 = make_array<uint64_t>(1, 14, 14, 1024);
  Conv2DWrapper(1, 14, 14, 256, 1, 1, 1024, 0, 0, 0, 0, 1, 1, tmp510, tmp124,
                tmp512);
  ClearMemSecret4(1, 1, 256, 1024, tmp124);
  ClearMemSecret4(1, 14, 14, 256, tmp510);

  uint64_t *tmp515 = make_array<uint64_t>(1, 14, 14, 1024);
  MatAdd4(1, 14, 14, 1024, tmp512, tmp487, tmp515);
  ClearMemSecret4(1, 14, 14, 1024, tmp512);
  ClearMemSecret4(1, 14, 14, 1024, tmp487);

  uint64_t *tmp518 = make_array<uint64_t>(1, 14, 14, 1024);
  ScaleDown4(1, 14, 14, 1024, tmp515, kScale);
  FusedBatchNorm4411(1, 14, 14, 1024, tmp515, tmp125, tmp126, 0, kScale,
                     tmp518);
  ClearMemSecret1(1024, tmp126);
  ClearMemSecret1(1024, tmp125);

  uint64_t *tmp521 = make_array<uint64_t>(1, 14, 14, 1024);
  Relu4(1, 14, 14, 1024, tmp518, tmp521, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 1024, tmp518);

#if USE_FUSED_BN
  uint64_t *tmp526 = make_array<uint64_t>(1, 14, 14, 256);
  FusedBN(1, 14, 14, 1024, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp521, tmp129, tmp130,
          tmp131, tmp526);
  ClearMemSecret4(1, 14, 14, 1024, tmp521);
  ClearMemSecret4(1, 1, 1024, 256, tmp129);
  ClearMemSecret1(256, tmp130);
  ClearMemSecret1(256, tmp131);
#else
  uint64_t *tmp523 = make_array<uint64_t>(1, 14, 14, 256);
  Conv2DWrapper(1, 14, 14, 1024, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp521, tmp129,
                tmp523);
  ClearMemSecret4(1, 1, 1024, 256, tmp129);
  ClearMemSecret4(1, 14, 14, 1024, tmp521);

  uint64_t *tmp526 = make_array<uint64_t>(1, 14, 14, 256);
  ScaleDown4(1, 14, 14, 256, tmp523, kScale);
  FusedBatchNorm4411(1, 14, 14, 256, tmp523, tmp130, tmp131, 0, kScale, tmp526);
  ClearMemSecret1(256, tmp131);
  ClearMemSecret1(256, tmp130);
  ClearMemSecret4(1, 14, 14, 256, tmp523);
#endif

  uint64_t *tmp530 = make_array<uint64_t>(1, 14, 14, 256);
  Relu4(1, 14, 14, 256, tmp526, tmp530, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 256, tmp526);

#if USE_FUSED_BN
  uint64_t *tmp535 = make_array<uint64_t>(1, 14, 14, 256);
  FusedBN(1, 14, 14, 256, 3, 3, 256, 1, 1, 1, 1, 1, 1, tmp530, tmp134, tmp135,
          tmp136, tmp535);
  ClearMemSecret4(1, 14, 14, 256, tmp530);
  ClearMemSecret4(3, 3, 256, 256, tmp134);
  ClearMemSecret1(256, tmp135);
  ClearMemSecret1(256, tmp136);
#else
  uint64_t *tmp532 = make_array<uint64_t>(1, 14, 14, 256);
  Conv2DWrapper(1, 14, 14, 256, 3, 3, 256, 1, 1, 1, 1, 1, 1, tmp530, tmp134,
                tmp532);
  ClearMemSecret4(3, 3, 256, 256, tmp134);
  ClearMemSecret4(1, 14, 14, 256, tmp530);

  uint64_t *tmp535 = make_array<uint64_t>(1, 14, 14, 256);
  ScaleDown4(1, 14, 14, 256, tmp532, kScale);
  FusedBatchNorm4411(1, 14, 14, 256, tmp532, tmp135, tmp136, 0, kScale, tmp535);
  ClearMemSecret4(1, 14, 14, 256, tmp532);
  ClearMemSecret1(256, tmp136);
  ClearMemSecret1(256, tmp135);
#endif

  uint64_t *tmp539 = make_array<uint64_t>(1, 14, 14, 256);
  Relu4(1, 14, 14, 256, tmp535, tmp539, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 256, tmp535);

  uint64_t *tmp541 = make_array<uint64_t>(1, 14, 14, 1024);
  Conv2DWrapper(1, 14, 14, 256, 1, 1, 1024, 0, 0, 0, 0, 1, 1, tmp539, tmp139,
                tmp541);
  ClearMemSecret4(1, 1, 256, 1024, tmp139);
  ClearMemSecret4(1, 14, 14, 256, tmp539);

  uint64_t *tmp544 = make_array<uint64_t>(1, 14, 14, 1024);
  ScaleUp4(1, 14, 14, 1024, tmp515, kScale);
  MatAdd4(1, 14, 14, 1024, tmp541, tmp515, tmp544);
  ClearMemSecret4(1, 14, 14, 1024, tmp541);
  ClearMemSecret4(1, 14, 14, 1024, tmp515);

  uint64_t *tmp547 = make_array<uint64_t>(1, 14, 14, 1024);
  ScaleDown4(1, 14, 14, 1024, tmp544, kScale);
  FusedBatchNorm4411(1, 14, 14, 1024, tmp544, tmp140, tmp141, 0, kScale,
                     tmp547);
  ClearMemSecret1(1024, tmp141);
  ClearMemSecret1(1024, tmp140);

  uint64_t *tmp550 = make_array<uint64_t>(1, 14, 14, 1024);
  Relu4(1, 14, 14, 1024, tmp547, tmp550, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 1024, tmp547);

#if USE_FUSED_BN
  uint64_t *tmp555 = make_array<uint64_t>(1, 14, 14, 256);
  FusedBN(1, 14, 14, 1024, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp550, tmp144, tmp145,
          tmp146, tmp555);
  ClearMemSecret4(1, 14, 14, 1024, tmp550);
  ClearMemSecret4(1, 1, 1024, 256, tmp144);
  ClearMemSecret1(256, tmp145);
  ClearMemSecret1(256, tmp146);
#else
  uint64_t *tmp552 = make_array<uint64_t>(1, 14, 14, 256);
  Conv2DWrapper(1, 14, 14, 1024, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp550, tmp144,
                tmp552);
  ClearMemSecret4(1, 1, 1024, 256, tmp144);
  ClearMemSecret4(1, 14, 14, 1024, tmp550);

  uint64_t *tmp555 = make_array<uint64_t>(1, 14, 14, 256);
  ScaleDown4(1, 14, 14, 256, tmp552, kScale);
  FusedBatchNorm4411(1, 14, 14, 256, tmp552, tmp145, tmp146, 0, kScale, tmp555);
  ClearMemSecret1(256, tmp146);
  ClearMemSecret1(256, tmp145);
  ClearMemSecret4(1, 14, 14, 256, tmp552);
#endif

  uint64_t *tmp559 = make_array<uint64_t>(1, 14, 14, 256);
  Relu4(1, 14, 14, 256, tmp555, tmp559, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 256, tmp555);

#if USE_FUSED_BN
  uint64_t *tmp564 = make_array<uint64_t>(1, 14, 14, 256);
  FusedBN(1, 14, 14, 256, 3, 3, 256, 1, 1, 1, 1, 1, 1, tmp559, tmp149, tmp150,
          tmp151, tmp564);
  ClearMemSecret4(1, 14, 14, 256, tmp559);
  ClearMemSecret4(3, 3, 256, 256, tmp149);
  ClearMemSecret1(256, tmp150);
  ClearMemSecret1(256, tmp151);
#else
  uint64_t *tmp561 = make_array<uint64_t>(1, 14, 14, 256);
  Conv2DWrapper(1, 14, 14, 256, 3, 3, 256, 1, 1, 1, 1, 1, 1, tmp559, tmp149,
                tmp561);
  ClearMemSecret4(3, 3, 256, 256, tmp149);
  ClearMemSecret4(1, 14, 14, 256, tmp559);

  uint64_t *tmp564 = make_array<uint64_t>(1, 14, 14, 256);
  ScaleDown4(1, 14, 14, 256, tmp561, kScale);
  FusedBatchNorm4411(1, 14, 14, 256, tmp561, tmp150, tmp151, 0, kScale, tmp564);
  ClearMemSecret4(1, 14, 14, 256, tmp561);
  ClearMemSecret1(256, tmp151);
  ClearMemSecret1(256, tmp150);
#endif

  uint64_t *tmp568 = make_array<uint64_t>(1, 14, 14, 256);
  Relu4(1, 14, 14, 256, tmp564, tmp568, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 256, tmp564);

  uint64_t *tmp570 = make_array<uint64_t>(1, 14, 14, 1024);
  Conv2DWrapper(1, 14, 14, 256, 1, 1, 1024, 0, 0, 0, 0, 1, 1, tmp568, tmp154,
                tmp570);
  ClearMemSecret4(1, 1, 256, 1024, tmp154);
  ClearMemSecret4(1, 14, 14, 256, tmp568);

  uint64_t *tmp573 = make_array<uint64_t>(1, 14, 14, 1024);
  ScaleUp4(1, 14, 14, 1024, tmp544, kScale);
  MatAdd4(1, 14, 14, 1024, tmp570, tmp544, tmp573);
  ClearMemSecret4(1, 14, 14, 1024, tmp570);
  ClearMemSecret4(1, 14, 14, 1024, tmp544);

  uint64_t *tmp576 = make_array<uint64_t>(1, 14, 14, 1024);
  ScaleDown4(1, 14, 14, 1024, tmp573, kScale);
  FusedBatchNorm4411(1, 14, 14, 1024, tmp573, tmp155, tmp156, 0, kScale,
                     tmp576);
  ClearMemSecret1(1024, tmp156);
  ClearMemSecret1(1024, tmp155);

  uint64_t *tmp579 = make_array<uint64_t>(1, 14, 14, 1024);
  Relu4(1, 14, 14, 1024, tmp576, tmp579, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 1024, tmp576);

#if USE_FUSED_BN
  uint64_t *tmp584 = make_array<uint64_t>(1, 14, 14, 256);
  FusedBN(1, 14, 14, 1024, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp579, tmp159, tmp160,
          tmp161, tmp584);
  ClearMemSecret4(1, 14, 14, 1024, tmp579);
  ClearMemSecret4(1, 1, 1024, 256, tmp159);
  ClearMemSecret1(256, tmp160);
  ClearMemSecret1(256, tmp161);
#else
  uint64_t *tmp581 = make_array<uint64_t>(1, 14, 14, 256);
  Conv2DWrapper(1, 14, 14, 1024, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp579, tmp159,
                tmp581);
  ClearMemSecret4(1, 1, 1024, 256, tmp159);
  ClearMemSecret4(1, 14, 14, 1024, tmp579);

  uint64_t *tmp584 = make_array<uint64_t>(1, 14, 14, 256);
  ScaleDown4(1, 14, 14, 256, tmp581, kScale);
  FusedBatchNorm4411(1, 14, 14, 256, tmp581, tmp160, tmp161, 0, kScale, tmp584);
  ClearMemSecret1(256, tmp161);
  ClearMemSecret1(256, tmp160);
  ClearMemSecret4(1, 14, 14, 256, tmp581);
#endif

  uint64_t *tmp588 = make_array<uint64_t>(1, 14, 14, 256);
  Relu4(1, 14, 14, 256, tmp584, tmp588, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 256, tmp584);

#if USE_FUSED_BN
  uint64_t *tmp593 = make_array<uint64_t>(1, 14, 14, 256);
  FusedBN(1, 14, 14, 256, 3, 3, 256, 1, 1, 1, 1, 1, 1, tmp588, tmp164, tmp165,
          tmp166, tmp593);
  ClearMemSecret4(1, 14, 14, 256, tmp588);
  ClearMemSecret4(3, 3, 256, 256, tmp164);
  ClearMemSecret1(256, tmp165);
  ClearMemSecret1(256, tmp166);
#else
  uint64_t *tmp590 = make_array<uint64_t>(1, 14, 14, 256);
  Conv2DWrapper(1, 14, 14, 256, 3, 3, 256, 1, 1, 1, 1, 1, 1, tmp588, tmp164,
                tmp590);
  ClearMemSecret4(3, 3, 256, 256, tmp164);
  ClearMemSecret4(1, 14, 14, 256, tmp588);

  uint64_t *tmp593 = make_array<uint64_t>(1, 14, 14, 256);
  ScaleDown4(1, 14, 14, 256, tmp590, kScale);
  FusedBatchNorm4411(1, 14, 14, 256, tmp590, tmp165, tmp166, 0, kScale, tmp593);
  ClearMemSecret4(1, 14, 14, 256, tmp590);
  ClearMemSecret1(256, tmp166);
  ClearMemSecret1(256, tmp165);
#endif

  uint64_t *tmp597 = make_array<uint64_t>(1, 14, 14, 256);
  Relu4(1, 14, 14, 256, tmp593, tmp597, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 256, tmp593);

  uint64_t *tmp599 = make_array<uint64_t>(1, 14, 14, 1024);
  Conv2DWrapper(1, 14, 14, 256, 1, 1, 1024, 0, 0, 0, 0, 1, 1, tmp597, tmp169,
                tmp599);
  ClearMemSecret4(1, 1, 256, 1024, tmp169);
  ClearMemSecret4(1, 14, 14, 256, tmp597);

  uint64_t *tmp602 = make_array<uint64_t>(1, 14, 14, 1024);
  ScaleUp4(1, 14, 14, 1024, tmp573, kScale);
  MatAdd4(1, 14, 14, 1024, tmp599, tmp573, tmp602);
  ClearMemSecret4(1, 14, 14, 1024, tmp599);
  ClearMemSecret4(1, 14, 14, 1024, tmp573);

  uint64_t *tmp605 = make_array<uint64_t>(1, 14, 14, 1024);
  ScaleDown4(1, 14, 14, 1024, tmp602, kScale);
  FusedBatchNorm4411(1, 14, 14, 1024, tmp602, tmp170, tmp171, 0, kScale,
                     tmp605);
  ClearMemSecret1(1024, tmp171);
  ClearMemSecret1(1024, tmp170);

  uint64_t *tmp608 = make_array<uint64_t>(1, 14, 14, 1024);
  Relu4(1, 14, 14, 1024, tmp605, tmp608, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 1024, tmp605);

#if USE_FUSED_BN
  uint64_t *tmp613 = make_array<uint64_t>(1, 14, 14, 256);
  FusedBN(1, 14, 14, 1024, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp608, tmp174, tmp175,
          tmp176, tmp613);
  ClearMemSecret4(1, 14, 14, 1024, tmp608);
  ClearMemSecret4(1, 1, 1024, 256, tmp174);
  ClearMemSecret1(256, tmp175);
  ClearMemSecret1(256, tmp176);
#else
  uint64_t *tmp610 = make_array<uint64_t>(1, 14, 14, 256);
  Conv2DWrapper(1, 14, 14, 1024, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp608, tmp174,
                tmp610);
  ClearMemSecret4(1, 14, 14, 1024, tmp608);
  ClearMemSecret4(1, 1, 1024, 256, tmp174);

  uint64_t *tmp613 = make_array<uint64_t>(1, 14, 14, 256);
  ScaleDown4(1, 14, 14, 256, tmp610, kScale);
  FusedBatchNorm4411(1, 14, 14, 256, tmp610, tmp175, tmp176, 0, kScale, tmp613);
  ClearMemSecret4(1, 14, 14, 256, tmp610);
  ClearMemSecret1(256, tmp176);
  ClearMemSecret1(256, tmp175);
#endif

  uint64_t *tmp617 = make_array<uint64_t>(1, 14, 14, 256);
  Relu4(1, 14, 14, 256, tmp613, tmp617, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 256, tmp613);

#if USE_FUSED_BN
  uint64_t *tmp622 = make_array<uint64_t>(1, 14, 14, 256);
  FusedBN(1, 14, 14, 256, 3, 3, 256, 1, 1, 1, 1, 1, 1, tmp617, tmp179, tmp180,
          tmp181, tmp622);
  ClearMemSecret4(1, 14, 14, 256, tmp617);
  ClearMemSecret4(3, 3, 256, 256, tmp179);
  ClearMemSecret1(256, tmp180);
  ClearMemSecret1(256, tmp181);
#else
  uint64_t *tmp619 = make_array<uint64_t>(1, 14, 14, 256);
  Conv2DWrapper(1, 14, 14, 256, 3, 3, 256, 1, 1, 1, 1, 1, 1, tmp617, tmp179,
                tmp619);
  ClearMemSecret4(3, 3, 256, 256, tmp179);
  ClearMemSecret4(1, 14, 14, 256, tmp617);

  uint64_t *tmp622 = make_array<uint64_t>(1, 14, 14, 256);
  ScaleDown4(1, 14, 14, 256, tmp619, kScale);
  FusedBatchNorm4411(1, 14, 14, 256, tmp619, tmp180, tmp181, 0, kScale, tmp622);
  ClearMemSecret4(1, 14, 14, 256, tmp619);
  ClearMemSecret1(256, tmp181);
  ClearMemSecret1(256, tmp180);
#endif

  uint64_t *tmp626 = make_array<uint64_t>(1, 14, 14, 256);
  Relu4(1, 14, 14, 256, tmp622, tmp626, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 256, tmp622);

  uint64_t *tmp628 = make_array<uint64_t>(1, 14, 14, 1024);
  Conv2DWrapper(1, 14, 14, 256, 1, 1, 1024, 0, 0, 0, 0, 1, 1, tmp626, tmp184,
                tmp628);
  ClearMemSecret4(1, 14, 14, 256, tmp626);
  ClearMemSecret4(1, 1, 256, 1024, tmp184);

  uint64_t *tmp631 = make_array<uint64_t>(1, 14, 14, 1024);
  ScaleUp4(1, 14, 14, 1024, tmp602, kScale);
  MatAdd4(1, 14, 14, 1024, tmp628, tmp602, tmp631);
  ClearMemSecret4(1, 14, 14, 1024, tmp628);
  ClearMemSecret4(1, 14, 14, 1024, tmp602);

  uint64_t *tmp634 = make_array<uint64_t>(1, 14, 14, 1024);
  ScaleDown4(1, 14, 14, 1024, tmp631, kScale);
  FusedBatchNorm4411(1, 14, 14, 1024, tmp631, tmp185, tmp186, 0, kScale,
                     tmp634);
  ClearMemSecret1(1024, tmp186);
  ClearMemSecret1(1024, tmp185);

  uint64_t *tmp637 = make_array<uint64_t>(1, 14, 14, 1024);
  Relu4(1, 14, 14, 1024, tmp634, tmp637, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 1024, tmp634);

#if USE_FUSED_BN
  uint64_t *tmp642 = make_array<uint64_t>(1, 14, 14, 256);
  FusedBN(1, 14, 14, 1024, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp637, tmp189, tmp190,
          tmp191, tmp642);
  ClearMemSecret4(1, 14, 14, 1024, tmp637);
  ClearMemSecret4(1, 1, 1024, 256, tmp189);
  ClearMemSecret1(256, tmp190);
  ClearMemSecret1(256, tmp191);
#else
  uint64_t *tmp639 = make_array<uint64_t>(1, 14, 14, 256);
  Conv2DWrapper(1, 14, 14, 1024, 1, 1, 256, 0, 0, 0, 0, 1, 1, tmp637, tmp189,
                tmp639);
  ClearMemSecret4(1, 1, 1024, 256, tmp189);
  ClearMemSecret4(1, 14, 14, 1024, tmp637);

  uint64_t *tmp642 = make_array<uint64_t>(1, 14, 14, 256);
  ScaleDown4(1, 14, 14, 256, tmp639, kScale);
  FusedBatchNorm4411(1, 14, 14, 256, tmp639, tmp190, tmp191, 0, kScale, tmp642);
  ClearMemSecret1(256, tmp190);
  ClearMemSecret4(1, 14, 14, 256, tmp639);
  ClearMemSecret1(256, tmp191);
#endif

  uint64_t *tmp646 = make_array<uint64_t>(1, 14, 14, 256);
  Relu4(1, 14, 14, 256, tmp642, tmp646, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 256, tmp642);

#if USE_FUSED_BN
  uint64_t *tmp651 = make_array<uint64_t>(1, 14, 14, 256);
  FusedBN(1, 14, 14, 256, 3, 3, 256, 1, 1, 1, 1, 1, 1, tmp646, tmp194, tmp195,
          tmp196, tmp651);
  ClearMemSecret4(1, 14, 14, 256, tmp646);
  ClearMemSecret4(3, 3, 256, 256, tmp194);
  ClearMemSecret1(256, tmp196);
  ClearMemSecret1(256, tmp195);
#else
  uint64_t *tmp648 = make_array<uint64_t>(1, 14, 14, 256);
  Conv2DWrapper(1, 14, 14, 256, 3, 3, 256, 1, 1, 1, 1, 1, 1, tmp646, tmp194,
                tmp648);
  ClearMemSecret4(1, 14, 14, 256, tmp646);
  ClearMemSecret4(3, 3, 256, 256, tmp194);

  uint64_t *tmp651 = make_array<uint64_t>(1, 14, 14, 256);
  ScaleDown4(1, 14, 14, 256, tmp648, kScale);
  FusedBatchNorm4411(1, 14, 14, 256, tmp648, tmp195, tmp196, 0, kScale, tmp651);
  ClearMemSecret4(1, 14, 14, 256, tmp648);
  ClearMemSecret1(256, tmp196);
  ClearMemSecret1(256, tmp195);
#endif

  uint64_t *tmp655 = make_array<uint64_t>(1, 14, 14, 256);
  Relu4(1, 14, 14, 256, tmp651, tmp655, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 256, tmp651);

  uint64_t *tmp657 = make_array<uint64_t>(1, 14, 14, 1024);
  Conv2DWrapper(1, 14, 14, 256, 1, 1, 1024, 0, 0, 0, 0, 1, 1, tmp655, tmp199,
                tmp657);
  ClearMemSecret4(1, 14, 14, 256, tmp655);
  ClearMemSecret4(1, 1, 256, 1024, tmp199);

  uint64_t *tmp660 = make_array<uint64_t>(1, 14, 14, 1024);
  ScaleUp4(1, 14, 14, 1024, tmp631, kScale);
  MatAdd4(1, 14, 14, 1024, tmp657, tmp631, tmp660);
  ClearMemSecret4(1, 14, 14, 1024, tmp657);
  ClearMemSecret4(1, 14, 14, 1024, tmp631);

  uint64_t *tmp663 = make_array<uint64_t>(1, 14, 14, 1024);
  ScaleDown4(1, 14, 14, 1024, tmp660, kScale);
  FusedBatchNorm4411(1, 14, 14, 1024, tmp660, tmp200, tmp201, 0, kScale,
                     tmp663);
  ClearMemSecret4(1, 14, 14, 1024, tmp660);
  ClearMemSecret1(1024, tmp200);
  ClearMemSecret1(1024, tmp201);

  uint64_t *tmp667 = make_array<uint64_t>(1, 14, 14, 1024);
  Relu4(1, 14, 14, 1024, tmp663, tmp667, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 1024, tmp663);

  int64_t *tmp669 = make_array<int64_t>(4, 2);
  Arr2DIdxRowM(tmp669, 4, 2, (int64_t)0, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp669, 4, 2, (int64_t)0, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp669, 4, 2, (int64_t)1, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp669, 4, 2, (int64_t)1, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp669, 4, 2, (int64_t)2, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp669, 4, 2, (int64_t)2, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp669, 4, 2, (int64_t)3, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp669, 4, 2, (int64_t)3, (int64_t)1) = 0;

  uint64_t *tmp670 = make_array<uint64_t>(1, 14, 14, 1024);
  Pad442(1, 14, 14, 1024, 1, 14, 14, 1024, tmp667, 4, 2, tmp669, tmp670);
  ClearMemPublic2(4, 2, tmp669);

  uint64_t *tmp672 = make_array<uint64_t>(1, 7, 7, 2048);
  Conv2DWrapper(1, 14, 14, 1024, 1, 1, 2048, 0, 0, 0, 0, 2, 2, tmp670, tmp204,
                tmp672);
  ClearMemSecret4(1, 14, 14, 1024, tmp670);
  ClearMemSecret4(1, 1, 1024, 2048, tmp204);

#if USE_FUSED_BN
  uint64_t *tmp678 = make_array<uint64_t>(1, 14, 14, 512);
  FusedBN(1, 14, 14, 1024, 1, 1, 512, 0, 0, 0, 0, 1, 1, tmp667, tmp205, tmp206,
          tmp207, tmp678);
  ClearMemSecret4(1, 14, 14, 1024, tmp667);
  ClearMemSecret4(1, 1, 1024, 512, tmp205);
  ClearMemSecret1(512, tmp206);
  ClearMemSecret1(512, tmp207);
#else
  uint64_t *tmp675 = make_array<uint64_t>(1, 14, 14, 512);
  Conv2DWrapper(1, 14, 14, 1024, 1, 1, 512, 0, 0, 0, 0, 1, 1, tmp667, tmp205,
                tmp675);
  ClearMemSecret4(1, 14, 14, 1024, tmp667);
  ClearMemSecret4(1, 1, 1024, 512, tmp205);

  uint64_t *tmp678 = make_array<uint64_t>(1, 14, 14, 512);
  ScaleDown4(1, 14, 14, 512, tmp675, kScale);
  FusedBatchNorm4411(1, 14, 14, 512, tmp675, tmp206, tmp207, 0, kScale, tmp678);
  ClearMemSecret1(512, tmp206);
  ClearMemSecret1(512, tmp207);
  ClearMemSecret4(1, 14, 14, 512, tmp675);
#endif

  uint64_t *tmp682 = make_array<uint64_t>(1, 14, 14, 512);
  Relu4(1, 14, 14, 512, tmp678, tmp682, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 14, 14, 512, tmp678);

  int64_t *tmp684 = make_array<int64_t>(4, 2);
  Arr2DIdxRowM(tmp684, 4, 2, (int64_t)0, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp684, 4, 2, (int64_t)0, (int64_t)1) = 0;
  Arr2DIdxRowM(tmp684, 4, 2, (int64_t)1, (int64_t)0) = 1;
  Arr2DIdxRowM(tmp684, 4, 2, (int64_t)1, (int64_t)1) = 1;
  Arr2DIdxRowM(tmp684, 4, 2, (int64_t)2, (int64_t)0) = 1;
  Arr2DIdxRowM(tmp684, 4, 2, (int64_t)2, (int64_t)1) = 1;
  Arr2DIdxRowM(tmp684, 4, 2, (int64_t)3, (int64_t)0) = 0;
  Arr2DIdxRowM(tmp684, 4, 2, (int64_t)3, (int64_t)1) = 0;

  uint64_t *tmp685 = make_array<uint64_t>(1, 16, 16, 512);
  Pad442(1, 16, 16, 512, 1, 14, 14, 512, tmp682, 4, 2, tmp684, tmp685);
  ClearMemPublic2(4, 2, tmp684);
  ClearMemSecret4(1, 14, 14, 512, tmp682);

#if USE_FUSED_BN
  uint64_t *tmp691 = make_array<uint64_t>(1, 7, 7, 512);
  FusedBN(1, 16, 16, 512, 3, 3, 512, 0, 0, 0, 0, 2, 2, tmp685, tmp210, tmp211,
          tmp212, tmp691);
  ClearMemSecret4(1, 16, 16, 512, tmp685);
  ClearMemSecret4(3, 3, 512, 512, tmp210);
  ClearMemSecret1(512, tmp211);
  ClearMemSecret1(512, tmp212);
#else
  uint64_t *tmp688 = make_array<uint64_t>(1, 7, 7, 512);
  Conv2DWrapper(1, 16, 16, 512, 3, 3, 512, 0, 0, 0, 0, 2, 2, tmp685, tmp210,
                tmp688);
  ClearMemSecret4(3, 3, 512, 512, tmp210);
  ClearMemSecret4(1, 16, 16, 512, tmp685);

  uint64_t *tmp691 = make_array<uint64_t>(1, 7, 7, 512);
  ScaleDown4(1, 7, 7, 512, tmp688, kScale);
  FusedBatchNorm4411(1, 7, 7, 512, tmp688, tmp211, tmp212, 0, kScale, tmp691);
  ClearMemSecret1(512, tmp211);
  ClearMemSecret1(512, tmp212);
  ClearMemSecret4(1, 7, 7, 512, tmp688);
#endif

  uint64_t *tmp695 = make_array<uint64_t>(1, 7, 7, 512);
  Relu4(1, 7, 7, 512, tmp691, tmp695, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 7, 7, 512, tmp691);

  uint64_t *tmp697 = make_array<uint64_t>(1, 7, 7, 2048);
  Conv2DWrapper(1, 7, 7, 512, 1, 1, 2048, 0, 0, 0, 0, 1, 1, tmp695, tmp215,
                tmp697);
  ClearMemSecret4(1, 1, 512, 2048, tmp215);
  ClearMemSecret4(1, 7, 7, 512, tmp695);

  uint64_t *tmp700 = make_array<uint64_t>(1, 7, 7, 2048);
  MatAdd4(1, 7, 7, 2048, tmp697, tmp672, tmp700);
  ClearMemSecret4(1, 7, 7, 2048, tmp672);
  ClearMemSecret4(1, 7, 7, 2048, tmp697);

  uint64_t *tmp703 = make_array<uint64_t>(1, 7, 7, 2048);
  ScaleDown4(1, 7, 7, 2048, tmp700, kScale);
  FusedBatchNorm4411(1, 7, 7, 2048, tmp700, tmp216, tmp217, 0, kScale, tmp703);
  ClearMemSecret1(2048, tmp217);
  ClearMemSecret1(2048, tmp216);

  uint64_t *tmp706 = make_array<uint64_t>(1, 7, 7, 2048);
  Relu4(1, 7, 7, 2048, tmp703, tmp706, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 7, 7, 2048, tmp703);

#if USE_FUSED_BN
  uint64_t *tmp711 = make_array<uint64_t>(1, 7, 7, 512);
  FusedBN(1, 7, 7, 2048, 1, 1, 512, 0, 0, 0, 0, 1, 1, tmp706, tmp220, tmp221,
          tmp222, tmp711);
  ClearMemSecret4(1, 7, 7, 2048, tmp706);
  ClearMemSecret4(1, 1, 2048, 512, tmp220);
  ClearMemSecret1(512, tmp222);
  ClearMemSecret1(512, tmp221);
#else
  uint64_t *tmp708 = make_array<uint64_t>(1, 7, 7, 512);
  Conv2DWrapper(1, 7, 7, 2048, 1, 1, 512, 0, 0, 0, 0, 1, 1, tmp706, tmp220,
                tmp708);
  ClearMemSecret4(1, 1, 2048, 512, tmp220);
  ClearMemSecret4(1, 7, 7, 2048, tmp706);

  uint64_t *tmp711 = make_array<uint64_t>(1, 7, 7, 512);
  ScaleDown4(1, 7, 7, 512, tmp708, kScale);
  FusedBatchNorm4411(1, 7, 7, 512, tmp708, tmp221, tmp222, 0, kScale, tmp711);
  ClearMemSecret4(1, 7, 7, 512, tmp708);
  ClearMemSecret1(512, tmp222);
  ClearMemSecret1(512, tmp221);
#endif

  uint64_t *tmp715 = make_array<uint64_t>(1, 7, 7, 512);
  Relu4(1, 7, 7, 512, tmp711, tmp715, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 7, 7, 512, tmp711);

#if USE_FUSED_BN
  uint64_t *tmp720 = make_array<uint64_t>(1, 7, 7, 512);
  FusedBN(1, 7, 7, 512, 3, 3, 512, 1, 1, 1, 1, 1, 1, tmp715, tmp225, tmp226,
          tmp227, tmp720);
  ClearMemSecret4(1, 7, 7, 512, tmp715);
  ClearMemSecret4(3, 3, 512, 512, tmp225);
  ClearMemSecret1(512, tmp226);
  ClearMemSecret1(512, tmp227);
#else
  uint64_t *tmp717 = make_array<uint64_t>(1, 7, 7, 512);
  Conv2DWrapper(1, 7, 7, 512, 3, 3, 512, 1, 1, 1, 1, 1, 1, tmp715, tmp225,
                tmp717);
  ClearMemSecret4(1, 7, 7, 512, tmp715);
  ClearMemSecret4(3, 3, 512, 512, tmp225);

  uint64_t *tmp720 = make_array<uint64_t>(1, 7, 7, 512);
  ScaleDown4(1, 7, 7, 512, tmp717, kScale);
  FusedBatchNorm4411(1, 7, 7, 512, tmp717, tmp226, tmp227, 0, kScale, tmp720);
  ClearMemSecret1(512, tmp227);
  ClearMemSecret1(512, tmp226);
  ClearMemSecret4(1, 7, 7, 512, tmp717);
#endif

  uint64_t *tmp724 = make_array<uint64_t>(1, 7, 7, 512);
  Relu4(1, 7, 7, 512, tmp720, tmp724, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 7, 7, 512, tmp720);

  uint64_t *tmp726 = make_array<uint64_t>(1, 7, 7, 2048);
  Conv2DWrapper(1, 7, 7, 512, 1, 1, 2048, 0, 0, 0, 0, 1, 1, tmp724, tmp230,
                tmp726);
  ClearMemSecret4(1, 7, 7, 512, tmp724);
  ClearMemSecret4(1, 1, 512, 2048, tmp230);

  uint64_t *tmp729 = make_array<uint64_t>(1, 7, 7, 2048);
  ScaleUp4(1, 7, 7, 2048, tmp700, kScale);
  MatAdd4(1, 7, 7, 2048, tmp726, tmp700, tmp729);
  ClearMemSecret4(1, 7, 7, 2048, tmp700);
  ClearMemSecret4(1, 7, 7, 2048, tmp726);

  uint64_t *tmp732 = make_array<uint64_t>(1, 7, 7, 2048);
  ScaleDown4(1, 7, 7, 2048, tmp729, kScale);
  FusedBatchNorm4411(1, 7, 7, 2048, tmp729, tmp231, tmp232, 0, kScale, tmp732);
  ClearMemSecret1(2048, tmp231);
  ClearMemSecret1(2048, tmp232);

  uint64_t *tmp735 = make_array<uint64_t>(1, 7, 7, 2048);
  Relu4(1, 7, 7, 2048, tmp732, tmp735, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 7, 7, 2048, tmp732);

#if USE_FUSED_BN
  uint64_t *tmp740 = make_array<uint64_t>(1, 7, 7, 512);
  FusedBN(1, 7, 7, 2048, 1, 1, 512, 0, 0, 0, 0, 1, 1, tmp735, tmp235, tmp236,
          tmp237, tmp740);
  ClearMemSecret4(1, 7, 7, 2048, tmp735);
  ClearMemSecret4(1, 1, 2048, 512, tmp235);
  ClearMemSecret1(512, tmp236);
  ClearMemSecret1(512, tmp237);
#else
  uint64_t *tmp737 = make_array<uint64_t>(1, 7, 7, 512);
  Conv2DWrapper(1, 7, 7, 2048, 1, 1, 512, 0, 0, 0, 0, 1, 1, tmp735, tmp235,
                tmp737);
  ClearMemSecret4(1, 7, 7, 2048, tmp735);
  ClearMemSecret4(1, 1, 2048, 512, tmp235);

  uint64_t *tmp740 = make_array<uint64_t>(1, 7, 7, 512);
  ScaleDown4(1, 7, 7, 512, tmp737, kScale);
  FusedBatchNorm4411(1, 7, 7, 512, tmp737, tmp236, tmp237, 0, kScale, tmp740);
  ClearMemSecret1(512, tmp237);
  ClearMemSecret1(512, tmp236);
  ClearMemSecret4(1, 7, 7, 512, tmp737);
#endif

  uint64_t *tmp744 = make_array<uint64_t>(1, 7, 7, 512);
  Relu4(1, 7, 7, 512, tmp740, tmp744, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 7, 7, 512, tmp740);

#if USE_FUSED_BN
  uint64_t *tmp749 = make_array<uint64_t>(1, 7, 7, 512);
  FusedBN(1, 7, 7, 512, 3, 3, 512, 1, 1, 1, 1, 1, 1, tmp744, tmp240, tmp241,
          tmp242, tmp749);
  ClearMemSecret4(1, 7, 7, 512, tmp744);
  ClearMemSecret4(3, 3, 512, 512, tmp240);
  ClearMemSecret1(512, tmp241);
  ClearMemSecret1(512, tmp242);
#else
  uint64_t *tmp746 = make_array<uint64_t>(1, 7, 7, 512);
  Conv2DWrapper(1, 7, 7, 512, 3, 3, 512, 1, 1, 1, 1, 1, 1, tmp744, tmp240,
                tmp746);
  ClearMemSecret4(3, 3, 512, 512, tmp240);
  ClearMemSecret4(1, 7, 7, 512, tmp744);

  uint64_t *tmp749 = make_array<uint64_t>(1, 7, 7, 512);
  ScaleDown4(1, 7, 7, 512, tmp746, kScale);
  FusedBatchNorm4411(1, 7, 7, 512, tmp746, tmp241, tmp242, 0, kScale, tmp749);
  ClearMemSecret1(512, tmp242);
  ClearMemSecret4(1, 7, 7, 512, tmp746);
  ClearMemSecret1(512, tmp241);
#endif

  uint64_t *tmp753 = make_array<uint64_t>(1, 7, 7, 512);
  Relu4(1, 7, 7, 512, tmp749, tmp753, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 7, 7, 512, tmp749);

  uint64_t *tmp755 = make_array<uint64_t>(1, 7, 7, 2048);
  Conv2DWrapper(1, 7, 7, 512, 1, 1, 2048, 0, 0, 0, 0, 1, 1, tmp753, tmp245, tmp755);
  ClearMemSecret4(1, 7, 7, 512, tmp753);
  ClearMemSecret4(1, 1, 512, 2048, tmp245);

  uint64_t *tmp758 = make_array<uint64_t>(1, 7, 7, 2048);
  ScaleUp4(1, 7, 7, 2048, tmp729, kScale);
  MatAdd4(1, 7, 7, 2048, tmp755, tmp729, tmp758);
  ClearMemSecret4(1, 7, 7, 2048, tmp729);
  ClearMemSecret4(1, 7, 7, 2048, tmp755);

  uint64_t *tmp761 = make_array<uint64_t>(1, 7, 7, 2048);
  ScaleDown4(1, 7, 7, 2048, tmp758, kScale);
  FusedBatchNorm4411(1, 7, 7, 2048, tmp758, tmp246, tmp247, 0, kScale, tmp761);
  ClearMemSecret4(1, 7, 7, 2048, tmp758);
  ClearMemSecret1(2048, tmp247);
  ClearMemSecret1(2048, tmp246);

  uint64_t *tmp765 = make_array<uint64_t>(1, 7, 7, 2048);
  Relu4(1, 7, 7, 2048, tmp761, tmp765, kScale, kDoExtractTruncate);
  ClearMemSecret4(1, 7, 7, 2048, tmp761);

  uint64_t *tmp767 = make_array<uint64_t>(1, 1, 1, 2048);
  AvgPool(1, 1, 1, 2048, 7, 7, 0, 0, 0, 0, 1, 1, 1, 7, 7, 2048, tmp765, tmp767);
  ClearMemSecret4(1, 7, 7, 2048, tmp765);

  uint64_t *tmp771 = make_array<uint64_t>(1, 2048);

  int64_t tmp769 = 1;

  int64_t tmp770 = 2;
  Squeeze24(1, 2048, tmp769, tmp770, 1, 1, 1, 2048, tmp767, tmp771);
  ClearMemSecret4(1, 1, 1, 2048, tmp767);

  uint64_t *tmp773 = make_array<uint64_t>(1, 1001);
  MatMul2D(1, 2048, 1001, tmp771, tmp250, tmp773, 0);
  ClearMemSecret2(2048, 1001, tmp250);
  ClearMemSecret2(1, 2048, tmp771);

  uint64_t *tmp776 = make_array<uint64_t>(1, 1001);
  ScaleUp1(1001, tmp251, kScale);
  MatAddBroadCast2(1, 1001, tmp773, tmp251, tmp776);
  ClearMemSecret2(1, 1001, tmp773);
  ClearMemSecret1(1001, tmp251);

  int64_t tmp779 = 1;

  uint64_t *tmp780 = make_array<uint64_t>(1);
  ArgMax1(1, 1, 1001, tmp776, tmp779, tmp780);
  ClearMemPublic(tmp779);
  EndComputation();

  std::vector<double> prediction_vector(1001);
  for (uint64_t i0 = 0; i0 < 1001; i0++) {
	prediction_vector[i0] = funcReconstruct2PCCons(Arr1DIdxRowM(tmp776, 1001, i0), 2) / 
	  std::pow(4., kScale);
  }
  ClearMemSecret2(1, 1001, tmp776);
  if (party == CLIENT) {
	std::sort(prediction_vector.begin(), prediction_vector.end(), 
			  [](double u, double v) { return u > v; });
	printf("top-10 values from ResNet50\n");
	printf("[");
	for (uint64_t i = 0; i < 10; ++i) {
	  printf("%.7f,", prediction_vector[i]);
	}
	printf("]\n");
  }

  for (uint64_t i0 = (uint64_t)0; i0 < 1; i0++) {
    auto pred = funcReconstruct2PCCons(Arr1DIdxRowM(tmp780, 1, i0), 2);
    if (party == CLIENT) {
	  printf("predicted label=%lld\n", pred);
	}
  }

  finalize();
}