#include <perms.h>
int _imp_mainep(int _imp_argc, char **_imp_argv) {
  _imp_enter();
  typedef struct RA {
    int B[500 - 1 + 1];
    int A;

  } RA;

  typedef struct ERA {
    _imp_string C;
    int B[4 - 1 + 1];
    int A;

  } ERA;

  typedef struct POINTER {
    int A;
    POINTER *LINK;

  } POINTER;

  typedef struct CELL {
    int A;

  } CELL;
  int X;
  int A;
  int J;
  int K;
  int SUB;
  RA RECA;
  RA RECB;
  RA RECC[1 - -1 + 1];
  int INT1[3 - 1 + 1][15 - 11 + 1];
  int INT2[5 - 1 + 1];
  _imp_string S1;
  _imp_string S2;
  _imp_string S3;
  _imp_string SARRAY[110 - 100 + 1];
  int ERROR;
  CELL SELL;
  CELL *PCELL;
  POINTER *PTR;
  static int FAILURES = 0;
  auto void PASS(void) {
    _imp_enter();
    PRINTSTRING(_imp_str_literal("Pass: "));
    _imp_leave();
  }
  auto void FAIL(void) {
    _imp_enter();
    PRINTSTRING(_imp_str_literal("FAIL: "));
    FAILURES = FAILURES + 1;
    _imp_leave();
  }
  auto void INC(int D);
  auto void INC2(int D) {
    _imp_enter();
    auto void INC3(int D) {
      _imp_enter();
      auto void INC4(int D) {
        _imp_enter();
        auto void INC5(int D) {
          _imp_enter();
          if (D > 400) {
            PRINTSTRING(
                _imp_str_literal("Pass: Deeply recursed, nested routine."));
            NEWLINE();
            {
              _imp_leave();
              return;
            }
          }
          INC(D + 1);
          _imp_leave();
        }
        INC5(D + 1);
        _imp_leave();
      }
      INC4(D + 1);
      _imp_leave();
    }
    INC3(D + 1);
    _imp_leave();
  }
  auto void INC(int D) {
    _imp_enter();
    INC2(D + 1);
    _imp_leave();
  }
  auto void PARAMS(int A, int *B, int C, int *D, _imp_string E, _imp_string *F,
                   _imp_string G, _imp_string *H, int *J, int *K,
                   _imp_string *L, RA RECA, RA *RECB, RA *RECC) {
    _imp_enter();
    int W;
    B = A + C + D;
    A = A * 10;
    *F = _imp_join(E, G);
    E = G;
    for (C = 1; C != 5 + 1; C += 1) J = K;
    for (C = 1; C != 5 + 1; C += 1) J = 6 - K;
    for (C = 11; C != 15 + 1; C += 1) J = 20;
    D = 0;
    for (W = 11; W != 15 + 1; W += 1) D = D + J + J + J;
    *H = _imp_str_literal("");
    for (W = 100; W != 110 + 1; W += 1) *H = _imp_join(H, L);
    for (W = 0; W != 10 + 1; W += 1) /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
      *L(/*index missing*/) = MISSING_RHS;
    RECB = RECA;
    RECA = 0;
    for (W = -1; W != 1 + 1; W += 1) {
      RECC[W].A = W;
      for (C = 1; C != 500 + 1; C += 1) RECC[W].B[C] = C;
    }

    _imp_leave();
  }
  auto void STATICDATA(int N, int *E) {
    _imp_enter();
    int I;
    int SUM = 0;
    static int J = 1;
    static int K = 3;
    static _imp_string S = _imp_str_literal("1");
    static int INT[100 - 1 + 1] = {1};
    /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ if (J != N || K != 3 * N ||
                                                  S != ())
      E = E + 1;
    for (I = 1; I != 100 + 1; I += 1) SUM = SUM + INT[I];
    if (SUM != 100 * N) E = E + 1;
    J = J + 1;
    K = J * 3; /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    S = MISSING_RHS;
    for (I = 1; I != 100 + 1; I += 1) INT[I] = J;
    _imp_leave();
  }
  auto void P5(int N, int *M) {
    _imp_enter();
    if (N == 0) {
      *M = 0;
      {
        _imp_leave();
        return;
      }
    }
    P5(N - 1, M);
    *M = M + 1;
    _imp_leave();
  }
  auto void P2(int N, int *M) {
    _imp_enter();
    *M = M + 1;
    if (N == 1) {
      _imp_leave();
      return;
    }
    *M = M + 1;
    if (N == 2) {
      _imp_leave();
      return;
    }
    *M = M + 1;
    {
      _imp_leave();
      return;
    }
    *M = M + 1;
    _imp_leave();
  }
  auto void P6(int N, int *M);
  auto void P7(int N, int *M) {
    _imp_enter();
    int L;
    if (N == 0) {
      _imp_leave();
      return;
    }
    L = N - 1;
    P6(L, M);
    *M = M + 1;
    _imp_leave();
  }
  auto void P6(int N, int *M) {
    _imp_enter();
    int K;
    if (N == 0) {
      _imp_leave();
      return;
    }
    K = N - 1;
    P7(K, M);
    *M = M + 1;
    _imp_leave();
  }
  auto int SIDEEFFECT(int A) {
    _imp_enter();
    J = A * 10;
    return (A);
    _imp_leave();
  }
  auto int FACTORIAL(int N) {
    _imp_enter();
    if (N <= 0) return (1);
    return (N * FACTORIAL(N - 1));
    _imp_leave();
  }
  auto int EVEN(int N) {
    _imp_enter();
    if (N / 2 * 2 == N) return (1);
    return (0);
    _imp_leave();
  }
  auto _imp_string *SMAP(int CHOICE) {
    _imp_enter();
    if (CHOICE == 2) return (&S2);
    if (CHOICE == 1) return (&S1);
    return (&SARRAY[105]);
    _imp_leave();
  }
  auto int *INTMAP(void) {
    _imp_enter();
    if (J < K) return (&J);
    if (J == K) return (&A);
    return (&K);
    _imp_leave();
  }
  OPENOUTPUT(1, CLIPARAM());
  SELECTOUTPUT(1);
  X = 1;
  A = 0;
  ERROR = 0;
  {
    int X = 2;
    int Y;
    int B;
    B = A + 1;
    Y = X * 2;
    {
      int X = 5;
      int C;
      C = B + 1;
      if (Y == 4 && X == 5)
        PASS();
      else
        FAIL();
      PRINTSTRING(_imp_str_literal("Nesting at level TWO."));
      NEWLINE();
      {
        int Z;
        int D;
        D = C + 1;
        Z = 6;
        {
          int W;
          int E;
          E = D + 1;
          W = 7;
          {
            int V;
            int F;
            F = E + 1;
            V = W + X + Y + Z;
            {
              int T;
              int G;
              G = F + 1;
              T = V + X;
              if (T == 27 && V == 22 && W == 7 && X == 5 && G == 6)
                PASS();
              else
                FAIL();
              PRINTSTRING(
                  _imp_str_literal("Scoping of variables at level SIX"));
              NEWLINE();
            }
            if (V != 22) ERROR = ERROR + 1;
          }
          if (W != 7) ERROR = ERROR + 1;
        }
        if (Z != 6) ERROR = ERROR + 1;
      }
      if (X != 5) ERROR = ERROR + 1;
    }
    if (X != 2) ERROR = ERROR + 1;
  }
  if (ERROR == 0)
    PASS();
  else
    FAIL();
  PRINTSTRING(
      _imp_str_literal("Scoping of variables on leaving nested blocks."));
  NEWLINES(3);
  K = 6;
  X = 5 * K;
  {
    int J;
    int SUM = 0;
    int INT[X - 1 + 1];
    for (J = 1; J != X + 1; J += 1) {
      INT[J] = J;
      SUM = SUM + INT[J];
    }
    if (SUM == X * (X + 1) / 2)
      PASS();
    else
      FAIL();
    PRINTSTRING(_imp_str_literal("'Dynamic' array bounds within a block."));
    NEWLINE();
  }
  NEWLINES(2);
  for (J = 1; J != 5 + 1; J += 1) INT2[J] = J;
  for (J = 0; J != 10 + 1; J += 1) /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
    SARRAY[100 + J] = MISSING_RHS;
  RECA.A = 1000;
  for (K = 1; K != 500 + 1; K += 1) RECA.B[K] = K;
  RECB.A = 2000;
  for (K = 1; K != 500 + 1; K += 1) RECB.B[K] = 1;
  for (K = -1; K != 1 + 1; K += 1) {
    for (A = 1; A != 500 + 1; A += 1) RECC[K].B[A] = 1;
    RECC[K].A = 10 + K;
  }
  J = 10;
  A = 20;
  S1 = _imp_str_literal("BACK");
  S3 = _imp_str_literal("NONSENSE");
  PARAMS(J, X, 20, A, _imp_str_literal("FRONT"), S2, S1, S3, INT1, INT2, SARRAY,
         RECA, RECB, RECC);
  ERROR = 0;
  if (J != 10) ERROR = ERROR + 1;
  if (X != 50) ERROR = ERROR + 1;
  if (S2 != _imp_str_literal("FRONTBACK")) ERROR = ERROR + 1;
  if (S1 != _imp_str_literal("BACK")) ERROR = ERROR + 1;
  if (S3 != _imp_str_literal("abcdefghijk")) ERROR = ERROR + 1;
  if (A != 130) ERROR = ERROR + 1;
  if (RECA.A != 1000) ERROR = ERROR + 1;
  if (RECB.A != 1000) ERROR = ERROR + 1;
  J = 0;
  for (K = 11; K != 15 + 1; K += 1)
    J = J + INT1[1][K] + INT1[2][K] + INT1[3][K];
  if (J != 130) ERROR = ERROR + 1;
  S1 = _imp_str_literal("");
  for (K = 100; K != 110 + 1; K += 1) S1 = _imp_join(S1, SARRAY[K]);
  if (S1 != _imp_str_literal("ABCDEFGHIJK")) ERROR = ERROR + 1;
  J = 0;
  for (K = -1; K != 1 + 1; K += 1) J = RECC[K].A + J;
  if (J != 0) ERROR = ERROR + 1;
  if (ERROR == 0)
    PASS();
  else
    FAIL();
  PRINTSTRING(_imp_str_literal("Value and %Name parameter passing."));
  NEWLINE();
  ERROR = 0;
  K = 0;
  for (J = 1; J != 3 + 1; J += 1) {
    P2(J, K);
    if (K != J * (J + 1) / 2) ERROR = ERROR + 1;
  }
  if (ERROR == 0)
    PASS();
  else
    FAIL();
  PRINTSTRING(
      _imp_str_literal("Conditional and normal %RETURN from a routine."));
  NEWLINE();
  ERROR = 0;
  if (FACTORIAL(0) != 1) ERROR = ERROR + 1;
  if (FACTORIAL(4) != 24) ERROR = ERROR + 1;
  if (FACTORIAL(10) != 10 * FACTORIAL(8) * 9) ERROR = ERROR + 1;
  if (ERROR == 0)
    PASS();
  else
    FAIL();
  PRINTSTRING(
      _imp_str_literal("Conditional and normal %RESULT from a function."));
  NEWLINE();
  A = FACTORIAL(FACTORIAL(FACTORIAL(FACTORIAL(3)) - 713) - 5032);
  if (A == 40320)
    PASS();
  else
    FAIL();
  PRINTSTRING(
      _imp_str_literal("Nested function calls as parameter to a function."));
  NEWLINE();
  P5(100, K);
  if (K == 100)
    PASS();
  else
    FAIL();
  PRINTSTRING(_imp_str_literal("Simple recursion in routines."));
  NEWLINE();
  K = 0;
  P7(100, K);
  if (K == 100)
    PASS();
  else
    FAIL();
  PRINTSTRING(_imp_str_literal("Mutual recursion in routines."));
  NEWLINE();
  K = SIDEEFFECT(10);
  if (K == 10 && J == 100)
    PASS();
  else
    FAIL();
  PRINTSTRING(_imp_str_literal("Side effects caused by functions."));
  NEWLINE();
  ERROR = 0;
  for (J = 1; J != 100 + 1; J += 1) STATICDATA(J, ERROR);
  if (ERROR == 0)
    PASS();
  else
    FAIL();
  PRINTSTRING(
      _imp_str_literal("%OWN Data preserved between routine invocations."));
  NEWLINE();
  ERROR = 0;
  if (EVEN(7)) ERROR = ERROR + 1;
  if (!EVEN(30)) ERROR = ERROR + 1;
  if (ERROR == 0)
    PASS();
  else
    FAIL();
  PRINTSTRING(
      _imp_str_literal("%Predicates successfully used in conditionals."));
  NEWLINE();
  INC(1);
  NEWLINES(2);
  J = 3;
  K = 4;
  A = 5;
  ERROR = 0;
  *INTMAP() = 6;
  if (J != 6 || K != 4 || A != 5) ERROR = ERROR + 1;
  *INTMAP() = 6;
  if (J != 6 || 6 != K || A != 5) ERROR = ERROR + 1;
  *INTMAP() = 8;
  if (J != K || K != 6 || A != 8) ERROR = ERROR + 1;
  if (INTMAP() != 8) ERROR = ERROR + 1;
  if (ERROR == 0)
    PASS();
  else
    FAIL();
  PRINTSTRING(
      _imp_str_literal("Conditional and unconditional %RESULT in a MAP."));
  NEWLINE();
  ERROR = 0;
  S1 = _imp_str_literal("ONE");
  S2 = _imp_str_literal("TWO");
  SARRAY[105] = _imp_str_literal("Help");
  S3 = SMAP(1);
  if (S3 != _imp_str_literal("ONE")) {
    ERROR = ERROR + 1;
    WRITE(1, 1);
  }
  if (S2 != SMAP(2)) {
    ERROR = ERROR + 1;
    WRITE(2, 1);
  }
  *SMAP(9) = _imp_str_literal("Dynamic");
  if (SARRAY[105] != _imp_str_literal("Dynamic")) {
    ERROR = ERROR + 1;
    WRITE(3, 1);
  }
  if (ERROR == 0)
    PASS();
  else
    FAIL();
  PRINTSTRING(_imp_str_literal("Pointing at local %Strings using a MAP."));
  NEWLINE();
  SELECTOUTPUT(0);
  WRITE(FAILURES, 1);
  PRINTSTRING(_imp_str_literal(" failure(s)"));
  NEWLINE();
  _imp_leave();
  exit(0);
  return (0);
}