(* Test: coverage of arithmetic operations and relations *)

UNSAFE MODULE Main;

TYPE
  A = UNTRACED REF INTEGER;
  SE = {sa, sb, sc, sd, se};
  S = SET OF SE;

VAR
  i, j, k: INTEGER;
  l, m, n: CARDINAL;
  x, y, z: REAL;
  X, Y, Z: LONGREAL;
  a, b, c : A;
  e, f, g : SE;
  s, t, u : S;
  B, C, D : BOOLEAN;

BEGIN

i := + j;           
l := + m;            
x := + y;           
X := + Y;           
CONST 
  i : INTEGER   = + (-23);
  l : CARDINAL  = + 23;
  x : REAL      = + 234.34;
  X : LONGREAL  = + 234.234d3;
  BEGIN END;

i := j + k;            
l := m + n;            
x := z + y;            
X := X + Y;            
a := b + 23;           
u := s + t;            
CONST
  i : INTEGER  = 23 + (-34);
  l : CARDINAL = (-34) + 123;
  x : REAL     = 4.0 + 45.34;
  X : LONGREAL = 23.34d1 + 234.45d-1;
  u : S        = S{SE.sa, SE.sb} + S{SE.sc ,SE.sb};
   BEGIN END;

i := - j;              
l := - m;              
x := - y;              
X := - Y;              
CONST
  i : INTEGER  = - 23;
  l : CARDINAL = - (-23);
  x : REAL     = - 234.34;
  X : LONGREAL = - 234.234d3;
  BEGIN END;

i := j - k;            
l := m - n;            
x := z - y;            
X := X - Y;            
a := b - 21;
i := b - c;
u := s - t;            
CONST
  i : INTEGER  = 23 - 34;
  l : CARDINAL = 72 - 23;
  x : REAL     = 4.0 - 45.34;
  X : LONGREAL = 23.34d1 - 234.45d-1;
  u : S        = S{SE.sa, SE.sb} - S{SE.sc ,SE.sb};
  BEGIN END;

i := j * k;            
l := m * n;            
x := z * y;            
X := X * Y;            
u := s * t;            
CONST
  i : INTEGER  = 23 * (-34);
  l : CARDINAL = 34 * 23;
  x : REAL     = 4.0 * 45.34;
  X : LONGREAL = 23.34d1 * 234.45d-1;
  u : S        = S{SE.sa, SE.sb} * S{SE.sc ,SE.sb};
  BEGIN END;

x := z / y;            
X := X / Y;            
u := s / t;            
CONST 
  x : REAL     = 4.0 / 45.34;
  X : LONGREAL = 23.34d1 / 234.45d-1;
  u : S        = S{SE.sa, SE.sb} / S{SE.sc ,SE.sb};
  BEGIN END;

i := j DIV k;            
l := m DIV n;            
CONST
  i : INTEGER  = -23 DIV 34;
  l : CARDINAL = 34 DIV 23;
  BEGIN END;

i := j MOD k;  
l := m MOD n;          
CONST
  i : INTEGER  = -23 MOD 34;
  l : CARDINAL = 34 MOD 23;
  BEGIN END;

i := ABS (k);            
l := ABS (m);            
x := ABS (y);            
X := ABS (Y);
CONST
  i : INTEGER  = ABS (-34);
  l : CARDINAL = ABS (-23);
  x : REAL     = ABS (- 45.34);
  X : LONGREAL = ABS (-45.34d12);
  BEGIN END;

x := FLOAT (j);          
x := FLOAT (m);        
x := FLOAT (z);          
x := FLOAT (X);        
CONST
  x1 = FLOAT (23);
  x2 = FLOAT (-34);
  x3 = FLOAT (4.0);
  x4 = FLOAT (23.34d1);
  BEGIN END;

X := LONGFLOAT (j);        
X := LONGFLOAT (m);        
X := LONGFLOAT (z);          
X := LONGFLOAT (X);          
CONST
  X1 = LONGFLOAT (23);
  X2 = LONGFLOAT (-34);
  X3 = LONGFLOAT (4.0);
  X4 = LONGFLOAT (23.34d1);
  BEGIN END;

