#include <perms.h>
int _imp_mainep(int _imp_argc, char **_imp_argv) {
  _imp_enter();
  const int NMAX = 20;
  auto void TESTMATRIX(float *A, int N);
  auto void HOUSEHOLDER(float *A, float *W, int N, int K);
  int I;
  float A[NMAX - 1 + 1][NMAX - 1 + 1];
  float W[NMAX - 1 + 1];
  TESTMATRIX(A, NMAX); /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
  ;
  HOUSEHOLDER(A, W, NMAX, 1);
  for (I = 1; I != NMAX + 1; I += 1) {
    PRINTFL(W, 8);
    NEWLINE();
  }
  /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/;
      /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
  ;
  exit(0);
  auto void TESTMATRIX(float *A, int N) {
    _imp_enter();
    int I;
    int J;
    float T;
    float C;
    float D;
    float F;
    C = N * (N + 1) * (2 * N - 5) / 6;
    D = 1 / C;
    *A(/*index missing*/) = -D;
    for (I = 1; I != N - 1 + 1; I += 1) {
      F = I;
      *A(/*index missing*/) = D * F;
      *A(/*index missing*/) = A;
      *A(/*index missing*/) = D * (C - REXP(F, 2));
      for (J = 1; J != I - 1 + 1; J += 1) {
        T = J;
        *A(/*index missing*/) = -D * F * T;
        *A(/*index missing*/) = A;
      }
    }

    _imp_leave();
  }
  auto void HOUSEHOLDER(float *A, float *W, int N, int K) {
    _imp_enter();
    auto void HOUSEHOLDERTRIDIAGONALISATION(float *A, float *B, float *C,
                                            int N);
    auto void TRIDIBISECTION(float *C, float *B, float *W, int N, float *NORM);
    auto void TRIDIINVERSEITERATION(float *C, float *B, float *W, float *Z,
                                    int N, float NORM);
    auto void BACKTRANSFORMATION(float *A, float *B, float *Z, int N);
    float Z[N - 1 + 1][N - 1 + 1];
    float B[N - 1 + 1], C[N - 1 + 1];
    int I;
    int J;
    float NORM;
    const float TEN = 10;
    HOUSEHOLDERTRIDIAGONALISATION(A, B, C, N);
    TRIDIBISECTION(C, B, W, N, NORM);
    if (K == 2) {
      _imp_leave();
      return;
    }
    TRIDIINVERSEITERATION(C, B, W, Z, N, NORM);
    BACKTRANSFORMATION(A, B, Z, N);
    for (I = 1; I != N + 1; I += 1) {
      for (J = 1; J != N + 1; J += 1) {
        *A(/*index missing*/) = Z;
      }
    }
    {
      _imp_leave();
      return;
    }
    auto void HOUSEHOLDERTRIDIAGONALISATION(float *A, float *B, float *C,
                                            int N) {
      _imp_enter();
      int I;
      int J;
      int K;
      float AI;
      float SIGMA;
      float H;
      float BJ;
      float BIGK;
      float BI;
      float Q[N - 1 - 1 + 1];
      for (I = N; I != 3 + -1; I += -1) {
        SIGMA = 0;
        for (K = 1; K != I - 1 + 1; K += 1) {
          SIGMA = SIGMA + REXP(A, 2);
        }
        AI = A;
        if (AI >= 0) /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
          BI = -();
        else /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/
          BI = MISSING_RHS;
        *B(/*index missing*/) = BI;
        if (BI == 0) continue;
        H = SIGMA - AI * BI;
        *A(/*index missing*/) = AI - BI;
        for (J = I - 1; J != 1 + -1; J += -1) {
          BJ = 0;
          for (K = I - 1; K != J + -1; K += -1) {
            BJ = BJ + A * A;
          }
          for (K = J - 1; K != 1 + -1; K += -1) {
            BJ = BJ + A * A;
          }
          Q[J] = BJ / H;
        }
        BIGK = 0;
        for (J = I - 1; J != 1 + -1; J += -1) {
          BIGK = BIGK + A * Q[J];
        }
        BIGK = BIGK / (2 * H);
        for (J = I - 1; J != 1 + -1; J += -1) {
          Q[J] = Q[J] - BIGK * A;
        }
        for (J = I - 1; J != 1 + -1; J += -1) {
          for (K = J; K != 1 + -1; K += -1) {
            *A(/*index missing*/) = A - A * Q[K] - A * Q[J];
          }
        }
      }
      for (I = N; I != 1 + -1; I += -1) {
        *C(/*index missing*/) = A;
      }
      *B(/*index missing*/) = A;
      *B(/*index missing*/) = 0;
      _imp_leave();
    }
    auto void TRIDIINVERSEITERATION(float *C, float *B, float *W, float *Z,
                                    int N, float NORM) {
      _imp_enter();
      int I;
      int J;
      float BI;
      float BI1;
      float Z1;
      float LAMBDA;
      float U;
      float S;
      float V;
      float H;
      float EPS;
      float ETA;
      float M[N - 1 + 1], P[N - 1 + 1], Q[N - 1 + 1], R[N - 1 + 1],
          INT[N - 1 + 1];
      float X[N + 2 - 1 + 1];
      LAMBDA = NORM;
      EPS = NORM / (REXP(TEN, 11));
      for (J = 1; J != N + 1; J += 1) {
        LAMBDA = LAMBDA - EPS;
        if (W < LAMBDA) LAMBDA = W;
        U = C - LAMBDA;
        V = B;
        if (V == 0) V = EPS;
        for (I = 1; I != N - 1 + 1; I += 1) {
          BI = B;
          if (BI == 0) BI = EPS;
          BI1 = B;
          if (BI1 == 0) BI1 = EPS;
          if (MOD(U) > MOD(BI)) {
            M[I + 1] = BI / U;
            P[I] = U;
            Q[I] = V;
            R[I] = 0;
            U = C - LAMBDA - M[I + 1] * V;
            V = BI1;
            INT[I + 1] = -1;

          } else {
            M[I + 1] = U / BI;
            if (M[I + 1] == 0 && BI <= EPS) M[I + 1] = 1;
            P[I] = BI;
            Q[I] = C - LAMBDA;
            R[I] = BI1;
            U = V - M[I + 1] * Q[I];
            V = -M[I + 1] * R[I];
            INT[I + 1] = 1;
          }
        }
        P[N] = U;
        Q[N] = 0;
        R[N] = 0;
        X[N + 1] = 0;
        X[N + 2] = 0;
        H = 0;
        ETA = 1 / N;
        for (I = N; I != 1 + -1; I += -1) {
          U = ETA - Q[I] * X[I + 1] - R[I] * X[I + 2];
          if (P[I] != 0)
            X[I] = U / P[I];
          else
            X[I] = U / EPS;
          H = H + MOD(X[I]);
        }
        H = 1 / H;
        for (I = 1; I != N + 1; I += 1) {
          X[I] = X[I] * H;
        }
        for (I = 2; I != N + 1; I += 1) {
          if (INT[I] <= 0)
            X[I] = X[I] - M[I] * X[I - 1];
          else {
            U = X[I - 1];
            X[I - 1] = X[I];
            X[I] = U - M[I] * X[I - 1];
          }
        }
        H = 0;
        for (I = N; I != 1 + -1; I += -1) {
          U = X[I] - Q[I] * X[I + 1] - R[I] * X[I + 2];
          if (P[I] == 0)
            X[I] = U / EPS;
          else
            X[I] = U / P[I];
          H = H + REXP(X[I], 2);
        }
        /*ERROR: name_sym_idx is -1!*/ /*C_NAME*/ H = 1 / ();
        for (I = 1; I != N + 1; I += 1) {
          *Z(/*index missing*/) = X[I] * H;
        }
      }

      _imp_leave();
    }
    auto void TRIDIBISECTION(float *C, float *B, float *W, int N, float *NORM) {
      _imp_enter();
      float L;
      float G;
      float H;
      float LAMBDA;
      float P1;
      float Q1;
      float Y;
      int I;
      int J;
      int K;
      int A1;
      int A2;
      float P[N - 1 + 1];
      P[1] = 0;
      *NORM = MOD(C) + MOD(B);
      for (I = 2; I != N + 1; I += 1) {
        L = MOD(B) + MOD(C) + MOD(B);
        if (L > NORM) *NORM = 1;
      }
      for (I = 1; I != N - 1 + 1; I += 1) {
        if (B == 0)
          P[I + 1] = NORM * NORM / REXP(TEN, 23);
        else
          P[I + 1] = REXP(B, 2);
      }
      for (K = 1; K != N + 1; K += 1) {
        G = NORM;
        H = -NORM;
        for (J = 1; J != 39 + 1; J += 1) {
          LAMBDA = (G + H) / 2;
          P1 = 0;
          Q1 = 1;
          A1 = 0;
          for (I = 1; I != N + 1; I += 1) {
            Y = (C - LAMBDA) * Q1 - P[I] * P1;
            P1 = Q1;
            Q1 = Y;
            if ((P1 >= 0 && Q1 >= 0) || (P1 < 0 && Q1 < 0)) A1 = A1 + 1;
          }
          if (Q1 == 0 && P1 > 0) A1 = A1 - 1;
          if (A1 >= K)
            H = LAMBDA;
          else
            G = LAMBDA;
        }
        *W(/*index missing*/) = (G + H) / 2;
      }
      {
        _imp_leave();
        return;
      }
      _imp_leave();
    }
    auto void BACKTRANSFORMATION(float *A, float *B, float *Z, int N) {
      _imp_enter();
      int I;
      int J;
      int K;
      float S;
      for (J = 1; J != N + 1; J += 1) {
        for (K = 3; K != N + 1; K += 1) {
          if (B == 0) continue;
          S = 0;
          for (I = 1; I != K - 1 + 1; I += 1) {
            S = S + A * Z;
          }
          S = S / (B * A);
          for (I = 1; I != K - 1 + 1; I += 1) {
            *Z(/*index missing*/) = Z + S * A;
          }
        }
      }

      _imp_leave();
    }

    _imp_leave();
  }

  _imp_leave();
  exit(0);
  return (0);
}