/*  TESTING OF THE REMOTE_ACCESS DIRECTIVE AND THE REMOTE_ACCESS CLAUSE'.
    DISTRIBUTED ARRAY A(N,M,K,L) OR ELEMENTS OF THIS ARRAY ARE REPLICATED
    ON ALL PROCESSORS. */
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#define Min(a, b) ((a) < (b) ? (a) : (b))
#define N 16
#define M 16
#define K 16
#define L 16
#define NL 1000

static void rem4101();
static void rem4102();
static void rem4103();
static void rem4104();
static void rem4105();
static void rem4106();
static void rem4107();
static void rem4108();
static void rem4109();
static void rem4110();
static void rem4111();
static void rem4112();
static void rem4113();
static void rem4114();

static void ansyes(const char tname[]);
static void ansno(const char tname[]);
static void serial4(int AR[N][M][K][L], int NN, int NM, int NK, int NLL,
                    int NNL);

int main(int an, char **as) {
  printf("===START OF REM41========================\n");
  rem4101();
  rem4102();
  rem4103();
  rem4104();
  rem4105();
  rem4106();
  rem4107();
  rem4108();
  rem4109();
  rem4110();
  rem4111();
  rem4112();
  rem4113();
  rem4114();

  printf("=== END OF REM41 ========================= \n");
  return 0;
}
/* ---------------------------------------------REM4101  */
void rem4101() {

  int C[N][M][K][L];
  int nloop, ib;
  char tname[] = "REM4101";
  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[block][block][block][*]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;
#pragma dvm region out(A)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }
  }
#pragma dvm get_actual(A[0][0][0][0])
#pragma dvm remote_access(A[0][0][0][0])
  { ib = A[0][0][0][0]; }
  if (ib == C[0][0][0][0])
    ansyes(tname);
  else
    ansno(tname);
}
/* ---------------------------------------------REM4102  */
void rem4102() {

  int C[N][M][K][L];
  int nloop, ib;
  char tname[] = "REM4102";
  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[block][block][*][block]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;
#pragma dvm region out(A)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }
  }
#pragma dvm get_actual(A[N - 1][M - 1][K - 1][L - 1])
#pragma dvm remote_access(A[N - 1][M - 1][K - 1][L - 1])
  { ib = A[N - 1][M - 1][K - 1][L - 1]; }

  if (ib == C[N - 1][M - 1][K - 1][L - 1])
    ansyes(tname);
  else
    ansno(tname);
}

/* ---------------------------------------------REM4103  */
void rem4103() {

  int C[N][M][K][L];
  int nloop, ib, isuma, isumc;
  char tname[] = "REM4103";
  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[block][*][block][block]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;
  isumc = 0;
  isuma = 0;
#pragma dvm region out(A)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }
  }
#pragma dvm get_actual(A[][][][])
#pragma dvm remote_access(A[][][][])
  {
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < K; jj++) {
            isumc = isumc + C[i][j][ii][jj];
            isuma = isuma + A[i][j][ii][jj];
          }
  }
  if (isuma == isumc)
    ansyes(tname);
  else
    ansno(tname);
}
/* ---------------------------------------------REM4104  */
void rem4104() {

  int C[N][M][K][L];
  int nloop, ib, isuma, isumc;
  char tname[] = "REM4104";

  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[*][block][block][block]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;
  isumc = 0;
  isuma = 0;
#pragma dvm region out(A)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }
  }
#pragma dvm get_actual(A[0][0][0][0])
#pragma dvm remote_access(A[0][][][])
  {
    for (j = 0; j < M; j++)
      for (ii = 0; ii < K; ii++)
        for (jj = 0; jj < K; jj++) {
          isumc = isumc + C[0][j][ii][jj];
          isuma = isuma + A[0][j][ii][jj];
        }
  }
  if (isuma == isumc)
    ansyes(tname);
  else
    ansno(tname);
}
/* ---------------------------------------------REM4105  */
void rem4105() {

  int C[N][M][K][L];
  int nloop, ib, isuma, isumc;
  char tname[] = "REM4105";

  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[block][block][block][*]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;
  isumc = 0;
  isuma = 0;

#pragma dvm region out(A)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }
  }
#pragma dvm get_actual(A[][M - 1][][])
#pragma dvm remote_access(A[][M - 1][][])
  {
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < K; jj++) {
            isumc = isumc + C[i][M - 1][ii][jj];
            isuma = isuma + A[i][M - 1][ii][jj];
          }
  }
  if (isuma == isumc)
    ansyes(tname);
  else
    ansno(tname);
}
/* ---------------------------------------------REM4106  */
void rem4106() {

  int C[N][M][K][L];
  int nloop, ib, isuma, isumc;
  char tname[] = "REM4106";

  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[block][block][*][block]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;
  isumc = 0;
  isuma = 0;

#pragma dvm region out(A)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }
  }
#pragma dvm get_actual(A[][][K - 1][])

#pragma dvm remote_access(A[][][K - 1][])
  {
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (jj = 0; jj < L; jj++) {
          isumc = isumc + C[i][j][K - 1][jj];
          isuma = isuma + A[i][j][K - 1][jj];
        }
  }
  if (isuma == isumc)
    ansyes(tname);
  else
    ansno(tname);
}
/* ---------------------------------------------REM4107  */
void rem4107() {

  int C[N][M][K][L];
  int nloop, ib, isuma, isumc;
  char tname[] = "REM4107";
  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[block][*][block][block]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;
  isumc = 0;
  isuma = 0;

#pragma dvm region out(A)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }
  }
