(fate_version 1)

(global string test_name)

(set test_name ( MERGE ))

(local int i)
(local int j)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; BASIC TEST 0 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (list int) li0)
(global (list int) li0oa)
(global (list int) li0ob)
(global (list int) li1)
(global (list int) li1oa)
(global (list int) li1ob)

(set li0
   (merge_to_list
      (lambda
         (
            (int a)
            (int b)
         )
         (- a b)
      )
      (range 10 40 1)
      (range 0 60 2)
   )
)

(set li0oa
   (merge_to_list
      (lambda
         (
            (int a)
            (int b)
         )
         (- a b)
      )
      (range 10 70 1)
      (range 0 60 2)
   )
)

(set li0ob
   (merge_to_list
      (lambda
         (
            (int a)
            (int b)
         )
         (- a b)
      )
      (range 10 40 1)
      (range 0 80 2)
   )
)

(set li1 (range 10 40 1))
(set li1oa (range 10 60 1))
(set li1ob (range 10 40 1))

(merge!
   (lambda
      (
         (int a)
         (int b)
      )
      (- a b)
   )
   li1
   (range 0 60 2)
)

(merge!
   (lambda
      (
         (int a)
         (int b)
      )
      (- a b)
   )
   li1oa
   (range 0 60 2)
)

(merge!
   (lambda
      (
         (int a)
         (int b)
      )
      (- a b)
   )
   li1ob
   (range 0 160 2)
)

(assert
   (= (var li1) (var li0) (var li0oa) (var li0ob) (var li1oa) (var li1ob))
   [FAILED] (var test_name) Equality test 0.
)

(for (set i 0) (=< i 30) (set i (+ i 1))
   (assert
      (=
         (- (+ 10 i) (* 2 i))
         (access li0 i)
         (access li0oa i)
         (access li0ob i)
         (access li1 i)
         (access li1oa i)
         (access li1ob i)
      )
      [FAILED] (var test_name) Basic test 0, index (var i), values:
      Expected: (- (+ 10 i) (* 2 i));
      li0: (access li0 i);
      li0oa: (access li0oa i);
      li0ob: (access li0ob i);
      li1: (access li1 i);
      li1oa: (access li1oa i);
      li1ob: (access li1ob i)
   )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; BASIC TEST 1 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (set int) si0)
(global (set int) si0oa)
(global (set int) si0ob)
(global (set int) si1)
(global (set int) si1oa)
(global (set int) si1ob)

(set si0
   (merge_to_set
      (lambda
         (
            (int a)
            (int b)
         )
         (- a b)
      )
      (range 10 40 1)
      (range 0 60 2)
   )
)

(set si0oa
   (merge_to_set
      (lambda
         (
            (int a)
            (int b)
         )
         (- a b)
      )
      (range 10 70 1)
      (range 0 60 2)
   )
)

(set si0ob
   (merge_to_set
      (lambda
         (
            (int a)
            (int b)
         )
         (- a b)
      )
      (range 10 40 1)
      (range 0 80 2)
   )
)

(add_all! (range 10 40 1) si1)
(add_all! (range 10 60 1) si1oa)
(add_all! (range 10 40 1) si1ob)

(merge!
   (lambda
      (
         (int a)
         (int b)
      )
      (- a b)
   )
   si1
   (range 0 60 2)
)

(merge!
   (lambda
      (
         (int a)
         (int b)
      )
      (- a b)
   )
   si1oa
   (range 0 60 2)
)

(merge!
   (lambda
      (
         (int a)
         (int b)
      )
      (- a b)
   )
   si1ob
   (range 0 80 2)
)

(assert
   (= (var si0) (var si0oa) (var si0ob) (var si1) (var si1oa) (var si1ob))
   [FAILED] (var test_name) Equality test 1.
)

(for
   (
      (set i 0)
      (set j 30)
   )
   (=< i 30)
   (
      (set i (+ i 1))
      (set j (- j 1))
   )
   (assert
      (=
         (- (+ 10 j) (* 2 j))
         (access si0 i)
         (access si0oa i)
         (access si0ob i)
         (access si1 i)
         (access si1oa i)
         (access si1ob i)
      )
      [FAILED] (var test_name) Basic test 1, index (var i), values:
      Expected: (- (+ 10 j) (* 2 j));
      si0: (access si0 i);
      si0oa: (access si0oa i);
      si0ob: (access si0ob i);
      si1: (access si1 i);
      si1oa: (access si1oa i);
      si1ob: (access si1ob i);
   )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; BASIC TEST 2 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (set int) si2)
(global (set int) si2oa)
(global (set int) si2ob)
(global (set int) si3)
(global (set int) si3oa)
(global (set int) si3ob)

(set si2
   (merge_to_set
      (lambda
         (
            (int a)
            (int b)
            (int mod)
         )
         (* (- a b) mod)
      )
      (range 10 40 1)
      (range 0 60 2)
      -1
   )
)

(set si2oa
   (merge_to_set
      (lambda
         (
            (int a)
            (int b)
            (int mod)
         )
         (* (- a b) mod)
      )
      (range 10 80 1)
      (range 0 60 2)
      -1
   )
)

