TEST:
	X[i] = i where N > i >= 0

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = N - 1; i >= 0; --i)
      {
          int _val_2 = i;
          X[i] = _val_2;
      }
}
DONE

TEST:
	X[i] = i where N >= i > 0

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = N; i > 0; --i)
      {
          int _val_2 = i;
          X[i] = _val_2;
      }
}
DONE

TEST:
	X[i] = i where N >= i >= 0

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = N; i >= 0; --i)
      {
          int _val_2 = i;
          X[i] = _val_2;
      }
}
DONE

TEST:
	X[i] = i where N > i > 0

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = N - 1; i > 0; --i)
      {
          int _val_2 = i;
          X[i] = _val_2;
      }
}
DONE


TEST:
  X[i] = -(i+i) where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_5 = -(i + i);
          X[i] = _val_5;
      }
}
DONE

TEST:
  X[i] = i+i*i where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_6 = (i + (i * i));
          X[i] = _val_6;
      }
}
DONE

TEST:
  X[i] = i*i+i where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_6 = ((i * i) + i);
          X[i] = _val_6;
      }
}
DONE

TEST:
  X[i] = i-i*i where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_6 = (i - (i * i));
          X[i] = _val_6;
      }
}
DONE

TEST:
  X[i] = i*i-i where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_6 = ((i * i) - i);
          X[i] = _val_6;
      }
}
DONE

TEST:
  X[i] = i*i*i where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_6 = ((i * i) * i);
          X[i] = _val_6;
      }
}
DONE

TEST:
  X[i] = i+i/i where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_6 = (i + (i / i));
          X[i] = _val_6;
      }
}
DONE

TEST:
  X[i] = i/i+i where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_6 = ((i / i) + i);
          X[i] = _val_6;
      }
}
DONE

TEST:
  X[i] = i-i/i where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_6 = (i - (i / i));
          X[i] = _val_6;
      }
}
DONE

RESULT:
  X[i] = ((i / i) - i) where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_6 = ((i / i) - i);
          X[i] = _val_6;
      }
}
DONE

TEST:
  X[i] = i*i/i where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_6 = ((i * i) / i);
          X[i] = _val_6;
      }
}
DONE

TEST:
  X[i] = d() where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
extern int d ();
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_2 = d ();
          X[i] = _val_2;
      }
}
DONE

TEST:
  X[i] = d(i) where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
extern int d (int);
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_3 = d (i);
          X[i] = _val_3;
      }
}
DONE

TEST:
   X[i] = d(i,i) where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
extern int d (int, int);
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_4 = d (i, i);
          X[i] = _val_4;
      }
}
DONE

TEST:
  X[i] = d(i/i) where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
extern int d (int);
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_5 = d ((i / i));
          X[i] = _val_5;
      }
}
DONE

TEST:
globals fun d () : int
in X[i] = d() where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
extern int d ();
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_3 = d ();
          X[i] = _val_3;
      }
}
DONE

TEST:
globals fun d(int) : int
in X[i] = d(i) where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
extern int d (int);
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_4 = d (i);
          X[i] = _val_4;
      }
}
DONE

TEST:
globals fun d(int,int) : int
in X[i] = d(i,i) where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
extern int d (int, int);
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_5 = d (i, i);
          X[i] = _val_5;
      }
}
DONE


TEST:
globals fun d () : float
in X[i] = d() where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
extern double d ();
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_3 = d ();
          X[i] = _val_3;
      }
}
DONE

TEST:
globals fun d(int) : float
in X[i] = d(i) where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
extern double d (int);
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_4 = d (i);
          X[i] = _val_4;
      }
}
DONE

TEST:
globals fun d(int,int) : char
in X[i] = d(i,i) where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
extern char d (int, int);
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_5 = d (i, i);
          X[i] = _val_5;
      }
}
DONE

TEST:
globals fun d(float,char) : char
in X[i] = d(i,i) where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
extern char d (double, char);
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_5 = d (i, i);
          X[i] = _val_5;
      }
}
DONE


TEST:
  X[i] = 5 where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_2 = 5;
          X[i] = _val_2;
      }
}
DONE

