       (1:0) const                    <--         (1:0) const
             ^                                          ^

       (1:6) nst squar                <--         (1:6) nst squar
                 ^                                          ^

      (1:12) uare = (x                <--        (1:12) uare = fu
                 ^                                          ^

      (1:16)  = (x: nu                <--        (1:15) e = funct
                 ^                                          ^

       (1:6) nst squar                <--        (1:24) ion squar
                 ^                                          ^

      (1:12) uare = (x                <--        (1:30) uare(x) {
                 ^                                          ^

      (1:16)  = (x: nu                <--        (1:31) are(x) {
                 ^                                          ^

      (1:25) mber): nu                <--        (1:32) re(x) {
                 ^                                          ^

      (1:25) mber): nu                <--         (2:2)   retur
                 ^                                        ^

      (1:38)  => x * x                <--         (2:9) urn x * x
                 ^                                          ^

      (1:39) => x * x;                <--        (2:10) rn x * x;
                 ^                                          ^

      (1:42) x * x;                   <--        (2:13) x * x;
                 ^                                          ^

      (1:43)  * x;                    <--        (2:14)  * x;
                 ^                                          ^

      (1:43)  * x;                    <--         (3:0) };
                 ^                                      ^

       (2:0) const                    <--         (4:0) const
             ^                                          ^

       (2:6) nst greet                <--         (4:6) nst greet
                 ^                                          ^

      (2:11) reet = (n                <--        (4:11) reet = fu
                 ^                                          ^

      (2:15)  = (name:                <--        (4:14) t = funct
                 ^                                          ^

       (2:6) nst greet                <--        (4:23) ion greet
                 ^                                          ^

      (2:11) reet = (n                <--        (4:28) reet(name
                 ^                                          ^

      (2:15)  = (name:                <--        (4:29) eet(name)
                 ^                                          ^

      (2:27) ring): st                <--        (4:33) name) {
                 ^                                          ^

      (2:27) ring): st                <--         (5:2)   retur
                 ^                                        ^

      (2:40)  => "Hell                <--         (5:9) urn "Hell
                 ^                                          ^

      (2:49) o, " + na                <--        (5:18) o, " + na
                 ^                                          ^

      (2:52) " + name;                <--        (5:21) " + name;
                 ^                                          ^

      (2:56) name;                    <--        (5:25) name;
                 ^                                          ^

      (2:56) name;                    <--         (6:0) };
                 ^                                      ^