i := FLOOR (x);            
i := FLOOR (X);            
CONST
  i1 = FLOOR (23.23);
  i2 = FLOOR (23.34d-3);
  BEGIN END;

i := CEILING (x);
i := CEILING (X);
CONST
  i1 = CEILING (23.23);
  i2 = CEILING (23.34d-3);
  BEGIN END;

i := ROUND (x);
i := ROUND (X);
CONST
  i1 = ROUND (23.23);
  i2 = ROUND (23.34d-3);
  BEGIN END;

i := TRUNC (x);
i := TRUNC (X);
CONST
  i1 = TRUNC (23.23);
  i2 = TRUNC (23.34d-3);
  BEGIN END;

i := MAX (j, k);
l := MAX (m, n);            
x := MAX (z, y);            
X := MAX (X, Y);
CONST
  i : INTEGER  = MAX (23, 34);
  l : CARDINAL = MAX (-34, 23);
  x : REAL     = MAX (4.0, 45.34);
  X : LONGREAL = MAX (23.34d1, 234.45d-1);
  BEGIN END;

i := MIN (j, k);
l := MIN (m, n);
x := MIN (z, y); 
X := MIN (X, Y); 
CONST
  i : INTEGER  = MIN (23, -34);
  l : CARDINAL = MIN (34, 23);
  x : REAL     = MIN (4.0, 45.34);
  X : LONGREAL = MIN (23.34d1, 234.45d-1);
  BEGIN END;


B := (i < j)  AND (i <= j) AND (i > j) AND 
     (i >= j) AND (i = j)  AND (i # j);
B := (l < m)  AND (l <= m) AND (l > m) AND 
     (l >= m) AND (l = m)  AND (l # m);
B := (x < y)  AND (x <= y) AND (x > y) AND 
     (x >= y) AND (x = y)  AND (x # y);
B := (X < Y)  AND (X <= Y) AND (X > Y) AND 
     (X >= Y) AND (X = Y)  AND (X # Y);
B := (a < b)  AND (a <= b) AND (a > b) AND 
     (a >= b) AND (a = b)  AND (a # b);
B := (s < t)  AND (s <= t) AND (s > t) AND 
     (s >= t) AND (s = t)  AND (s # t);
B := (e IN s);

CONST
  B1 = (2 < 3)            AND (2 <= 3)           AND (2 > 3) AND
       (2 >= 3)           AND (2 = 3)            AND (2 # 3);
  B2 = (5 < -23)          AND (5 <= -23)         AND (5 > -23) AND 
       (5 >= -23)         AND (5 = -23)          AND (5 # -23);
  B3 = (2.3 < 5.7)        AND (2.3 <= 5.7)       AND (2.3 > 5.7) AND
       (2.3 >= 5.7)       AND (2.3 = 5.7)        AND (2.3 # 5.7);
  B4 = (2.3d2 < 34.5d-3)  AND (2.3d2 <= 34.5d-3) AND (2.3d2 > 34.5d-3) AND 
       (2.3d2 >= 34.5d-3) AND (2.3d2 = 34.5d-3)  AND (2.3d2 # 34.5d-3);
  B5 = (S{SE.sa, SE.sb} < S{SE.sc, SE.sb}) AND 
       (S{SE.sa, SE.sb} <= S{SE.sc, SE.sb}) AND
       (S{SE.sa, SE.sb} > S{SE.sc, SE.sb}) AND
       (S{SE.sa, SE.sb} >= S{SE.sc, SE.sb}) AND 
       (S{SE.sa, SE.sb} = S{SE.sc, SE.sb}) AND 
       (S{SE.sa, SE.sb} # S{SE.sc, SE.sb});
  B6 = (SE.sa IN S{SE.sa, SE.sb});
  BEGIN END;

B := NOT C;
B := C AND D;
B := C OR D;

CONST 
  B1 = NOT TRUE;
  B2 = TRUE AND FALSE;
  B3 = FALSE OR TRUE;
  BEGIN END;

END Main.