-- version control marker $Id: cg10int.occ,v 1.1 1995/10/10 13:03:09 djb1 Exp $
PROC do.INT ()
  INT a, b , c:
  SEQ
    b := id.INT(85 (INT))
    --{{{  output message
    title ("INT arithmetic")
    --}}} 
    --{{{  check arithmetic and logical operators  (INT-000 to 099)
    a := b + 23 (INT)
    check.INT (a, 85(INT) + 23(INT), "INT-001")
    a := b PLUS 23 (INT)
    check.INT (a, 85(INT) PLUS 23(INT), "INT-002")
    a := b - 23 (INT)
    check.INT (a, 85(INT) - 23(INT), "INT-003")
    a := b MINUS 23 (INT)
    check.INT (a, 85(INT) MINUS 23(INT), "INT-004")
    a := b * 23 (INT)
    check.INT (a, 85(INT) * 23(INT), "INT-005")
    a := b TIMES 23 (INT)
    check.INT (a, 85(INT) TIMES 23(INT), "INT-006")
    a := b / 23 (INT)
    check.INT (a, 85(INT) / 23(INT), "INT-007")
    a := b \ 23 (INT)
    check.INT (a, 85(INT) \ 23(INT), "INT-008")
    --{{{  check logical operators                 (INT-009 to 014)
    a := b << 3
    check.INT (a, 85(INT) << 3, "INT-009")
    a := b >> 3
    check.INT (a, 85(INT) >> 3, "INT-010")
    a := b /\ 23 (INT)
    check.INT (a, 85(INT) /\ 23(INT), "INT-011")
    a := b \/ 23 (INT)
    check.INT (a, 85(INT) \/ 23(INT), "INT-012")
    a := b >< 23 (INT)
    check.INT (a, 85(INT) >< 23(INT), "INT-013")
    a := ~b
    check.INT (a, ~85(INT), "INT-014")
    --}}} 
    --{{{  unary minus                             (INT-015 to 018)
    a := (- b)
    check.INT (a, -85(INT), "INT-015")
    a := (MINUS b)
    check.INT (a, MINUS 85(INT), "INT-016")
    --{{{  
    a := MINUS (MOSTNEG INT)
    check.INT (a, MOSTNEG INT, "INT-017")
    --}}} 
    --{{{  
    c := MOSTNEG INT
    a := MINUS c
    check.INT (a, c, "INT-018")
    --}}} 
    --}}} 
    --{{{  sign extension                          (INT-019 to 029)
    PROC extension()
      PROC local(VAL INT w, x, y, z, INT i)
        i := ((INT w) + (INT x)) + ((INT y) + (INT z))
      :
      INT i :
      SEQ
        local(-1(INT), -1(INT), -1(INT), -1(INT), i)
        check(i, -4, "INT-019")
        local(1(INT), 1(INT), 1(INT), 1(INT), i)
        check(i, 4, "INT-020")
    :
    extension()
    --}}}
    --{{{  overflow checks on logical operators    (INT-030 to 039)
    INT p, q, r :
    SEQ
      p := id.INT(MOSTPOS INT)
      q := p PLUS 256(INT)
      check.INT(q, (MOSTNEG INT) + 255(INT), "INT-030")
    
      p := id.INT(MOSTNEG INT)
      q := p PLUS (-256(INT))
      check.INT(q, (MOSTPOS INT) - 255(INT), "INT-031")
    
      p := id.INT(MOSTPOS INT)
      q := p MINUS (-256(INT))
      check.INT(q, (MOSTNEG INT) + 255(INT), "INT-032")
    
      p := id.INT(MOSTNEG INT)
      q := p MINUS 256(INT)
      check.INT(q, (MOSTPOS INT) - 255(INT), "INT-033")
    
      p := id.INT(MOSTPOS INT)
      q := p TIMES 2(INT)
      check.INT(q, (MOSTPOS INT) TIMES 2(INT), "INT-034")
      check.INT(q, (MOSTPOS INT) << 1,           "INT-035")
    
      p := id.INT(MOSTPOS INT)
      q := MINUS p
      check.INT(q, 0(INT) MINUS (MOSTPOS INT), "INT-036")
      check.INT(q, (MOSTNEG INT) + 1(INT),     "INT-037")
    
      r := id.INT(0(INT))
      p := id.INT(MOSTPOS INT)
      q := (p PLUS 256(INT)) + r
      check.INT(q, (MOSTNEG INT) + 255(INT), "INT-038")
    
    --}}}
    
    --}}} 
    --{{{  check constant folding                  (INT-100 to 199)
    INT a, b :
    INT c :
    SEQ
      b := id.INT(5 (INT))
      c := 3
      --{{{  +        (INT-100)
      a := 2 (INT) + b               -- 7
      a := (1 (INT) + b    ) + a     -- 6
      a := (0 (INT) + b    ) + a     -- 5
      a := ((-1 (INT)) + b ) + a     -- 4
      a := ((-2 (INT)) + b ) + a     -- 3
      a := (b + 2 (INT)    ) + a     -- 7
      a := (b + 1 (INT)    ) + a     -- 6
      a := (b + 0 (INT)    ) + a     -- 5
      a := (b + (-1 (INT)) ) + a     -- 4
      a := (b + (-2 (INT)) ) + a     -- 3
      check.INT (a, 50 (INT), "INT-100")
      --}}} 
      --{{{  -        (INT-101)
      a := 2 (INT) - b               --  -3
      a := (1 (INT) - b    ) + a     --  -4
      a := (0 (INT) - b    ) + a     --  -5
      a := ((-1 (INT)) - b ) + a     --  -6
      a := ((-2 (INT)) - b ) + a     --  -7
      a := (b - 2 (INT)    ) + a     --   3
      a := (b - 1 (INT)    ) + a     --   4
      a := (b - 0 (INT)    ) + a     --   5
      a := (b - (-1 (INT)) ) + a     --   6
      a := (b - (-2 (INT)) ) + a     --   7
      check.INT (a, 0 (INT), "INT-101")
      --}}} 
      --{{{  *        (INT-102)
      a := 2 (INT) * b                 --  10
      a := (1 (INT) * b      ) + a     --   5
      a := (0 (INT) * b      ) + a     --   0
      a := ((-1 (INT)) * b   ) + a     --  -5
      a := ((-2 (INT)) * b   ) + a     -- -10
      a := (b * 2 (INT)      ) + a     --  10
      a := (b * 1 (INT)      ) + a     --   5
      a := (b * 0 (INT)      ) + a     --   0
      a := (b * (-1 (INT))   ) + a     --  -5
      a := (b * (-2 (INT))   ) + a     -- -10
      check.INT (a, 0 (INT), "INT-102")
      --}}} 
      --{{{  /        (INT-103)
      a := 2 (INT) / b                 -- 0
      a := (1 (INT) / b      ) + a     -- 0
      a := (0 (INT) / b      ) + a     -- 0
      a := ((-1 (INT)) / b   ) + a     -- 0
      a := ((-2 (INT)) / b   ) + a     -- 0
      a := (b / 2 (INT)      ) + a     -- 2
      a := (b / 1 (INT)      ) + a     -- 5
      --a := b / 0 (INT)  --should give error
      a := (b / (-1 (INT))   ) + a     -- -5
      a := (b / (-2 (INT))   ) + a     -- -2
      check.INT (a, 0 (INT), "INT-103")
      --}}} 
      --{{{  \        (INT-104)
      a := 2 (INT) \ b                 --  2
      a := (1 (INT) \ b      ) + a     --  1
      a := (0 (INT) \ b      ) + a     --  0
      a := ((-1 (INT)) \ b   ) + a     -- -1
      a := ((-2 (INT)) \ b   ) + a     -- -2
      a := (b \ 2 (INT)      ) + a     --  1
      a := (b \ 1 (INT)      ) + a     --  0
      --a := b \ 0 (INT)  --should give error
      a := (b \ (-1 (INT))   ) + a     --  0
      a := (b \ (-2 (INT))   ) + a     --  1
      check.INT (a, 2 (INT), "INT-104")
      --}}} 
      --{{{  PLUS     (INT-105)
      a := 2 (INT) PLUS b                 -- 7
      a := (1 (INT) PLUS b      ) + a     -- 6
      a := (0 (INT) PLUS b      ) + a     -- 5
      a := ((-1 (INT)) PLUS b   ) + a     -- 4
      a := ((-2 (INT)) PLUS b   ) + a     -- 3
      a := (b PLUS 2 (INT)      ) + a     -- 7
      a := (b PLUS 1 (INT)      ) + a     -- 6
      a := (b PLUS 0 (INT)      ) + a     -- 5
      a := (b PLUS (-1 (INT))   ) + a     -- 4
      a := (b PLUS (-2 (INT))   ) + a     -- 3
      check.INT (a, 50 (INT), "INT-105")
      --}}} 
      --{{{  MINUS    (INT-106)
      a := 2 (INT) MINUS b                  --  -3
      a := (1 (INT) MINUS b       ) + a     --  -4
      a := (0 (INT) MINUS b       ) + a     --  -5
      a := ((-1 (INT)) MINUS b    ) + a     --  -6
      a := ((-2 (INT)) MINUS b    ) + a     --  -7
      a := (b MINUS 2 (INT)       ) + a     --   3
      a := (b MINUS 1 (INT)       ) + a     --   4
      a := (b MINUS 0 (INT)       ) + a     --   5
      a := (b MINUS (-1 (INT))    ) + a     --   6
      a := (b MINUS (-2 (INT))    ) + a     --   7
      check.INT (a, 0 (INT), "INT-106")
      --}}} 
      --{{{  TIMES    (INT-107)
      a := 2 (INT) TIMES b                --  10
      a := (1 (INT) TIMES b     ) + a     --   5
      a := (0 (INT) TIMES b     ) + a     --   0
      a := ((-1 (INT)) TIMES b  ) + a     --  -5
      a := ((-2 (INT)) TIMES b  ) + a     -- -10
      a := (b TIMES 2 (INT)     ) + a     --  10
      a := (b TIMES 1 (INT)     ) + a     --   5
      a := (b TIMES 0 (INT)     ) + a     --   0
      a := (b TIMES (-1 (INT))  ) + a     --  -5
      a := (b TIMES (-2 (INT))  ) + a     -- -10
      check.INT (a, 0 (INT), "INT-107")
      --}}} 
      --{{{  /\       (INT-108)
      a := 2 (INT) /\ b                   -- 0
      a := (1 (INT) /\ b        ) + a     -- 1
      a := (0 (INT) /\ b        ) + a     -- 0
      a := ((-1 (INT)) /\ b     ) + a     -- 5
      a := ((-2 (INT)) /\ b     ) + a     -- 4
      a := (b /\ 2 (INT)        ) + a     -- 0
      a := (b /\ 1 (INT)        ) + a     -- 1
      a := (b /\ 0 (INT)        ) + a     -- 0
      a := (b /\ (-1 (INT))     ) + a     -- 5
      a := (b /\ (-2 (INT))     ) + a     -- 4
      check.INT (a, 20 (INT), "INT-108")
      a := b /\ 0(INT)
      check.INT (a, 0(INT), "INT-108a")
      a := b /\ (-1(INT))
      check.INT (a, 5(INT), "INT-108b")
      a := b /\ b
      check.INT (a, 5(INT), "INT-108c")
      
      --}}} 
      --{{{  \/       (INT-109)
      a := 2 (INT) \/ b                 --  7
      a := (1 (INT) \/ b      ) + a     --  5
      a := (0 (INT) \/ b      ) + a     --  5
      a := ((-1 (INT)) \/ b   ) + a     -- -1
      a := ((-2 (INT)) \/ b   ) + a     -- -1
      a := (b \/ 2 (INT)      ) + a     --  7
      a := (b \/ 1 (INT)      ) + a     --  5
      a := (b \/ 0 (INT)      ) + a     --  5
      a := (b \/ (-1 (INT))   ) + a     -- -1
      a := (b \/ (-2 (INT))   ) + a     -- -1
      check.INT (a, 30 (INT), "INT-109")
      a := b \/ 0(INT)
      check.INT (a, 5(INT), "INT-109a")
      a := b \/ (-1(INT))
      check.INT (a, -1(INT), "INT-109b")
      a := b \/ b
      check.INT (a, 5(INT), "INT-109c")
      
      --}}} 
      --{{{  ><       (INT-110)
      a := 2 (INT) >< b                  --  7
      a := (1 (INT) >< b       ) + a     --  4
      a := (0 (INT) >< b       ) + a     --  5
      a := ((-1 (INT)) >< b    ) + a     -- -6
      a := ((-2 (INT)) >< b    ) + a     -- -5
      a := (b >< 2 (INT)       ) + a     --  7
      a := (b >< 1 (INT)       ) + a     --  4
      a := (b >< 0 (INT)       ) + a     --  5
      a := (b >< (-1 (INT))    ) + a     -- -6
      a := (b >< (-2 (INT))    ) + a     -- -5
      check.INT (a, 10 (INT), "INT-110")
      a := b >< 0(INT)
      check.INT (a, 5(INT), "INT-110a")
      a := b >< (-1(INT))
      check.INT (a, -6(INT), "INT-110b")
      a := b >< b
      check.INT (a, 0(INT), "INT-110c")
      
      --}}} 
      --{{{  <<       (INT-111)
      a := 64 (INT) << c                 --  512
      a := (32 (INT) << c      ) + a     --  256
      a := (0 (INT) << c       ) + a     --    0
      a := ((-64 (INT)) << c   ) + a     -- -256
      a := ((-32 (INT)) << c   ) + a     -- -512
      --a := (b << 64              ) + a     --    0
      --a := (b << 32              ) + a     --    0         won't work on T2
      --a := (b << 16              ) + a     --   (5 << 16)  different when its a T2
      a := (b << 8               ) + a     --   (5 << 8)
      a := (b << 0               ) + a     --    5
      --a := b << (-64) --should give error
      --a := b << (-32) --should give error
      VAL correct.result IS 5(INT) + (5(INT) <<  8) :
      check.INT (a, correct.result, "INT-111")
      --}}} 
      --{{{  >>       (INT-112)
      a := 64 (INT) >> c                --  8
      a := (32 (INT) >> c     ) + a     --  4
      a := (0 (INT) >> c      ) + a     --  0
      a := ((-64 (INT)) >> c  ) + a     --  (-64 >> 3)
      a := ((-32 (INT)) >> c  ) + a     --  (-32 >> 3)
      --a := (b >> 64             ) + a     --  0
      --a := (b >> 32             ) + a     --  0    (won't work on T2)
      a := (b >> 16             ) + a     --  0
      a := (b >> 8              ) + a     --  0
      a := (b >> 0              ) + a     --  5
      --a := b >> (-64) --should give error
      --a := b >> (-32) --should give error
      VAL correct.result IS 17 (INT) +
                 ( ( (-64(INT)) >> 3) + ( (-32(INT)) >> 3) ) :
      check.INT (a, correct.result, "INT-112")
      --}}} 
    --}}} 
    --{{{  check comparison operators              (INT-200 to 299)
    a := id.INT(47(INT))
    x := a = b
    check.BOOL (x, FALSE, "INT-205")
    x := a > b
    check.BOOL (x, FALSE, "INT-206")
    x := a >= b
    check.BOOL (x, FALSE, "INT-207")
    x := a < b
    check.BOOL (x, TRUE, "INT-208")
    x := a <= b
    check.BOOL (x, TRUE, "INT-209")
    x := a <> b
    check.BOOL (x, TRUE, "INT-210")
    x := a AFTER b
    check.BOOL (x, FALSE, "INT-211")
    
    --}}} 
    --{{{  check conversions                       (INT-300 to 399)
    --{{{  variables for conversion tests
    REAL64 r64 :
    REAL32 r32 :
    INT64 i64 :
    INT32 i32 :
    INT16 i16 :
    BYTE byte :
    BOOL bool :
    --}}} 
    SEQ
      r64 := REAL64 TRUNC b
      check.REAL64 (r64, REAL64 TRUNC 85(INT), "INT-301")
      r64 := REAL64 ROUND b
      check.REAL64 (r64, REAL64 ROUND 85(INT), "INT-302")
      r32 := REAL32 TRUNC b
      check.REAL32 (r32, REAL32 TRUNC 85(INT), "INT-303")
      r32 := REAL32 ROUND b
      check.REAL32 (r32, REAL32 ROUND 85(INT), "INT-304")
      i64 := INT64 b
      check.INT64 (i64, INT64 85(INT), "INT-305")
      i32 := INT32 b
      check.INT32 (i32, INT32 85(INT), "INT-306")
      i16 := INT16 b
      check.INT16 (i16, INT16 85(INT), "INT-307")
      byte := BYTE b
      check.BYTE (byte, BYTE 85(INT), "INT-308")
      c := 1(INT)
      bool := BOOL c
      check.BOOL (bool, BOOL 1(INT), "INT-309")
    --}}} 
    --{{{  check 'remainder identity'              (INT-400 to 499)
    a := ( 23(INT) * ( b / 23(INT) ) ) + ( b \ 23(INT) )
    check.INT (a,
      ( 23(INT) * ( 85(INT) / 23(INT) ) ) + ( 85(INT) \ 23(INT) ),
      "INT-400")
    check.INT (a, b, "INT-401")
    --}}} 
    --{{{  hefty calculations                      (INT-500 to 599)
    --{{{  declarations
    INT x, y, z, a, b, c, d :
    VAL n1 IS 1(INT) :
    VAL n2 IS 2(INT) :
    VAL n3 IS 3(INT) :
    VAL n4 IS 1(INT) / 3(INT) :
    VAL twice.eight.four IS 8192(INT) : -- twice 8 to the power 4 (= 2 to the 13)
    --}}} 
    SEQ
      --{{{  initialisation
      x := 8(INT)
      y := x + x
      z := y - x
      a := 11111(INT)
      b := 22222(INT)
      c := a * 2(INT)
      --}}} 
      check.INT (y, 16(INT), "INT-500")
      check.INT (z,  8(INT), "INT-501")
      check.INT (c,  b, "INT-502")
      check.INT (((x + y) + (n3 * z)) + ((n2 * a) - b), 48(INT), "INT-503")
      check.INT (((x PLUS y) PLUS (n3 TIMES z)) PLUS ((n2 TIMES a) MINUS b), 48(INT), "INT-503a")
      check.INT (x + (x + (x + (x + (x + (x + x))))), 56(INT), "INT-504")
      check.INT (x PLUS (x PLUS (x PLUS (x PLUS (x PLUS (x PLUS x))))), 56(INT), "INT-504a")
      check.INT ((x * (x * (x * x))) + (x * (x * (x * x))),
                   twice.eight.four, "INT-505")
      check.INT ((x TIMES (x TIMES (x TIMES x))) PLUS (x TIMES (x TIMES (x TIMES x))),
                   twice.eight.four, "INT-505a")
      check.INT ((n2 * (y * (y * x))) + (n2 * (y * (y * x))),
                   twice.eight.four, "INT-506")
      check.INT ((n2 TIMES (y TIMES (y TIMES x))) PLUS (n2 TIMES (y TIMES (y TIMES x))),
                   twice.eight.four, "INT-506a")
      x := 1 (INT)
      y := 3 (INT)
      d := 2 (INT)
      check.INT (x / y, n4, "INT-507")
      c := ((d * y) * (d * y)) * ((d * y) * (d * y))
      check.INT (c, 1296 (INT), "INT-509")
      c := ((d TIMES y) TIMES (d TIMES y)) TIMES ((d TIMES y) TIMES (d TIMES y))
      check.INT (c, 1296 (INT), "INT-509a")
      c := ((((d * y) * (d * y)) * (d * y)) * (d * y)) * (d * y)
      check.INT (c, 7776 (INT), "INT-510")
      c := ((((d TIMES y) TIMES (d TIMES y)) TIMES (d TIMES y)) TIMES (d TIMES y)) TIMES (d TIMES y)
      check.INT (c, 7776 (INT), "INT-510a")
    
    
    --}}} 
    --{{{  passing as parameters                   (INT-600 to 699)
    --{{{  copy.int and add.int
    PROC copy.int (VAL INT x, INT y)
      y := x
    :
    PROC add.int (VAL INT x, y, INT z)
      z := x + y
    :
    --}}} 
    INT x, y, z :
    VAL n1 IS 2(INT) :
    VAL n2 IS 5000(INT) :
    SEQ
      copy.int (n1, x)
      check.INT (x, 2(INT), "INT-600")
      copy.int (n2, x)
      check.INT (x, 5000(INT), "INT-601")
      y := 57 (INT)
      copy.int (y, x)
      check.INT (x, 57(INT), "INT-602")
      add.int (n1, n2, x)
      check.INT (x, 5002(INT), "INT-603")
      y := n1
      z := n2
      add.int (y, z, x)
      check.INT (x, 5002(INT), "INT-604")
      check.INT (z, 5000(INT), "INT-605")
    --}}} 
    --{{{  arrays                                  (INT-700 to 799)
    VAL n IS 1(INT) :
    VAL m IS 2(INT) :
    VAL t1 IS [n, n, n, n, m] :
    VAL t2 IS [t1, t1, t1, t1 ] :
    VAL t3 IS [t2, t2, t2 ] :
    BOOL b :
    INT x :
    INT tot :
    SEQ
      check.INT (t1 [0], n,         "INT-700")
      check.INT (t1 [4], m,         "INT-701")
      check.INT (t2 [2] [4], m,     "INT-702")
      check.INT (t3 [1] [2] [4], m, "INT-703")
      --{{{  test individual access
      b := TRUE
      x := 4
      tot := 0(INT)
      SEQ i = 0 FOR SIZE t3
        SEQ j = 0 FOR SIZE t2
          SEQ k = 0 FOR SIZE t1
            SEQ
              IF
                (k = 4) AND (t3 [i] [j] [k] = m)
                  SKIP
                (k < 4) AND (t3 [i] [j] [k] = n)
                  SKIP
                TRUE
                  b := FALSE
              tot := tot + t3 [i] [j] [k]
              x := INT t3 [i] [j] [x]      -- sets it to 1
              x := 4                       -- resets it again
      check.BOOL (b, TRUE, "INT-704")
      VAL correct.value IS (48(INT) * n) + (12(INT) * m) :
      check.INT (tot, correct.value, "INT-705")
      --}}} 
      --{{{  test nested array access
      INT a, b, c :
      SEQ
        a := 2
        b := 1
        c := 3
        tot := t3[a][b][c] + ( t3[b][a][c] + ( t3[0][1][4] + ( t3[b][a+b][b+(a+b)] +
               t1[(a+b)+b] ) ) )
        VAL correct.value IS (2(INT) * n) + (3(INT) * m) :
        check.INT (tot, correct.value, "INT-706")
        tot := t3 [a] [ INT t3 [a] [b] [INT t3 [b + b] [a +
                        b] [b + (a + b)] ] ] [(INT t3 [a] [c] [c +
                        (b - a)]) + (3 * (INT t3 [a] [c] [b])) ]
        check.INT (tot, m, "INT-707")
      --}}} 
      --{{{  test individual access using abbreviations
      b := TRUE
      x := 4
      tot := 0(INT)
      SEQ i = 0 FOR SIZE t3
        VAL a2 IS t3 [i] :
        SEQ j = 0 FOR SIZE t2
          VAL a1 IS a2 [j] :
          SEQ k = 0 FOR SIZE t1
            VAL a0 IS a1 [k] :
            SEQ
              IF
                (k = 4) AND (a0 = m)
                  SKIP
                (k < 4) AND (a0 = n)
                  SKIP
                TRUE
                  b := FALSE
              tot := tot + a0
              x := INT a1 [x]              -- sets it to 1
              x := 4                       -- resets it again
      check.BOOL (b, TRUE, "INT-708")
      VAL correct.value IS (48(INT) * n) + (12(INT) * m) :
      check.INT (tot, correct.value, "INT-709")
      --}}} 
      --{{{  test livermore loop                   (INT-710 to 711)
      PROC livermore()
        VAL n IS 10 :
        VAL r IS 7(INT) :
        VAL t IS 13(INT) :
        [n + 6] INT u :
        [n] INT x, y, z :
        SEQ
          SEQ k = 0 FOR n + 6
            u [k] := 3(INT)
          SEQ k = 0 FOR n
            SEQ
              y [k] := 11(INT)
              z [k] :=  5(INT)
        
          SEQ k = 0 FOR n
            x [k] := u[k] + ((( r * (z[k] + (r * y[k]))) +
                              (t * ((u[k+3] + (r * (u[k+2] + (r * u[k+1]))))))) +
                              (t * ((u[k+6] + (r * (u[k+5] + (r * u[k+4])))))))
        
          check.INT (x[0],     5023(INT), "INT-710")
          check.INT (x[n - 1], 5023(INT), "INT-711")
      :
      livermore()
      --}}} 
      --{{{  test some bugs that were found        (INT-712 to 716)
      PROC bug.tests()
        SEQ
          --{{{  bug1                                  (INT-712)
          [2][2]INT arr :
          INT A :
          INT i :
          SEQ
            i := 0
            arr[i][i] := 0(INT)
            A := ((arr[i][i]+arr[i][i]) + (arr[i][i]+arr[i][i])) / 4(INT)
            check.INT (A, 0(INT), "INT-712")
          --}}} 
          --{{{  bug3                                  (INT-713 to 714)
          PROC Complex.Subst ([]INT a, b)
            SEQ
              check.INT (a[0], 2(INT), "INT-713")
              check.INT (b[1], 4(INT), "INT-714")
          :
          
          [2][2][2]INT g.plus, g.minus :
          INT i, j :
          SEQ
            i := 1(INT)
            j := 0(INT)
            g.plus [INT i][INT j][0] := 2(INT)
            g.minus[INT i][INT j][1] := 4(INT)
            Complex.Subst (g.plus[INT i][INT j],
                           g.minus[INT i][INT j])
          --}}} 
          --{{{  bug4                                  (INT-715)
          [10][10]INT c, b :
          INT i :
          INT A:
          SEQ
            i := 1
            SEQ i = 0 FOR 10
              SEQ j = 0 FOR 10
                VAL tmp IS INT j :
                c [i][j] := tmp
            A := ((c[i][i] * c [i*i][i+2])) / (c[(i*i)+i][(i*i)+i] + c[i][i])
            check.INT (A, 1(INT), "INT-715")
          --}}} 
          --{{{  test2                                 (INT-716)
          INT u :
          [4] INT ai :
          [3] [4] INT x, Gb :
          INT i, j, k :
          SEQ
            SEQ i = 0 FOR 4
              SEQ
                ai [i] := 5(INT)
                SEQ j = 0 FOR 3
                  SEQ
                    x [j] [i] := 2(INT)
                    Gb[j] [i] := 24(INT)
            u := 4(INT)
            i := 1
            j := 2
            k := 3
            u := u + (ai [j] * x [j][k])
            x [i][k] := (Gb [i][k] - u) / ai[i]
            check.INT (x [i][k], 2(INT), "INT-716")
          
            u := 4(INT)
            u := u PLUS (ai [j] TIMES x [j][k])
            x [i][k] := (Gb [i][k] MINUS u) / ai[i]
            check.INT (x [i][k], 2(INT), "INT-717")
          
          --}}} 
      :
      bug.tests()
      --}}} 
    --}}} 
    --{{{  miscellaneous bug checks                (INT-800 to 899)
    --}}} 
    --{{{  more conversion tests
    INT FUNCTION id(VAL INT i) IS i :
    VAL n IS 5 :
    VAL m IS 7 :
    [n][m]INT64 i64arr :
    [n][m]INT32 i32arr :
    [n][m]INT16 i16arr :
    [n][m]INT   iarr :
    [n][m]REAL32 r32arr :
    [n][m]REAL64 r64arr :
    INT i, j :
    VAL ans IS (n / 2) + (m / 2) :
    SEQ
      i, j := n / 2, m / 2
      SEQ k = 0 FOR n
        SEQ l = 0 FOR m
          iarr[k][l] := INT(k + l)
    
      r64arr[i][j] := REAL64 ROUND iarr[i][j]
      check.REAL64(r64arr[i][j], REAL64 ROUND ans, "INT-R64-1")
      r64arr[id(i)][j] := REAL64 ROUND iarr[id(i)][j]
      check.REAL64(r64arr[i][j], REAL64 ROUND ans, "INT-R64-2")
      r64arr[i][j] := REAL64 TRUNC iarr[i][j]
      check.REAL64(r64arr[i][j], REAL64 TRUNC ans, "INT-R64-3")
      r64arr[id(i)][j] := REAL64 TRUNC iarr[id(i)][j]
      check.REAL64(r64arr[i][j], REAL64 TRUNC ans, "INT-R64-4")
    
      r32arr[i][j] := REAL32 ROUND iarr[i][j]
      check.REAL32(r32arr[i][j], REAL32 ROUND ans, "INT-R32-1")
      r32arr[id(i)][j] := REAL32 ROUND iarr[id(i)][j]
      check.REAL32(r32arr[i][j], REAL32 ROUND ans, "INT-R32-2")
      r32arr[i][j] := REAL32 TRUNC iarr[i][j]
      check.REAL32(r32arr[i][j], REAL32 TRUNC ans, "INT-R32-3")
      r32arr[id(i)][j] := REAL32 TRUNC iarr[id(i)][j]
      check.REAL32(r32arr[i][j], REAL32 TRUNC ans, "INT-R32-4")
    
      i64arr[i][j] := INT64 iarr[i][j]
      check.INT64(i64arr[i][j], INT64 ans, "INT-I64-1")
      i64arr[id(i)][j] := INT64 iarr[id(i)][j]
      check.INT64(i64arr[i][j], INT64 ans, "INT-I64-2")
    
      i32arr[i][j] := INT32 iarr[i][j]
      check.INT32(i32arr[i][j], INT32 ans, "INT-I32-1")
      i32arr[id(i)][j] := INT32 iarr[id(i)][j]
      check.INT32(i32arr[i][j], INT32 ans, "INT-I32-2")
    
      i16arr[i][j] := INT16 iarr[i][j]
      check.INT16(i16arr[i][j], INT16 ans, "INT-I16-1")
      i16arr[id(i)][j] := INT16 iarr[id(i)][j]
      check.INT16(i16arr[i][j], INT16 ans, "INT-I16-2")
    
      iarr[i][j] := INT iarr[i][j]
      check.INT(iarr[i][j], INT ans, "INT-INT-1")
      iarr[id(i)][j] := INT iarr[id(i)][j]
      check.INT(iarr[i][j], INT ans, "INT-INT-2")
    --}}}
    --{{{  more constant folding (bug INSdi02215, INSdi01895)
    PROC constant.TIMES(VAL INT y)
    
      VAL zero.zero IS          0(INT) :
      VAL zero.one  IS          1(INT) :
      VAL zero.any  IS          2(INT) :
      VAL one.zero  IS #100(INT) :
      VAL one.one   IS #101(INT) :
      VAL one.any   IS #102(INT) :
      VAL any.zero  IS #200(INT) :
      VAL any.one   IS #201(INT) :
      VAL any.any   IS #202(INT) :
      VAL table IS [0(INT), 1(INT), 2(INT), -1(INT), -2(INT),
                    MOSTNEG INT, MOSTPOS INT, 10(INT),
                    zero.any,
                    one.zero, one.one, one.any,
                    any.zero, any.one, any.any,
                    -zero.any,
                    -one.zero, -one.one, -one.any,
                    -any.zero, -any.one, -any.any ] :
      SEQ
        SEQ z = 0 FOR SIZE table
          PROC local.check(VAL INT x, y, VAL []BYTE msg)
            check.INT(x, y TIMES table[z], msg)
          :
          INT res, x :
          SEQ
            x := id.INT(table[z])
    
            res := x TIMES zero.zero
            local.check(res, zero.zero, "INT-a")
            res := x TIMES zero.one
            local.check(res, zero.one, "INT-b")
            res := x TIMES zero.any
            local.check(res, zero.any, "INT-c")
          
            res := x TIMES one.zero
            local.check(res, one.zero, "INT-d")
            res := x TIMES one.one
            local.check(res, one.one, "INT-e")
            res := x TIMES one.any
            local.check(res, one.any, "INT-f")
          
            res := x TIMES any.zero
            local.check(res, any.zero, "INT-g")
            res := x TIMES any.one
            local.check(res, any.one, "INT-h")
            res := x TIMES any.any
            local.check(res, any.any, "INT-i")
          
            res := zero.zero TIMES x
            local.check(res, zero.zero, "INT-j")
            res := zero.one  TIMES x
            local.check(res, zero.one, "INT-k")
            res := zero.any  TIMES x
            local.check(res, zero.any, "INT-l")
          
            res := one.zero  TIMES x
            local.check(res, one.zero, "INT-m")
            res := one.one   TIMES x
            local.check(res, one.one, "INT-n")
            res := one.any   TIMES x
            local.check(res, one.any, "INT-o")
          
            res := any.zero  TIMES x
            local.check(res, any.zero, "INT-p")
            res := any.one   TIMES x
            local.check(res, any.one, "INT-q")
            res := any.any   TIMES x
            local.check(res, any.any, "INT-r")
    
            res := y         TIMES x
            local.check(res, y, "INT-s")
    :
    constant.TIMES(27(INT))
    --}}}
    --{{{  bug 670
    PROC bug.670()
      INT a,b :
      SEQ
        a := 2(INT)
        b := (a + 3(INT)) TIMES 3(INT)
        check.INT(b, 15(INT), "B670a")
    :
    bug.670()
    --}}}
    --{{{  bug 1000
    PROC bug.1000()
      PROC q (VAL INT a0, a1, a2, a3, a4, INT b0, b1, b2, b3, b4)
        b0, b1, b2, b3, b4 := a0, a1, a2, a3, a4
      :
      [5]INT z0, z1 :
      SEQ
        SEQ i = 0 FOR SIZE z0
          z0[i], z1[i] := INT (-i), INT 0
        q(z0[0],z0[1],z0[2],z0[3],z0[4],z1[0],z1[1],z1[2],z1[3],z1[4])
        SEQ i = 0 FOR SIZE z1
          check(INT z1[i], -i, "B1000a")
    :
    bug.1000()
    --}}}
    --{{{  bug 1150
    PROC bug.1150()
      INT x, y :
      VAL INT c IS   1(INT) :
      VAL INT d IS 100(INT) :
      SEQ
        x, y := c, d
        x := (x + x) + (y + y)
        check.INT(x, (c+c)+(d+d), "B1150a")
        x, y := c, d
        x := (x + x) - (y + y)
        check.INT(x, (c+c)-(d+d), "B1150b")
        x, y := c, d
        x := (x + x) + (x + x)
        check.INT(x, (c+c)+(c+c), "B1150c")
        x, y := c, d
        x := (x + x) - (x + x)
        check.INT(x, (c+c)-(c+c), "B1150d")
        x, y := c, d
        x := (y + y) + (x + x)
        check.INT(x, (d+d)+(c+c), "B1150e")
        x, y := c, d
        x := (y + y) - (x + x)
        check.INT(x, (d+d)-(c+c), "B1150f")
        x := #1234(INT)
        y := 1(INT)
        x := (x /\ #0FFF(INT))\/(((x>>12)+(y+1(INT)))<<12)
        check.INT(x, #3234(INT), "B1150g")
    :
    bug.1150()
    --}}}
    --{{{  bug 1274
    PROC bug.1274()
      INT x, y :
      VAL c IS 10(INT) :
      VAL d IS 20(INT) :
      SEQ
        y := c
    
        VAL a IS (c * c) + (c * d) :
        SEQ
          x := c
          x := (y * c) + (y * d)
          check.INT(x, a, "B1274-Ia+")
          x := c
          x := (x * c) + (y * d)
          check.INT(x, a, "B1274-Ib+")
          x := c
          x := (y * c) + (x * d)
          check.INT(x, a, "B1274-Ic+")
          x := c
          x := (x * c) + (x * d)
          check.INT(x, a, "B1274-Id+")
    
        VAL a IS (c * c) PLUS (c * d) :
        SEQ
          x := c
          x := (y * c) PLUS (y * d)
          check.INT(x, a, "B1274-IaP")
          x := c
          x := (x * c) PLUS (y * d)
          check.INT(x, a, "B1274-IbP")
          x := c
          x := (y * c) PLUS (x * d)
          check.INT(x, a, "B1274-IcP")
          x := c
          x := (x * c) PLUS (x * d)
          check.INT(x, a, "B1274-IdP")
    
        VAL a IS (c * c) * (c * d) :
        SEQ
          x := c
          x := (y * c) * (y * d)
          check.INT(x, a, "B1274-Ia**")
          x := c
          x := (x * c) * (y * d)
          check.INT(x, a, "B1274-Ib**")
          x := c
          x := (y * c) * (x * d)
          check.INT(x, a, "B1274-Ic**")
          x := c
          x := (x * c) * (x * d)
          check.INT(x, a, "B1274-Id**")
    
        VAL a IS (c * c) TIMES (c * d) :
        SEQ
          x := c
          x := (y * c) TIMES (y * d)
          check.INT(x, a, "B1274-IaT")
          x := c
          x := (x * c) TIMES (y * d)
          check.INT(x, a, "B1274-IbT")
          x := c
          x := (y * c) TIMES (x * d)
          check.INT(x, a, "B1274-IcT")
          x := c
          x := (x * c) TIMES (x * d)
          check.INT(x, a, "B1274-IdT")
    
    :
    bug.1274()
    --}}}
    --{{{  bug TS/2020
    PROC bug.TS.2020()
      INT int, mostneg, mostpos :
      SEQ
        int := (MOSTNEG INT) REM (-1(INT))
        check.INT(int, 0(INT), "B2020da")
        int := (MOSTNEG INT) REM ( 1(INT))
        check.INT(int, 0(INT), "B2020db")
        int := (MOSTPOS INT) REM (-1(INT))
        check.INT(int, 0(INT), "B2020dc")
        int := (MOSTPOS INT) REM ( 1(INT))
        check.INT(int, 0(INT), "B2020dd")
        int := (MOSTNEG INT) /   ( 1(INT))
        check.INT(int, MOSTNEG INT, "B2020de")
        int := (MOSTPOS INT) /   (-1(INT))
        check.INT(int, (MOSTNEG INT) + 1(INT), "B2020df")
        int := (MOSTPOS INT) /   ( 1(INT))
        check.INT(int, MOSTPOS INT, "B2020dg")
    
        mostneg, mostpos := MOSTNEG INT, MOSTPOS INT
    
        int := (mostneg) REM (-1(INT))
        check.INT(int, 0(INT), "B2020dh")
        int := (mostneg) REM ( 1(INT))
        check.INT(int, 0(INT), "B2020di")
        int := (mostpos) REM (-1(INT))
        check.INT(int, 0(INT), "B2020dj")
        int := (mostpos) REM ( 1(INT))
        check.INT(int, 0(INT), "B2020dk")
        int := (mostneg) /   ( 1(INT))
        check.INT(int, MOSTNEG INT, "B2020dl")
        int := (mostpos) /   (-1(INT))
        check.INT(int, (MOSTNEG INT) + 1(INT), "B2020dm")
        int := (mostpos) /   ( 1(INT))
        check.INT(int, MOSTPOS INT, "B2020dn")
    :
    bug.TS.2020()
    --}}}
    --{{{  bug INSdi02195
    PROC bug.INSdi02195()
      --{{{  functions
      BOOL   FUNCTION BOOL.fn   (VAL INT x) IS BOOL  x :
      BYTE   FUNCTION BYTE.fn   (VAL INT x) IS BYTE  x :
      INT16  FUNCTION INT16.fn  (VAL INT x) IS INT16 x :
      INT    FUNCTION INT.fn    (VAL INT x) IS x :
      INT32  FUNCTION INT32.fn  (VAL INT x) IS INT32 x :
      INT64  FUNCTION INT64.fn  (VAL INT x) IS INT64 x :
      REAL32 FUNCTION REAL32.fn (VAL INT x) IS REAL32 ROUND x :
      REAL64 FUNCTION REAL64.fn (VAL INT x) IS REAL64 ROUND x :
      --}}}
      --{{{  variables
      BOOL bool.var :
      BYTE byte.var :
      INT16 i16.var :
      INT32 i32.var :
      INT64 i64.var :
      INT   int.var :
      REAL32 r32.var :
      REAL64 r64.var :
      INT zero, int :
      --}}}
      INT local.i, local.j, local.k :
      SEQ
        zero := id(0)
        int := id(77)
        --{{{  INT var -> type -> INT         00 - 09
        local.j := id.INT(1(INT))
        
        local.i := INT (BOOL local.j)
        check.INT(local.i, 1(INT), "INT-00")
        
        local.j := id.INT(77(INT))
        
        local.i := INT (BYTE local.j)
        check.INT(local.i, 77(INT), "INT-01")
        local.i := INT (INT local.j)
        check.INT(local.i, 77(INT), "INT-02")
        local.i := INT (INT16 local.j)
        check.INT(local.i, 77(INT), "INT-03")
        local.i := INT (INT32 local.j)
        check.INT(local.i, 77(INT), "INT-04")
        local.i := INT (INT64 local.j)
        check.INT(local.i, 77(INT), "INT-05")
        local.i := INT ROUND (REAL32 ROUND local.j)
        check.INT(local.i, 77(INT), "INT-06")
        local.i := INT ROUND (REAL64 ROUND local.j)
        check.INT(local.i, 77(INT), "INT-07")
        --}}}
        --{{{  INT FUNCTION -> type -> INT    10 - 19
        local.j := id.INT(1(INT))
        
        local.i := INT (BOOL INT.fn(INT local.j))
        check.INT(local.i, 1(INT), "INT-10")
        
        local.j := id.INT(77(INT))
        
        local.i := INT (BYTE INT.fn(INT local.j))
        check.INT(local.i, 77(INT), "INT-11")
        local.i := INT (INT INT.fn(INT local.j))
        check.INT(local.i, 77(INT), "INT-12")
        local.i := INT (INT16 INT.fn(INT local.j))
        check.INT(local.i, 77(INT), "INT-13")
        local.i := INT (INT32 INT.fn(INT local.j))
        check.INT(local.i, 77(INT), "INT-14")
        local.i := INT (INT64 INT.fn(INT local.j))
        check.INT(local.i, 77(INT), "INT-15")
        local.i := INT ROUND (REAL32 ROUND (INT.fn(INT local.j)))
        check.INT(local.i, 77(INT), "INT-16")
        local.i := INT ROUND (REAL64 ROUND (INT.fn(INT local.j)))
        check.INT(local.i, 77(INT), "INT-17")
        --}}}
        --{{{  INT exp -> type -> INT         20 - 29
        local.k := id.INT(0(INT))
        
        local.j := id.INT(1(INT))
        
        local.i := INT (BOOL (local.j + local.k))
        check.INT(local.i, 1(INT), "INT-20")
        
        local.j := id.INT(77(INT))
        
        local.i := INT (BYTE (local.j + local.k))
        check.INT(local.i, 77(INT), "INT-21")
        local.i := INT (INT (local.j + local.k))
        check.INT(local.i, 77(INT), "INT-22")
        local.i := INT (INT16 (local.j + local.k))
        check.INT(local.i, 77(INT), "INT-23")
        local.i := INT (INT32 (local.j + local.k))
        check.INT(local.i, 77(INT), "INT-24")
        local.i := INT (INT64 (local.j + local.k))
        check.INT(local.i, 77(INT), "INT-25")
        local.i := INT ROUND (REAL32 ROUND (local.j + local.k))
        check.INT(local.i, 77(INT), "INT-26")
        local.i := INT ROUND (REAL64 ROUND (local.j + local.k))
        check.INT(local.i, 77(INT), "INT-27")
        --}}}
        --{{{  type var -> INT                  30 - 39
        bool.var := BOOL id(1)
        local.i := INT bool.var
        check.INT(local.i, 1(INT), "INT-30")
        byte.var := BYTE id(77)
        local.i := INT byte.var
        check.INT(local.i, 77(INT), "INT-31")
        int.var := id.INT(77(INT))
        local.i := INT int.var
        check.INT(local.i, 77(INT), "INT-32")
        i16.var := id.INT16(77(INT16))
        local.i := INT i16.var
        check.INT(local.i, 77(INT), "INT-33")
        i32.var := id.INT32(77(INT32))
        local.i := INT i32.var
        check.INT(local.i, 77(INT), "INT-34")
        i64.var := id.INT64(77(INT64))
        local.i := INT i64.var
        check.INT(local.i, 77(INT), "INT-35")
        r32.var := id.REAL32(77.0(REAL32))
        local.i := INT ROUND r32.var
        check.INT(local.i, 77(INT), "INT-36")
        r64.var := id.REAL64(77.0(REAL64))
        local.i := INT ROUND r64.var
        check.INT(local.i, 77(INT), "INT-37")
        --}}}
        --{{{  type FUNCTION -> INT             40 - 49
        local.i := INT BOOL.fn(zero)
        check.INT(local.i, 0(INT), "INT-40")
        local.i := INT BYTE.fn(int)
        check.INT(local.i, 77(INT), "INT-41")
        local.i := INT INT.fn(int)
        check.INT(local.i, 77(INT), "INT-42")
        local.i := INT INT16.fn(int)
        check.INT(local.i, 77(INT), "INT-43")
        local.i := INT INT32.fn(int)
        check.INT(local.i, 77(INT), "INT-44")
        local.i := INT INT64.fn(int)
        check.INT(local.i, 77(INT), "INT-45")
        local.i := INT ROUND REAL32.fn(int)
        check.INT(local.i, 77(INT), "INT-46")
        local.i := INT ROUND REAL64.fn(int)
        check.INT(local.i, 77(INT), "INT-47")
        --}}}
        --{{{  type exp -> INT                  50 - 59
        bool.var := BOOL id(1)
        local.i := INT (bool.var = bool.var)
        check.INT(local.i, 1(INT), "INT-50")
        byte.var := BYTE id(77)
        local.i := INT byte.var
        check.INT(local.i, 77(INT), "INT-51")
        int.var := id.INT(77(INT))
        local.i := INT (int.var + (INT   zero))
        check.INT(local.i, 77(INT), "INT-52")
        i16.var := id.INT16(77(INT16))
        local.i := INT (i16.var + (INT16 zero))
        check.INT(local.i, 77(INT), "INT-53")
        i32.var := id.INT32(77(INT32))
        local.i := INT (i32.var + (INT32 zero))
        check.INT(local.i, 77(INT), "INT-54")
        i64.var := id.INT64(77(INT64))
        local.i := INT (i64.var + (INT64 zero))
        check.INT(local.i, 77(INT), "INT-55")
        r32.var := id.REAL32(77.0(REAL32))
        local.i := INT ROUND (r32.var + (REAL32 ROUND zero))
        check.INT(local.i, 77(INT), "INT-56")
        r64.var := id.REAL64(77.0(REAL64))
        local.i := INT ROUND (r64.var + (REAL64 ROUND zero))
        check.INT(local.i, 77(INT), "INT-57")
        --}}}
    :
    bug.INSdi02195()
    --}}}
    --{{{  bug INSdi02423
    PROC bug.INSdi02423()
    
      PROC CheckOverflow ( VAL INT address, INT result)
        result := address
      :  
    
      PROC local(VAL INT Areg, Breg, VAL INT expected0, expected1, VAL []BYTE msg)
        INT XBreg, XAreg, Xtimes :
        INT result0, result1 :
        SEQ
          CheckOverflow ( (INT Breg)TIMES(INT Areg), result0 )
          XBreg := (INT Breg)
          XAreg := (INT Areg)
          Xtimes := XAreg TIMES XBreg
          CheckOverflow (Xtimes, result1)
          check.INT(result0, expected0, msg)
          check.INT(result1, expected0, msg)
    
          CheckOverflow ( (INT Breg)*(INT Areg), result0 )
          Xtimes := XAreg * XBreg
          CheckOverflow (Xtimes, result1)
          check.INT(result0, expected0, msg)
          check.INT(result1, expected0, msg)
    
          CheckOverflow ( (INT Breg)+(INT Areg), result0 )
          Xtimes := XAreg + XBreg
          CheckOverflow (Xtimes, result1)
          check.INT(result0, expected1, msg)
          check.INT(result1, expected1, msg)
    
          CheckOverflow ( (INT Breg)PLUS(INT Areg), result0 )
          Xtimes := XAreg PLUS XBreg
          CheckOverflow (Xtimes, result1)
          check.INT(result0, expected1, msg)
          check.INT(result1, expected1, msg)
      :
      SEQ
        local(    1,     2,     2(INT),  3(INT), "di2423a")
        local(    2,     1,     2(INT),  3(INT), "di2423b")
        local(   -1,     2,    -2(INT),  1(INT), "di2423c")
        local(    1,    -2,    -2(INT), -1(INT), "di2423d")
        local(   -1,     1,    -1(INT),  0(INT), "di2423e")
        local(    1,    -1,    -1(INT),  0(INT), "di2423f")
        local(    1,     0,     0(INT),  1(INT), "di2423g")
        local(    0,     1,     0(INT),  1(INT), "di2423h")
        local(    0,    -1,     0(INT), -1(INT), "di2423i")
        local(   -1,     0,     0(INT), -1(INT), "di2423j")
    :
    bug.INSdi02423()
    --}}}
    --{{{  bug INSdi02439
    PROC bug.INSdi02439()
      SEQ
        PROTOCOL CONTROL  IS  INT; INT :
        CHAN OF CONTROL ControlToMonitor:
        PAR
          SEQ
            SEQ i = 0 FOR 4
              INT   ii :
              INT j :
              SEQ
                ControlToMonitor ? ii; j
                check(i, INT j, "di2439a")
                check(i, ii,    "di2439b")
          SEQ i = 0 FOR 4
            ControlToMonitor ! i; INT i
    :
    bug.INSdi02439()
    --}}}
:
do.INT ()