TEST:
  X[i] = i where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_2 = i;
          X[i] = _val_2;
      }
}
DONE

TEST:
  X[i] = y[i] where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N, int y[])
{
    for (int i = 0; i < N; ++i)
      {
          int _val_3 = y[i];
          X[i] = _val_3;
      }
}
DONE

TEST:
  X[i] = y[i,3,5] where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N, dprog::Matrix < int >&y)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_5 = y.cell (i, 3, 5);
          X[i] = _val_5;
      }
}
DONE

TEST:
  X[i] = min{5 where 0 <= k < i} where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_9 = INT_MAX;
          for (int k = 0; k < i; ++k)
            {
                int _val_2 = 5;
                _val_9 = std::min (_val_9, _val_2);
            }
          X[i] = _val_9;
      }
}
DONE

TEST:
  X[i] = min{5} where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_5 = INT_MAX;
          if (1)
            {
                int _val_2 = 5;
                _val_5 = std::min (_val_5, _val_2);
            }
          X[i] = _val_5;
      }
}
DONE

TEST:
  X[i] = min{5 when true} where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_5 = INT_MAX;
          if (1)
            {
                int _val_2 = 5;
                _val_5 = std::min (_val_5, _val_2);
            }
          X[i] = _val_5;
      }
}
DONE

TEST:
  X[i] = min{5 when 2 < 1} where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_8 = INT_MAX;
          if ((2 < 1))
            {
                int _val_2 = 5;
                _val_8 = std::min (_val_8, _val_2);
            }
          X[i] = _val_8;
      }
}
DONE

TEST:
  X[i] = min{5 when 2 < 1, 6 when 2 > 1} where 0 <= i < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_15 = INT_MAX;
          if ((2 < 1))
            {
                int _val_2 = 5;
                _val_15 = std::min (_val_15, _val_2);
            }
          if ((2 > 1))
            {
                int _val_9 = 6;
                _val_15 = std::min (_val_15, _val_9);
            }
          X[i] = _val_15;
      }
}
DONE

TEST:
  X[i,j] = min{5} where 0 <= i < N and 0 <= j < M

RESULT:
#include <cxx_dprog.hh>
void
fill_table (dprog::Matrix2 < int >&X, int N, int M)
{
    for (int i = 0; i < N; ++i)
      {
          for (int j = 0; j < M; ++j)
            {
                int _val_5 = INT_MAX;
                if (1)
                  {
                      int _val_2 = 5;
                      _val_5 = std::min (_val_5, _val_2);
                  }
                X.cell (i, j) = _val_5;
            }
      }
}
DONE

TEST:
  X[i] = i Y[j] = j where 0 <= i < N and 0 <= j < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int Y[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          for (int j = 0; j < N; ++j)
            {
                int _val_2 = i;
                X[i] = _val_2;
                int _val_5 = j;
                Y[j] = _val_5;
            }
      }
}
DONE

TEST:
      X[i] = select{0 when i < j, 1}
      Y[j] = select{0 when i < j, 1}
  where 0 <= i < N and 0 <= j < N

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int X[], int Y[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          for (int j = 0; j < N; ++j)
            {
                int _val_12;
                if ((i < j))
                  {
                      int _val_2 = 0;
                      _val_12 = _val_2;
                  }
                else if (1)
                  {
                      int _val_9 = 1;
                      _val_12 = _val_9;
                  }
                else
                  {
                      assert (0);
                  }
                X[i] = _val_12;
                int _val_25;
                if ((i < j))
                  {
                      int _val_15 = 0;
                      _val_25 = _val_15;
                  }
                else if (1)
                  {
                      int _val_22 = 1;
                      _val_25 = _val_22;
                  }
                else
                  {
                      assert (0);
                  }
                Y[j] = _val_25;
            }
      }
}
DONE

TEST:
  float X[i,j] = min{5} where 0 <= i < N and 0 <= j < M

RESULT:
#include <cxx_dprog.hh>
void
fill_table (dprog::Matrix2 < double >&X, int N, int M)
{
    for (int i = 0; i < N; ++i)
      {
          for (int j = 0; j < M; ++j)
            {
                int _val_5 = INT_MAX;
                if (1)
                  {
                      int _val_2 = 5;
                      _val_5 = std::min (_val_5, _val_2);
                  }
                X.cell (i, j) = _val_5;
            }
      }
}
DONE