(set si2ob
   (merge_to_set
      (lambda
         (
            (int a)
            (int b)
            (int mod)
         )
         (* (- a b) mod)
      )
      (range 10 40 1)
      (range 0 80 2)
      -1
   )
)

(add_all! (range 10 40 1) si3)
(add_all! (range 10 80 1) si3oa)
(add_all! (range 10 40 1) si3ob)

(merge!
   (lambda
      (
         (int a)
         (int b)
         (int mod)
      )
      (* (- a b) mod)
   )
   si3
   (range 0 60 2)
   -1
)

(merge!
   (lambda
      (
         (int a)
         (int b)
         (int mod)
      )
      (* (- a b) mod)
   )
   si3oa
   (range 0 60 2)
   -1
)

(merge!
   (lambda
      (
         (int a)
         (int b)
         (int mod)
      )
      (* (- a b) mod)
   )
   si3ob
   (range 0 90 2)
   -1
)

(assert
   (= (var si2) (var si2oa) (var si2ob) (var si3) (var si3oa) (var si3ob))
   [FAILED] (var test_name) Equality test 2.
)

(for
   (set i 0)
   (=< i 30)
   (set i (+ i 1))
   (assert
      (=
         (* (- (+ 10 i) (* 2 i)) -1)
         (access si2 i)
         (access si2oa i)
         (access si2ob i)
         (access si3 i)
         (access si3oa i)
         (access si3ob i)
      )
      [FAILED] (var test_name) Basic test 2, index (var i), values:
      Expected: (* (- (+ 10 i) (* 2 i)) -1);
      si2: (access si2 i);
      si2oa: (access si2oa i);
      si2ob: (access si2ob i);
      si3: (access si3 i);
      si3oa: (access si3oa i);
      si3ob: (access si3ob i)
   )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; INDEXED TEST 0 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (list int) ili0)
(global (list int) ili0oa)
(global (list int) ili0ob)
(global (list int) ili1)
(global (list int) ili1oa)
(global (list int) ili1ob)

(set ili0
   (indexed_merge_to_list
      (lambda
         (
            (int i)
            (int a)
            (int b)
         )
         (* (- a b) i)
      )
      (range 10 40 1)
      (range 0 60 2)
   )
)

(set ili0oa
   (indexed_merge_to_list
      (lambda
         (
            (int i)
            (int a)
            (int b)
         )
         (* (- a b) i)
      )
      (range 10 70 1)
      (range 0 60 2)
   )
)

(set ili0ob
   (indexed_merge_to_list
      (lambda
         (
            (int i)
            (int a)
            (int b)
         )
         (* (- a b) i)
      )
      (range 10 40 1)
      (range 0 80 2)
   )
)

(set ili1 (range 10 40 1))
(set ili1oa (range 10 60 1))
(set ili1ob (range 10 40 1))

(indexed_merge!
   (lambda
      (
         (int i)
         (int a)
         (int b)
      )
      (* (- a b) i)
   )
   ili1
   (range 0 60 2)
)

(indexed_merge!
   (lambda
      (
         (int i)
         (int a)
         (int b)
      )
      (* (- a b) i)
   )
   ili1oa
   (range 0 60 2)
)

(indexed_merge!
   (lambda
      (
         (int i)
         (int a)
         (int b)
      )
      (* (- a b) i)
   )
   ili1ob
   (range 0 160 2)
)

(assert
   (= (var ili1) (var ili0) (var ili0oa) (var ili0ob) (var ili1oa) (var ili1ob))
   [FAILED] (var test_name) Equality test indexed 0.
)

(for (set i 0) (=< i 30) (set i (+ i 1))
   (assert
      (=
         (* (- (+ 10 i) (* 2 i)) i)
         (access ili0 i)
         (access ili0oa i)
         (access ili0ob i)
         (access ili1 i)
         (access ili1oa i)
         (access ili1ob i)
      )
      [FAILED] (var test_name) Indexed test 0, index (var i), values:
      Expected: (* (- (+ 10 i) (* 2 i)) i);
      ili0: (access ili0 i);
      ili0oa: (access ili0oa i);
      ili0ob: (access ili0ob i);
      ili1: (access ili1 i);
      ili1oa: (access ili1oa i);
      ili1ob: (access ili1ob i)
   )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; INDEXED TEST 1 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (set int) isi0)
(global (set int) isi0oa)
(global (set int) isi0ob)
(global (set int) isi1)
(global (set int) isi1oa)
(global (set int) isi1ob)

(set isi0
   (indexed_merge_to_set
      (lambda
         (
            (int i)
            (int a)
            (int b)
         )
         (* (- a b) (+ i 1))
      )
      (range 10 40 1)
      (range 0 60 2)
   )
)

(set isi0oa
   (indexed_merge_to_set
      (lambda
         (
            (int i)
            (int a)
            (int b)
         )
         (* (- a b) (+ i 1))
      )
      (range 10 70 1)
      (range 0 60 2)
   )
)