#pragma dvm get_actual(A[][][][L - 1])
#pragma dvm remote_access(A[][][][L - 1])
  {
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++) {
          isumc = isumc + C[i][j][ii][L - 1];
          isuma = isuma + A[i][j][ii][L - 1];
        }
  }
  if (isuma == isumc)
    ansyes(tname);
  else
    ansno(tname);
}
/* ---------------------------------------------REM4108  */
void rem4108() {

  int C[N][M][K][L];
  int nloop, ib;
  char tname[] = "REM4108";

  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[*][block][block][block]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;

#pragma dvm region local(A, B)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }

#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
    remote_access(A[0][0][0][0])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {

            B[i][j][ii][jj] = A[0][0][0][0];
          }
#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            if (B[i][j][ii][jj] != C[0][0][0][0])
              nloop = i;
          }
  }
#pragma dvm get_actual(nloop)
  if (nloop == NL)
    ansyes(tname);
  else
    ansno(tname);
}
/* ---------------------------------------------REM4109  */
void rem4109() {

  int C[N][M][K][L];
  int nloop, ib;
  char tname[] = "REM4109";
  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[block][block][block][*]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;

#pragma dvm region local(A, B)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }

#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
    remote_access(A[N - 1][M - 1][K - 1][L - 1])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {

            B[i][j][ii][jj] = A[N - 1][M - 1][K - 1][L - 1];
          }
#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            if (B[i][j][ii][jj] != C[N - 1][M - 1][K - 1][L - 1])
              nloop = i;
          }
  }
#pragma dvm get_actual(nloop)
  if (nloop == NL)
    ansyes(tname);
  else
    ansno(tname);
}
/* ---------------------------------------------REM4110  */
void rem4110() {

  int C[N][M][K][L];
  int nloop, ib;
  char tname[] = "REM4110";
  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[block][block][*][block]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;

#pragma dvm region local(A, B)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }

#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) remote_access(A[][][][])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {

            B[i][j][ii][jj] = A[i][j][ii][jj];
          }
#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            if (B[i][j][ii][jj] != C[i][j][ii][jj])
              nloop = i;
          }
  }
#pragma dvm get_actual(nloop)
  if (nloop == NL)
    ansyes(tname);
  else
    ansno(tname);
}
/* ---------------------------------------------REM4111  */
void rem4111() {

  int C[N][M][K][L];
  int nloop, ib;
  char tname[] = "REM4111";

  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[block][*][block][block]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;

#pragma dvm region local(A, B)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }

#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
    remote_access(A[0][][][])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {

            B[i][j][ii][jj] = A[0][j][ii][jj];
          }
#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            if (B[i][j][ii][jj] != C[0][j][ii][jj])
              nloop = i;
          }
  }
#pragma dvm get_actual(nloop)
  if (nloop == NL)
    ansyes(tname);
  else
    ansno(tname);
}

/* ---------------------------------------------REM4112  */
void rem4112() {

  int C[N][M][K][L];
  int nloop, ib;
  char tname[] = "REM4112";

  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[*][block][block][block]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;

#pragma dvm region local(A, B)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }

#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
    remote_access(A[][M - 1][][])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {

            B[i][j][ii][jj] = A[i][M - 1][ii][jj];
          }
#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            if (B[i][j][ii][jj] != C[i][M - 1][ii][jj])
              nloop = i;
          }
  }
#pragma dvm get_actual(nloop)
  if (nloop == NL)
    ansyes(tname);
  else
    ansno(tname);
}
/* ---------------------------------------------REM4113  */
void rem4113() {

  int C[N][M][K][L];
  int nloop, ib;
  char tname[] = "REM4113";
  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[block][block][block][*]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;

#pragma dvm region local(A, B)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }

#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
    remote_access(A[][][K - 1][])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {

            B[i][j][ii][jj] = A[i][j][K - 1][jj];
          }
#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            if (B[i][j][ii][jj] != C[i][j][K - 1][jj])
              nloop = i;
          }
  }
#pragma dvm get_actual(nloop)
  if (nloop == NL)
    ansyes(tname);
  else
    ansno(tname);
}
/* ---------------------------------------------REM4114  */
void rem4114() {

  int C[N][M][K][L];
  int nloop, ib;
  char tname[] = "REM4114";
  int i, j, ii, jj, NN, NM, NK, NLL, NNL;

#pragma dvm array distribute[block][block][*][block]
  int B[N][M][K][L];

#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
  int A[N][M][K][L];

  NN = N;
  NM = M;
  NK = K;
  NLL = L;
  NNL = NL;
  serial4(C, NN, NM, NK, NLL, NNL);
  nloop = NL;

#pragma dvm region local(A, B)
  {

#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            A[i][j][ii][jj] = NL + i + j + ii + jj;
          }

#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
    remote_access(A[][][][L - 1])
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {

            B[i][j][ii][jj] = A[i][j][ii][L - 1];
          }
#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
    for (i = 0; i < N; i++)
      for (j = 0; j < M; j++)
        for (ii = 0; ii < K; ii++)
          for (jj = 0; jj < L; jj++) {
            if (B[i][j][ii][jj] != C[i][j][ii][L - 1])
              nloop = i;
          }
  }
#pragma dvm get_actual(nloop)
  if (nloop == NL)
    ansyes(tname);
  else
    ansno(tname);
}
void serial4(int AR[N][M][K][L], int NN, int NM, int NK, int NLL, int NNL) {
  int i, j, ii, jj;

  for (i = 0; i < NN; i++)
    for (j = 0; j < NM; j++)
      for (ii = 0; ii < NK; ii++)
        for (jj = 0; jj < NLL; jj++)

        {
          AR[i][j][ii][jj] = NNL + i + j + ii + jj;
        }
}
void ansyes(const char name[]) {
  printf("%s  -  complete\n", name);
  return;
}
void ansno(const char name[]) {
  printf("%s  -  ***error\n", name);
  return;
}
