initialise-binding initialise-storing initialise-giving finalise-failing finalise-throwing scope
  (collateral (bind
    ("init",
     allocate-variable (functions
       (tuples ((values)*),
        values))),
  bind
    ("printArray",
     allocate-variable (functions
       (tuples ((values)*),
        values))),
  bind
    ("reverse",
     allocate-variable (functions
       (tuples ((values)*),
        values))),
  bind
    ("map",
     allocate-variable (functions
       (tuples ((values)*),
        values))),
  bind
    ("insertionSort",
     allocate-variable (functions
       (tuples ((values)*),
        values))),
  bind
    ("bubbleSort",
     allocate-variable (functions
       (tuples ((values)*),
        values))),
  bind
    ("siftDown",
     allocate-variable (functions
       (tuples ((values)*),
        values))),
  bind
    ("heapSort",
     allocate-variable (functions
       (tuples ((values)*),
        values))),
  bind
    ("main",
     allocate-variable (functions
       (tuples ((values)*),
        values)))),
   sequential (assign
     (bound ("init"),
      function closure (scope
        (match
          (given,
           tuple (pattern closure (bind
             ("n",
              allocate-initialised-variable
                (values,
                 given))))),
         handle-return (scope
           (bind
             ("x",
              allocate-nested-vectors (assigned (bound ("n")))),
            sequential
              (print ("Type ",
              assigned (bound ("n")),
              " numbers: "),
               scope
                 (bind
                   ("i",
                    allocate-initialised-variable
                      (values,
                       decimal-natural ("0"))),
                  while
                    (is-less-or-equal
                      (assigned (bound ("i")),
                       integer-subtract
                         (assigned (bound ("n")),
                          decimal-natural ("1"))),
                     sequential
                       (effect (give
                         (read,
                          sequential
                            (assign
                              (checked index
                                (integer-add
                                  (1,
                                   assigned (bound ("i"))),
                                 vector-elements (assigned (bound ("x")))),
                               given),
                             given))),
                        effect (give
                          (bound ("i"),
                           sequential
                             (assign
                               (given,
                                integer-add
                                  (assigned (given),
                                   1)),
                              assigned (given))))))),
               print ("Finished reading the ",
               assigned (bound ("n")),
               " numbers\n"),
               return (assigned (bound ("x"))))))))),
   assign
     (bound ("printArray"),
      function closure (scope
        (match
          (given,
           tuple (pattern closure (bind
             ("x",
              allocate-initialised-variable
                (values,
                 given))))),
         handle-return (sequential
           (print ("\n"),
            scope
              (bind
                ("i",
                 allocate-initialised-variable
                   (values,
                    decimal-natural ("0"))),
               while
                 (is-less-or-equal
                   (assigned (bound ("i")),
                    integer-subtract
                      (length (vector-elements (assigned (bound ("x")))),
                       decimal-natural ("1"))),
                  sequential
                    (print (assigned (checked index
                      (integer-add
                        (1,
                         assigned (bound ("i"))),
                       vector-elements (assigned (bound ("x"))))),
                    " "),
                     effect (give
                       (bound ("i"),
                        sequential
                          (assign
                            (given,
                             integer-add
                               (assigned (given),
                                1)),
                           assigned (given))))))),
            print ("\n")))))),
   assign
     (bound ("reverse"),
      function closure (scope
        (match
          (given,
           tuple (pattern closure (bind
             ("x",
              allocate-initialised-variable
                (values,
                 given))))),
         handle-return (scope
           (bind
             ("n",
              allocate-initialised-variable
                (values,
                 length (vector-elements (assigned (bound ("x")))))),
            scope
              (bind
                ("i",
                 allocate-initialised-variable
                   (values,
                    decimal-natural ("0"))),
               while
                 (is-less-or-equal
                   (assigned (bound ("i")),
                    integer-subtract
                      (checked integer-divide
                        (assigned (bound ("n")),
                         decimal-natural ("2")),
                       decimal-natural ("1"))),
                  sequential
                    (scope
                      (bind
                        ("t",
                         allocate-initialised-variable
                           (values,
                            assigned (checked index
                              (integer-add
                                (1,
                                 assigned (bound ("i"))),
                               vector-elements (assigned (bound ("x"))))))),
                       sequential
                         (effect (give
                           (assigned (checked index
                             (integer-add
                               (1,
                                integer-subtract
                                  (integer-subtract
                                    (assigned (bound ("n")),
                                     assigned (bound ("i"))),
                                   decimal-natural ("1"))),
                              vector-elements (assigned (bound ("x"))))),
                            sequential
                              (assign
                                (checked index
                                  (integer-add
                                    (1,
                                     assigned (bound ("i"))),
                                   vector-elements (assigned (bound ("x")))),
                                 given),
                               given))),
                          effect (give
                            (assigned (bound ("t")),
                             sequential
                               (assign
                                 (checked index
                                   (integer-add
                                     (1,
                                      integer-subtract
                                        (integer-subtract
                                          (assigned (bound ("n")),
                                           assigned (bound ("i"))),
                                         decimal-natural ("1"))),
                                    vector-elements (assigned (bound ("x")))),
                                  given),
                                given))))),
                     effect (give
                       (bound ("i"),
                        sequential
                          (assign
                            (given,
                             integer-add
                               (assigned (given),
                                1)),
                           assigned (given)))))))))))),
   assign
     (bound ("map"),
      function closure (scope
        (match
          (given,
           tuple (pattern closure (bind
             ("m",
              allocate-initialised-variable
                (values,
                 given))),
           pattern closure (bind
             ("f",
              allocate-initialised-variable
                (values,
                 given))),
           pattern closure (bind
             ("x",
              allocate-initialised-variable
                (values,
                 given))))),
         handle-return (scope
           (bind
             ("i",
              allocate-initialised-variable
                (values,
                 decimal-natural ("0"))),
            while
              (is-less-or-equal
                (assigned (bound ("i")),
                 integer-subtract
                   (length (vector-elements (assigned (bound ("f")))),
                    decimal-natural ("1"))),
               sequential
                 (sequential
                   (print (assigned (checked index
                     (integer-add
                       (1,
                        assigned (bound ("i"))),
                      vector-elements (assigned (bound ("m")))))),
                    effect (apply
                      (assigned (checked index
                        (integer-add
                          (1,
                           assigned (bound ("i"))),
                         vector-elements (assigned (bound ("f"))))),
                       tuple (assigned (bound ("x")))))),
                  effect (give
                    (bound ("i"),
                     sequential
                       (assign
                         (given,
                          integer-add
                            (assigned (given),
                             1)),
                        assigned (given))))))))))),
   assign
     (bound ("insertionSort"),
      function closure (scope
        (match
          (given,
           tuple (pattern closure (bind
             ("x",
              allocate-initialised-variable
                (values,
                 given))))),
         handle-return (scope
           (bind
             ("i",
              allocate-initialised-variable
                (values,
                 decimal-natural ("1"))),
            while
              (is-less-or-equal
                (assigned (bound ("i")),
                 integer-subtract
                   (length (vector-elements (assigned (bound ("x")))),
                    decimal-natural ("1"))),
               sequential
                 (scope
                   (bind
                     ("v",
                      allocate-initialised-variable
                        (values,
                         assigned (checked index
                           (integer-add
                             (1,
                              assigned (bound ("i"))),
                            vector-elements (assigned (bound ("x"))))))),
                    scope
                      (bind
                        ("j",
                         allocate-initialised-variable
                           (values,
                            integer-subtract
                              (assigned (bound ("i")),
                               decimal-natural ("1")))),
                       sequential
                         (while
                           (if-else
                             (is-greater
                               (assigned (bound ("j")),
                                decimal-natural ("0")),
                              is-greater
                                (assigned (checked index
                                  (integer-add
                                    (1,
                                     assigned (bound ("j"))),
                                   vector-elements (assigned (bound ("x"))))),
                                 assigned (bound ("v"))),
                              false),
                            sequential
                              (effect (give
                                (assigned (checked index
                                  (integer-add
                                    (1,
                                     assigned (bound ("j"))),
                                   vector-elements (assigned (bound ("x"))))),
                                 sequential
                                   (assign
                                     (checked index
                                       (integer-add
                                         (1,
                                          integer-add
                                            (assigned (bound ("j")),
                                             decimal-natural ("1"))),
                                        vector-elements (assigned (bound ("x")))),
                                      given),
                                    given))),
                               effect (give
                                 (integer-subtract
                                   (assigned (bound ("j")),
                                    decimal-natural ("1")),
                                  sequential
                                    (assign
                                      (bound ("j"),
                                       given),
                                     given))))),
                          if-else
                            (is-greater
                              (assigned (checked index
                                (integer-add
                                  (1,
                                   decimal-natural ("0")),
                                 vector-elements (assigned (bound ("x"))))),
                               assigned (bound ("v"))),
                             sequential
                               (effect (give
                                 (assigned (checked index
                                   (integer-add
                                     (1,
                                      decimal-natural ("0")),
                                    vector-elements (assigned (bound ("x"))))),
                                  sequential
                                    (assign
                                      (checked index
                                        (integer-add
                                          (1,
                                           decimal-natural ("1")),
                                         vector-elements (assigned (bound ("x")))),
                                       given),
                                     given))),
                                effect (give
                                  (assigned (bound ("v")),
                                   sequential
                                     (assign
                                       (checked index
                                         (integer-add
                                           (1,
                                            decimal-natural ("0")),
                                          vector-elements (assigned (bound ("x")))),
                                        given),
                                      given)))),
                             effect (give
                               (assigned (bound ("v")),
                                sequential
                                  (assign
                                    (checked index
                                      (integer-add
                                        (1,
                                         integer-add
                                           (assigned (bound ("j")),
                                            decimal-natural ("1"))),
                                       vector-elements (assigned (bound ("x")))),
                                     given),
                                   given))))))),
                  effect (give
                    (bound ("i"),
                     sequential
                       (assign
                         (given,
                          integer-add
                            (assigned (given),
                             1)),
                        assigned (given))))))))))),
   assign
     (bound ("bubbleSort"),
      function closure (scope
        (match
          (given,
           tuple (pattern closure (bind
             ("v",
              allocate-initialised-variable
                (values,
                 given))))),
         handle-return (scope
           (bind
             ("n",
              allocate-initialised-variable
                (values,
                 length (vector-elements (assigned (bound ("v")))))),
            scope
              (bind
                ("i",
                 allocate-initialised-variable
                   (values,
                    decimal-natural ("0"))),
               while
                 (is-less-or-equal
                   (assigned (bound ("i")),
                    integer-subtract
                      (assigned (bound ("n")),
                       decimal-natural ("1"))),
                  sequential
                    (scope
                      (bind
                        ("j",
                         allocate-initialised-variable
                           (values,
                            decimal-natural ("0"))),
                       while
                         (is-less-or-equal
                           (assigned (bound ("j")),
                            integer-subtract
                              (assigned (bound ("n")),
                               decimal-natural ("2"))),
                          sequential
                            (if-else
                              (is-greater
                                (assigned (checked index
                                  (integer-add
                                    (1,
                                     assigned (bound ("j"))),
                                   vector-elements (assigned (bound ("v"))))),
                                 assigned (checked index
                                   (integer-add
                                     (1,
                                      integer-add
                                        (assigned (bound ("j")),
                                         decimal-natural ("1"))),
                                    vector-elements (assigned (bound ("v")))))),
                               scope
                                 (bind
                                   ("t",
                                    allocate-initialised-variable
                                      (values,
                                       assigned (checked index
                                         (integer-add
                                           (1,
                                            integer-add
                                              (assigned (bound ("j")),
                                               decimal-natural ("1"))),
                                          vector-elements (assigned (bound ("v"))))))),
                                  sequential
                                    (effect (give
                                      (assigned (checked index
                                        (integer-add
                                          (1,
                                           assigned (bound ("j"))),
                                         vector-elements (assigned (bound ("v"))))),
                                       sequential
                                         (assign
                                           (checked index
                                             (integer-add
                                               (1,
                                                integer-add
                                                  (assigned (bound ("j")),
                                                   decimal-natural ("1"))),
                                              vector-elements (assigned (bound ("v")))),
                                            given),
                                          given))),
                                     effect (give
                                       (assigned (bound ("t")),
                                        sequential
                                          (assign
                                            (checked index
                                              (integer-add
                                                (1,
                                                 assigned (bound ("j"))),
                                               vector-elements (assigned (bound ("v")))),
                                             given),
                                           given))))),
                               null),
                             effect (give
                               (bound ("j"),
                                sequential
                                  (assign
                                    (given,
                                     integer-add
                                       (assigned (given),
                                        1)),
                                   assigned (given))))))),
                     effect (give
                       (bound ("i"),
                        sequential
                          (assign
                            (given,
                             integer-add
                               (assigned (given),
                                1)),
                           assigned (given)))))))))))),
   assign
     (bound ("siftDown"),
      function closure (scope
        (match
          (given,
           tuple (pattern closure (bind
             ("x",
              allocate-initialised-variable
                (values,
                 given))),
           pattern closure (bind
             ("root",
              allocate-initialised-variable
                (values,
                 given))),
           pattern closure (bind
             ("bottom",
              allocate-initialised-variable
                (values,
                 given))))),
         handle-return (scope
           (bind
             ("done",
              allocate-initialised-variable
                (values,
                 false)),
            scope
              (bind
                ("maxChild",
                 allocate-variable (values)),
               while
                 (if-else
                   (is-less-or-equal
                     (integer-multiply
                       (assigned (bound ("root")),
                        decimal-natural ("2")),
                      assigned (bound ("bottom"))),
                    not (assigned (bound ("done"))),
                    false),
                  sequential
                    (if-else
                      (is-equal
                        (integer-multiply
                          (assigned (bound ("root")),
                           decimal-natural ("2")),
                         assigned (bound ("bottom"))),
                       effect (give
                         (integer-multiply
                           (assigned (bound ("root")),
                            decimal-natural ("2")),
                          sequential
                            (assign
                              (bound ("maxChild"),
                               given),
                             given))),
                       if-else
                         (is-greater
                           (assigned (checked index
                             (integer-add
                               (1,
                                integer-multiply
                                  (assigned (bound ("root")),
                                   decimal-natural ("2"))),
                              vector-elements (assigned (bound ("x"))))),
                            assigned (checked index
                              (integer-add
                                (1,
                                 integer-add
                                   (integer-multiply
                                     (assigned (bound ("root")),
                                      decimal-natural ("2")),
                                    decimal-natural ("1"))),
                               vector-elements (assigned (bound ("x")))))),
                          effect (give
                            (integer-multiply
                              (assigned (bound ("root")),
                               decimal-natural ("2")),
                             sequential
                               (assign
                                 (bound ("maxChild"),
                                  given),
                                given))),
                          effect (give
                            (integer-add
                              (integer-multiply
                                (assigned (bound ("root")),
                                 decimal-natural ("2")),
                               decimal-natural ("1")),
                             sequential
                               (assign
                                 (bound ("maxChild"),
                                  given),
                                given))))),
                     if-else
                       (is-less
                         (assigned (checked index
                           (integer-add
                             (1,
                              assigned (bound ("root"))),
                            vector-elements (assigned (bound ("x"))))),
                          assigned (checked index
                            (integer-add
                              (1,
                               assigned (bound ("maxChild"))),
                             vector-elements (assigned (bound ("x")))))),
                        scope
                          (bind
                            ("t",
                             allocate-initialised-variable
                               (values,
                                assigned (checked index
                                  (integer-add
                                    (1,
                                     assigned (bound ("root"))),
                                   vector-elements (assigned (bound ("x"))))))),
                           sequential
                             (effect (give
                               (assigned (checked index
                                 (integer-add
                                   (1,
                                    assigned (bound ("maxChild"))),
                                  vector-elements (assigned (bound ("x"))))),
                                sequential
                                  (assign
                                    (checked index
                                      (integer-add
                                        (1,
                                         assigned (bound ("root"))),
                                       vector-elements (assigned (bound ("x")))),
                                     given),
                                   given))),
                              effect (give
                                (assigned (bound ("t")),
                                 sequential
                                   (assign
                                     (checked index
                                       (integer-add
                                         (1,
                                          assigned (bound ("maxChild"))),
                                        vector-elements (assigned (bound ("x")))),
                                      given),
                                    given))),
                              effect (give
                                (assigned (bound ("maxChild")),
                                 sequential
                                   (assign
                                     (bound ("root"),
                                      given),
                                    given))))),
                        effect (give
                          (true,
                           sequential
                             (assign
                               (bound ("done"),
                                given),
                              given)))))))))))),
   assign
     (bound ("heapSort"),
      function closure (scope
        (match
          (given,
           tuple (pattern closure (bind
             ("x",
              allocate-initialised-variable
                (values,
                 given))))),
         handle-return (scope
           (bind
             ("n",
              allocate-initialised-variable
                (values,
                 length (vector-elements (assigned (bound ("x")))))),
            scope
              (bind
                ("i",
                 allocate-initialised-variable
                   (values,
                    integer-subtract
                      (checked integer-divide
                        (assigned (bound ("n")),
                         decimal-natural ("2")),
                       decimal-natural ("1")))),
               sequential
                 (while
                   (is-greater-or-equal
                     (assigned (bound ("i")),
                      decimal-natural ("0")),
                    sequential
                      (effect (apply
                        (assigned (bound ("siftDown")),
                         tuple (assigned (bound ("x")),
                         assigned (bound ("i")),
                         integer-subtract
                           (assigned (bound ("n")),
                            decimal-natural ("1"))))),
                       effect (give
                         (integer-subtract
                           (assigned (bound ("i")),
                            decimal-natural ("1")),
                          sequential
                            (assign
                              (bound ("i"),
                               given),
                             given))))),
                  effect (give
                    (integer-subtract
                      (assigned (bound ("n")),
                       decimal-natural ("1")),
                     sequential
                       (assign
                         (bound ("i"),
                          given),
                        given))),
                  while
                    (is-greater-or-equal
                      (assigned (bound ("i")),
                       decimal-natural ("1")),
                     scope
                       (bind
                         ("t",
                          allocate-initialised-variable
                            (values,
                             assigned (checked index
                               (integer-add
                                 (1,
                                  decimal-natural ("0")),
                                vector-elements (assigned (bound ("x"))))))),
                        sequential
                          (effect (give
                            (assigned (checked index
                              (integer-add
                                (1,
                                 assigned (bound ("i"))),
                               vector-elements (assigned (bound ("x"))))),
                             sequential
                               (assign
                                 (checked index
                                   (integer-add
                                     (1,
                                      decimal-natural ("0")),
                                    vector-elements (assigned (bound ("x")))),
                                  given),
                                given))),
                           effect (give
                             (assigned (bound ("t")),
                              sequential
                                (assign
                                  (checked index
                                    (integer-add
                                      (1,
                                       assigned (bound ("i"))),
                                     vector-elements (assigned (bound ("x")))),
                                   given),
                                 given))),
                           effect (apply
                             (assigned (bound ("siftDown")),
                              tuple (assigned (bound ("x")),
                              decimal-natural ("0"),
                              integer-subtract
                                (assigned (bound ("i")),
                                 decimal-natural ("1"))))),
                           effect (give
                             (integer-subtract
                               (assigned (bound ("i")),
                                decimal-natural ("1")),
                              sequential
                                (assign
                                  (bound ("i"),
                                   given),
                                 given))))))))))))),
   assign
     (bound ("main"),
      function closure (scope
        (match
          (given,
           tuple ()),
         handle-return (sequential
           (print ("Size of the array to sort = "),
            scope
              (bind
                ("x",
                 allocate-initialised-variable
                   (values,
                    apply
                      (assigned (bound ("init")),
                       tuple (read)))),
               scope
                 (bind
                   ("m",
                    allocate-nested-vectors (decimal-natural ("11"))),
                  scope
                    (bind
                      ("f",
                       allocate-nested-vectors (decimal-natural ("11"))),
                     sequential
                       (effect (give
                         ("The original unsorted array is:",
                          sequential
                            (assign
                              (checked index
                                (integer-add
                                  (1,
                                   decimal-natural ("0")),
                                 vector-elements (assigned (bound ("m")))),
                               given),
                             given))),
                        effect (give
                          (assigned (bound ("printArray")),
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("0")),
                                  vector-elements (assigned (bound ("f")))),
                                given),
                              given))),
                        effect (give
                          ("Reversing the array ... ",
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("1")),
                                  vector-elements (assigned (bound ("m")))),
                                given),
                              given))),
                        effect (give
                          (assigned (bound ("reverse")),
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("1")),
                                  vector-elements (assigned (bound ("f")))),
                                given),
                              given))),
                        effect (give
                          ("Done!\nThe reversed array is:",
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("2")),
                                  vector-elements (assigned (bound ("m")))),
                                given),
                              given))),
                        effect (give
                          (assigned (bound ("printArray")),
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("2")),
                                  vector-elements (assigned (bound ("f")))),
                                given),
                              given))),
                        effect (give
                          ("Sorting the array using insertion sort ... ",
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("3")),
                                  vector-elements (assigned (bound ("m")))),
                                given),
                              given))),
                        effect (give
                          (assigned (bound ("insertionSort")),
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("3")),
                                  vector-elements (assigned (bound ("f")))),
                                given),
                              given))),
                        effect (give
                          ("Done!\nThe resulting array is:",
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("4")),
                                  vector-elements (assigned (bound ("m")))),
                                given),
                              given))),
                        effect (give
                          (assigned (bound ("printArray")),
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("4")),
                                  vector-elements (assigned (bound ("f")))),
                                given),
                              given))),
                        effect (give
                          ("Reversing the array ... ",
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("5")),
                                  vector-elements (assigned (bound ("m")))),
                                given),
                              given))),
                        effect (give
                          (assigned (bound ("reverse")),
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("5")),
                                  vector-elements (assigned (bound ("f")))),
                                given),
                              given))),
                        effect (give
                          ("Done!\nSorting the array using bubble sort ... ",
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("6")),
                                  vector-elements (assigned (bound ("m")))),
                                given),
                              given))),
                        effect (give
                          (assigned (bound ("bubbleSort")),
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("6")),
                                  vector-elements (assigned (bound ("f")))),
                                given),
                              given))),
                        effect (give
                          ("Done!\nThe resulting array is:",
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("7")),
                                  vector-elements (assigned (bound ("m")))),
                                given),
                              given))),
                        effect (give
                          (assigned (bound ("printArray")),
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("7")),
                                  vector-elements (assigned (bound ("f")))),
                                given),
                              given))),
                        effect (give
                          ("Reversing the array ... ",
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("8")),
                                  vector-elements (assigned (bound ("m")))),
                                given),
                              given))),
                        effect (give
                          (assigned (bound ("reverse")),
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("8")),
                                  vector-elements (assigned (bound ("f")))),
                                given),
                              given))),
                        effect (give
                          ("Done!\nSorting the array using heap sort ... ",
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("9")),
                                  vector-elements (assigned (bound ("m")))),
                                given),
                              given))),
                        effect (give
                          (assigned (bound ("heapSort")),
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("9")),
                                  vector-elements (assigned (bound ("f")))),
                                given),
                              given))),
                        effect (give
                          ("Done!\nThe resulting array is:",
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("10")),
                                  vector-elements (assigned (bound ("m")))),
                                given),
                              given))),
                        effect (give
                          (assigned (bound ("printArray")),
                           sequential
                             (assign
                               (checked index
                                 (integer-add
                                   (1,
                                    decimal-natural ("10")),
                                  vector-elements (assigned (bound ("f")))),
                                given),
                              given))),
                        effect (apply
                          (assigned (bound ("map")),
                           tuple (assigned (bound ("m")),
                           assigned (bound ("f")),
                           assigned (bound ("x")))))))))))))),
   apply
     (assigned (bound ("main")),
      tuple ())))