(set isi0ob
   (indexed_merge_to_set
      (lambda
         (
            (int i)
            (int a)
            (int b)
         )
         (* (- a b) (+ i 1))
      )
      (range 10 40 1)
      (range 0 80 2)
   )
)

(add_all! (range 10 40 1) isi1)
(add_all! (range 10 60 1) isi1oa)
(add_all! (range 10 40 1) isi1ob)

(indexed_merge!
   (lambda
      (
         (int i)
         (int a)
         (int b)
      )
      (* (- a b) (+ i 1))
   )
   isi1
   (range 0 60 2)
)

(indexed_merge!
   (lambda
      (
         (int i)
         (int a)
         (int b)
      )
      (* (- a b) (+ i 1))
   )
   isi1oa
   (range 0 60 2)
)

(indexed_merge!
   (lambda
      (
         (int i)
         (int a)
         (int b)
      )
      (* (- a b) (+ i 1))
   )
   isi1ob
   (range 0 80 2)
)

(assert
   (= (var isi0) (var isi0oa) (var isi0ob) (var isi1) (var isi1oa) (var isi1ob))
   [FAILED] (var test_name) Equality test indexed 1.
)

For reference, the values found in the sets are:
(for (set i 0) (=< i 30) (set i (+ i 1))
   (* (- (+ 10 i) (* 2 i)) (+ j i)) (newline)
)

(for
   (
      (set i 0)
      (set j 25)
   )
   (=< i 25)
   (
      (set i (+ i 1))
      (set j (- j 1))
   )
   (assert
      (=
         (* (- (+ 10 j) (* 2 j)) (+ j 1))
         (access isi0 i)
         (access isi0oa i)
         (access isi0ob i)
         (access isi1 i)
         (access isi1oa i)
         (access isi1ob i)
      )
      [FAILED] (var test_name) Indexed test 1, index (var i), values:
      Expected: (* (- (+ 10 j) (* 2 j)) (+ j 1));
      isi0: (access isi0 i);
      isi0oa: (access isi0oa i);
      isi0ob: (access isi0ob i);
      isi1: (access isi1 i);
      isi1oa: (access isi1oa i);
      isi1ob: (access isi1ob i);
   )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; INDEXED TEST 2 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global (set int) isi2)
(global (set int) isi2oa)
(global (set int) isi2ob)
(global (set int) isi3)
(global (set int) isi3oa)
(global (set int) isi3ob)

(set isi2
   (indexed_merge_to_set
      (lambda
         (
            (int i)
            (int a)
            (int b)
            (int mod)
         )
         (* (* (- a b) mod) (+ i 1))
      )
      (range 10 40 1)
      (range 0 60 2)
      -1
   )
)

(set isi2oa
   (indexed_merge_to_set
      (lambda
         (
            (int i)
            (int a)
            (int b)
            (int mod)
         )
         (* (* (- a b) mod) (+ i 1))
      )
      (range 10 80 1)
      (range 0 60 2)
      -1
   )
)

(set isi2ob
   (indexed_merge_to_set
      (lambda
         (
            (int i)
            (int a)
            (int b)
            (int mod)
         )
         (* (- a b) mod (+ i 1))
      )
      (range 10 40 1)
      (range 0 80 2)
      -1
   )
)

(add_all! (range 10 40 1) isi3)
(add_all! (range 10 80 1) isi3oa)
(add_all! (range 10 40 1) isi3ob)

(indexed_merge!
   (lambda
      (
         (int i)
         (int a)
         (int b)
         (int mod)
      )
      (* (- a b) mod (+ i 1))
   )
   isi3
   (range 0 60 2)
   -1
)

(indexed_merge!
   (lambda
      (
         (int i)
         (int a)
         (int b)
         (int mod)
      )
      (* (- a b) mod (+ i 1))
   )
   isi3oa
   (range 0 60 2)
   -1
)

(indexed_merge!
   (lambda
      (
         (int i)
         (int a)
         (int b)
         (int mod)
      )
      (* (- a b) mod (+ i 1))
   )
   isi3ob
   (range 0 90 2)
   -1
)

(assert
   (= (var isi2) (var isi2oa) (var isi2ob) (var isi3) (var isi3oa) (var isi3ob))
   [FAILED] (var test_name) Equality test indexed 2.
)

(for
   (set i 0)
   (=< i 25)
   (set i (+ i 1))
   (assert
      (=
         (* (* (- (+ 10 i) (* 2 i)) -1) (+ i 1))
         (access isi2 i)
         (access isi2oa i)
         (access isi2ob i)
         (access isi3 i)
         (access isi3oa i)
         (access isi3ob i)
      )
      [FAILED] (var test_name) Indexed test 2, index (var i), values:
      Expected: (* (* (- (+ 10 i) (* 2 i)) -1) (+ i 1));
      isi2: (access isi2 i);
      isi2oa: (access isi2oa i);
      isi2ob: (access isi2ob i);
      isi3: (access isi3 i);
      isi3oa: (access isi3oa i);
      isi3ob: (access isi3ob i)
   )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; DEFAULT_VALUES TEST 0 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; TODO

[COMPLETED] (var test_name)

(end)