TEST:
  char X[i,j] = min{5} where 0 <= i < N and 0 <= j < M

RESULT:
#include <cxx_dprog.hh>
void
fill_table (dprog::Matrix2 < char >&X, int N, int M)
{
    for (int i = 0; i < N; ++i)
      {
          for (int j = 0; j < M; ++j)
            {
                int _val_5 = INT_MAX;
                if (1)
                  {
                      int _val_2 = 5;
                      _val_5 = std::min (_val_5, _val_2);
                  }
                X.cell (i, j) = _val_5;
            }
      }
}
DONE




TEST:
globals
	val x : int
in
  	X[i] = x where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
extern int x;
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_3 = x;
          X[i] = _val_3;
      }
}
DONE

TEST:
parameters
	val x : int
in
  	X[i] = x where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int x, int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_3 = x;
          X[i] = _val_3;
      }
}
DONE

TEST:
globals
	matrix F[N] : int
in
  	X[i] = F[i] where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
extern int F[];
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_5 = F[i];
          X[i] = _val_5;
      }
}
DONE

TEST:
parameters
	matrix F[N] : int
in
  	X[i] = F[i] where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
void
fill_table (int F[], int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_5 = F[i];
          X[i] = _val_5;
      }
}
DONE

TEST:
globals
	matrix F[N,N] : int
in
  	X[i] = F[i,i] where 0 <= i < N
end

RESULT:	;; the indentation is weired because `indent' chokes on namespaces
#include <cxx_dprog.hh>
extern
dprog::Matrix2 < int >
    F;
void
fill_table (int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int
              _val_7 =
              F.
              cell (i, i);
          X[i] = _val_7;
      }
}
DONE

TEST:
parameters
	matrix F[N,N] : int
in
  	X[i] = F[i,i] where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
void
fill_table (dprog::Matrix2 < int >&F, int X[], int N)
{
    for (int i = 0; i < N; ++i)
      {
          int _val_7 = F.cell (i, i);
          X[i] = _val_7;
      }
}
DONE

TEST:
parameters
	matrix F[N,N] : int
locals
	matrix Y[N] : int
in
	Y[i] = F[i,0]
  	X[i] = F[0,i] + Y[i]
	where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
void
fill_table (dprog::Matrix2 < int >&F, int X[], int N)
{
    int Y[N];
    for (int i = 0; i < N; ++i)
      {
          int _val_9 = F.cell (i, 0);
          Y[i] = _val_9;
          int _val_17 = (F.cell (0, i) + Y[i]);
          X[i] = _val_17;
      }
}
DONE

TEST:
parameters
	matrix F[N,N] : int
locals
	matrix Y[N,N] : int
in
	Y[i,i] = F[i,0]
  	X[i] = F[0,i] + Y[i,i]
	where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
void
fill_table (dprog::Matrix2 < int >&F, int X[], int N)
{
    Matrix2 < int >Y (N, N);
    for (int i = 0; i < N; ++i)
      {
          int _val_10 = F.cell (i, 0);
          Y.cell (i, i) = _val_10;
          int _val_19 = (F.cell (0, i) + Y.cell (i, i));
          X[i] = _val_19;
      }
}
DONE

TEST:
parameters
	matrix F[N,N] : int
locals
	matrix Y[N,N,N] : int
in
	Y[i,i,i] = F[i,0]
  	X[i] = F[0,i] + Y[i,i,i]
	where 0 <= i < N
end

RESULT:
#include <cxx_dprog.hh>
void
fill_table (dprog::Matrix2 < int >&F, int X[], int N)
{
    Matrix < int >Y (3, N, N, N);
    for (int i = 0; i < N; ++i)
      {
          int _val_11 = F.cell (i, 0);
          Y.cell (i, i, i) = _val_11;
          int _val_21 = (F.cell (0, i) + Y.cell (i, i, i));
          X[i] = _val_21;
      }
}
DONE