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

       (2:2)   Trace                  <--         (1:9) t { Trace
               ^                                            ^

      (2:10) eMap,                    <--        (1:17) eMap, eac
                 ^                                          ^

       (3:2)   eachM                  <--        (1:19) ap, eachM
               ^                                            ^

      (3:13) ping,                    <--        (1:30) ping } fr
                 ^                                          ^

       (5:7) rom "@jri                <--        (1:38) rom "@jri
                 ^                                          ^

      (5:34) ing";                    <--        (1:65) ing";
                 ^                                          ^

       (6:0) impor                    <--         (2:0) impor
             ^                                          ^

       (6:9) t { decod                <--         (2:9) t { decod
                 ^                                          ^

      (6:28) ings } fr                <--        (2:28) ings } fr
                 ^                                          ^

      (6:36) rom "@jri                <--        (2:36) rom "@jri
                 ^                                          ^

      (6:65) dec";                    <--        (2:65) dec";
                 ^                                          ^

       (8:0) const                    <--         (3:0) const
             ^                                          ^

       (8:6) nst CONTE                <--         (3:6) nst CONTE
                 ^                                          ^

      (8:18) SIZE = 4;                <--        (3:18) SIZE = 4;
                 ^                                          ^

      (8:21) E = 4;                   <--        (3:21) E = 4;
                 ^                                          ^

      (8:22)  = 4;                    <--        (3:22)  = 4;
                 ^                                          ^

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

       (9:6) nst LOC_S                <--         (4:6) nst LOC_S
                 ^                                          ^

      (9:14) SIZE = 10                <--        (4:14) SIZE = 10
                 ^                                          ^

      (9:17) E = 10;                  <--        (4:17) E = 10;
                 ^                                          ^

      (9:19) = 10;                    <--        (4:19) = 10;
                 ^                                          ^

      (10:0) const                    <--         (5:0) const
             ^                                          ^

      (10:6) nst CONTE                <--         (5:6) nst CONTE
                 ^                                          ^

     (10:18) SIZE = 15                <--        (5:18) SIZE = 15
                 ^                                          ^

     (10:21) E = 15;                  <--        (5:21) E = 15;
                 ^                                          ^

     (10:23) = 15;                    <--        (5:23) = 15;
                 ^                                          ^

      (12:0) funct                    <--         (6:0) funct
             ^                                          ^

      (12:9) ion simpl                <--         (6:9) ion simpl
                 ^                                          ^

     (12:29) oint(line                <--        (6:29) oint(line
                 ^                                          ^

     (12:30) int(lines                <--        (6:30) int(lines
                 ^                                          ^

     (12:45) ng[], lin                <--        (6:35) ines, lin
                 ^                                          ^

     (12:47) [], line:                <--        (6:37) es, line,
                 ^                                          ^

     (12:59) mber, col                <--        (6:41) line, col
                 ^                                          ^

     (12:61) er, col:                 <--        (6:43) ne, col)
                 ^                                          ^

     (12:72) mber) {                  <--        (6:46)  col) {
                 ^                                          ^

     (12:74) er) {                    <--        (6:48) ol) {
                 ^                                          ^

      (13:2)   const                  <--         (7:2)   const
               ^                                          ^

      (13:8) nst start                <--         (7:8) nst start
                 ^                                          ^

     (13:13) tart = Ma                <--        (7:13) tart = Ma
                 ^                                          ^

     (13:16) t = Math.                <--        (7:16) t = Math.
                 ^                                          ^

     (13:20) Math.max(                <--        (7:20) Math.max(
                 ^                                          ^

     (13:21) ath.max(c                <--        (7:21) ath.max(c
                 ^                                          ^

     (13:24) .max(col                 <--        (7:24) .max(col
                 ^                                          ^

     (13:25) max(col -                <--        (7:25) max(col -
                 ^                                          ^

     (13:28) (col - CO                <--        (7:28) (col - CO
                 ^                                          ^

     (13:31) l - CONTE                <--        (7:31) l - CONTE
                 ^                                          ^

     (13:43) SIZE, 0);                <--        (7:43) SIZE, 0);
                 ^                                          ^

     (13:45) ZE, 0);                  <--        (7:45) ZE, 0);
                 ^                                          ^

     (13:46) E, 0);                   <--        (7:46) E, 0);
                 ^                                          ^

     (13:47) , 0);                    <--        (7:47) , 0);
                 ^                                          ^

      (14:2)   const                  <--         (8:2)   const
               ^                                          ^

      (14:8) nst end =                <--         (8:8) nst end =
                 ^                                          ^

     (14:11)  end = Ma                <--        (8:11)  end = Ma
                 ^                                          ^

     (14:14) d = Math.                <--        (8:14) d = Math.
                 ^                                          ^

     (14:18) Math.min(                <--        (8:18) Math.min(
                 ^                                          ^

     (14:19) ath.min(c                <--        (8:19) ath.min(c
                 ^                                          ^

     (14:22) .min(col                 <--        (8:22) .min(col
                 ^                                          ^

     (14:23) min(col +                <--        (8:23) min(col +
                 ^                                          ^

     (14:26) (col + 1                 <--        (8:26) (col + 1
                 ^                                          ^

     (14:29) l + 1 + C                <--        (8:29) l + 1 + C
                 ^                                          ^

     (14:30)  + 1 + CO                <--        (8:30)  + 1 + CO
                 ^                                          ^

     (14:33) 1 + CONTE                <--        (8:33) 1 + CONTE
                 ^                                          ^

     (14:45) SIZE, lin                <--        (8:45) SIZE, lin
                 ^                                          ^

     (14:47) ZE, lines                <--        (8:47) ZE, lines
                 ^                                          ^

     (14:52) ines[line                <--        (8:52) ines[line
                 ^                                          ^

     (14:53) nes[line                 <--        (8:53) nes[line
                 ^                                          ^

     (14:57) line - 1]                <--        (8:57) line - 1]
                 ^                                          ^

     (14:60) e - 1].le                <--        (8:60) e - 1].le
                 ^                                          ^

     (14:61)  - 1].len                <--        (8:61)  - 1].len
                 ^                                          ^

     (14:62) - 1].leng                <--        (8:62) - 1].leng
                 ^                                          ^

     (14:63)  1].lengt                <--        (8:63)  1].lengt
                 ^                                          ^

     (14:69) ngth);                   <--        (8:69) ngth);
                 ^                                          ^

     (14:70) gth);                    <--        (8:70) gth);
                 ^                                          ^

      (16:2)   const                  <--         (9:2)   const
               ^                                          ^

      (16:8) nst code                 <--         (9:8) nst code
                 ^                                          ^

     (16:12) code = li                <--        (9:12) code = li
                 ^                                          ^

     (16:15) e = lines                <--        (9:15) e = lines
                 ^                                          ^

     (16:20) ines[line                <--        (9:20) ines[line
                 ^                                          ^

     (16:21) nes[line                 <--        (9:21) nes[line
                 ^                                          ^

     (16:25) line - 1]                <--        (9:25) line - 1]
                 ^                                          ^

     (16:28) e - 1].sl                <--        (9:28) e - 1].sl
                 ^                                          ^

     (16:29)  - 1].sli                <--        (9:29)  - 1].sli
                 ^                                          ^

     (16:30) - 1].slic                <--        (9:30) - 1].slic
                 ^                                          ^

     (16:31)  1].slice                <--        (9:31)  1].slice
                 ^                                          ^

     (16:36) lice(star                <--        (9:36) lice(star
                 ^                                          ^

     (16:37) ice(start                <--        (9:37) ice(start
                 ^                                          ^

     (16:42) tart, end                <--        (9:42) tart, end
                 ^                                          ^

     (16:44) rt, end);                <--        (9:44) rt, end);
                 ^                                          ^

     (16:47)  end);                   <--        (9:47)  end);
                 ^                                          ^

     (16:48) end);                    <--        (9:48) end);
                 ^                                          ^

      (17:2)   const                  <--        (10:2)   const
               ^                                          ^

      (17:8) nst loc =                <--        (10:8) nst loc =
                 ^                                          ^

     (17:11)  loc = `(                <--       (10:11)  loc = `(
                 ^                                          ^

     (17:14) c = `(${l                <--       (10:14) c = `(${l
                 ^                                          ^

     (17:18) `(${line}                <--       (10:18) `(${line}
                 ^                                          ^

     (17:22) line}:${c                <--       (10:22) line}:${c
                 ^                                          ^

     (17:26) }:${col})                <--       (10:26) }:${col})
                 ^                                          ^

     (17:29) {col}) `.                <--       (10:29) {col}) `.
                 ^                                          ^

     (17:33) }) `.padS                <--       (10:33) }) `.padS
                 ^                                          ^

     (17:34) ) `.padSt                <--       (10:34) ) `.padSt
                 ^                                          ^

     (17:42) tart(LOC_                <--       (10:42) tart(LOC_
                 ^                                          ^

     (17:43) art(LOC_S                <--       (10:43) art(LOC_S
                 ^                                          ^

     (17:51) SIZE, " "                <--       (10:51) SIZE, " "
                 ^                                          ^

     (17:53) ZE, " ");                <--       (10:53) ZE, " ");
                 ^                                          ^

     (17:56)  " ");                   <--       (10:56)  " ");
                 ^                                          ^

     (17:57) " ");                    <--       (10:57) " ");
                 ^                                          ^

      (18:2)   retur                  <--        (11:2)   retur
               ^                                          ^

      (18:9) urn loc +                <--        (11:9) urn loc +
                 ^                                          ^

     (18:12)  loc + co                <--       (11:12)  loc + co
                 ^                                          ^

     (18:15) c + code                 <--       (11:15) c + code
                 ^                                          ^

     (18:19) code + "\                <--       (11:19) code + "\
                 ^                                          ^

     (18:22) e + "\n"                 <--       (11:22) e + "\n"
                 ^                                          ^

     (18:26) "\n" + "                 <--       (11:26) "\n" + "
                 ^                                          ^

     (18:29) " + " ".r                <--       (11:29) " + " ".r
                 ^                                          ^

     (18:32)  " ".repe                <--       (11:32)  " ".repe
                 ^                                          ^

     (18:33) " ".repea                <--       (11:33) " ".repea
                 ^                                          ^

     (18:39) peat(col                 <--       (11:39) peat(col
                 ^                                          ^

     (18:40) eat(col -                <--       (11:40) eat(col -
                 ^                                          ^

     (18:43) (col - st                <--       (11:43) (col - st
                 ^                                          ^

     (18:46) l - start                <--       (11:46) l - start
                 ^                                          ^

     (18:51) tart + lo                <--       (11:51) tart + lo
                 ^                                          ^

     (18:54) t + loc.l                <--       (11:54) t + loc.l
                 ^                                          ^

     (18:57)  loc.leng                <--       (11:57)  loc.leng
                 ^                                          ^

     (18:58) loc.lengt                <--       (11:58) loc.lengt
                 ^                                          ^

     (18:64) ngth) + "                <--       (11:64) ngth) + "
                 ^                                          ^

     (18:65) gth) + "^                <--       (11:65) gth) + "^
                 ^                                          ^

     (18:68) ) + "^";                 <--       (11:68) ) + "^";
                 ^                                          ^

     (18:71)  "^";                    <--       (11:71)  "^";
                 ^                                          ^

      (19:0) }                        <--        (12:0) }
             ^                                          ^

      (21:0) funct                    <--        (13:0) funct
             ^                                          ^

      (21:9) ion simpl                <--        (13:9) ion simpl
                 ^                                          ^

     (21:29) ange(                    <--       (13:29) ange(line
                 ^                                          ^

      (22:2)   lines                  <--       (13:30) nge(lines
               ^                                            ^

     (22:17) ng[],                    <--       (13:35) ines, lin
                 ^                                          ^

      (23:2)   lineS                  <--       (13:37) es, lineS
               ^                                            ^

     (23:19) mber,                    <--       (13:46) tart, col
                 ^                                          ^

      (24:2)   colSt                  <--       (13:48) rt, colSt
               ^                                            ^

     (24:18) mber,                    <--       (13:56) tart, lin
                 ^                                          ^

      (25:2)   lineE                  <--       (13:58) rt, lineE
               ^                                            ^

     (25:17) mber,                    <--       (13:65) eEnd, col
                 ^                                          ^

      (26:2)   colEn                  <--       (13:67) nd, colEn
               ^                                            ^

     (26:16) mber,                    <--       (13:73) lEnd) {
                 ^                                          ^

      (27:2) ) {                      <--       (13:75) nd) {
               ^                                            ^

      (28:2)   colEn                  <--        (14:2)   colEn
               ^                                          ^

      (28:8) lEnd = Ma                <--        (14:8) lEnd = Ma
                 ^                                          ^

     (28:11) d = Math.                <--       (14:11) d = Math.
                 ^                                          ^

     (28:15) Math.min(                <--       (14:15) Math.min(
                 ^                                          ^

     (28:16) ath.min(c                <--       (14:16) ath.min(c
                 ^                                          ^

     (28:19) .min(colE                <--       (14:19) .min(colE
                 ^                                          ^

     (28:20) min(colEn                <--       (14:20) min(colEn
                 ^                                          ^

     (28:26) lEnd, lin                <--       (14:26) lEnd, lin
                 ^                                          ^

     (28:28) nd, lines                <--       (14:28) nd, lines
                 ^                                          ^

     (28:33) ines[line                <--       (14:33) ines[line
                 ^                                          ^

     (28:34) nes[lineS                <--       (14:34) nes[lineS
                 ^                                          ^

     (28:43) tart - 1]                <--       (14:43) tart - 1]
                 ^                                          ^

     (28:46) t - 1].le                <--       (14:46) t - 1].le
                 ^                                          ^

     (28:47)  - 1].len                <--       (14:47)  - 1].len
                 ^                                          ^

     (28:48) - 1].leng                <--       (14:48) - 1].leng
                 ^                                          ^

     (28:49)  1].lengt                <--       (14:49)  1].lengt
                 ^                                          ^

     (28:55) ngth);                   <--       (14:55) ngth);
                 ^                                          ^

     (28:56) gth);                    <--       (14:56) gth);
                 ^                                          ^

      (30:2)   const                  <--        (15:2)   const
               ^                                          ^

      (30:8) nst start                <--        (15:8) nst start
                 ^                                          ^

     (30:13) tart = Ma                <--       (15:13) tart = Ma
                 ^                                          ^

     (30:16) t = Math.                <--       (15:16) t = Math.
                 ^                                          ^

     (30:20) Math.max(                <--       (15:20) Math.max(
                 ^                                          ^

     (30:21) ath.max(c                <--       (15:21) ath.max(c
                 ^                                          ^

     (30:24) .max(colS                <--       (15:24) .max(colS
                 ^                                          ^

     (30:25) max(colSt                <--       (15:25) max(colSt
                 ^                                          ^

     (30:33) tart - CO                <--       (15:33) tart - CO
                 ^                                          ^

     (30:36) t - CONTE                <--       (15:36) t - CONTE
                 ^                                          ^

     (30:48) SIZE, 0);                <--       (15:48) SIZE, 0);
                 ^                                          ^

     (30:50) ZE, 0);                  <--       (15:50) ZE, 0);
                 ^                                          ^

     (30:51) E, 0);                   <--       (15:51) E, 0);
                 ^                                          ^

     (30:52) , 0);                    <--       (15:52) , 0);
                 ^                                          ^

      (31:2)   const                  <--        (16:2)   const
               ^                                          ^

      (31:8) nst end =                <--        (16:8) nst end =
                 ^                                          ^

     (31:11)  end = Ma                <--       (16:11)  end = Ma
                 ^                                          ^

     (31:14) d = Math.                <--       (16:14) d = Math.
                 ^                                          ^

     (31:18) Math.min(                <--       (16:18) Math.min(
                 ^                                          ^

     (31:19) ath.min(c                <--       (16:19) ath.min(c
                 ^                                          ^

     (31:22) .min(colE                <--       (16:22) .min(colE
                 ^                                          ^

     (31:23) min(colEn                <--       (16:23) min(colEn
                 ^                                          ^

     (31:29) lEnd + CO                <--       (16:29) lEnd + CO
                 ^                                          ^

     (31:32) d + CONTE                <--       (16:32) d + CONTE
                 ^                                          ^

     (31:44) SIZE, lin                <--       (16:44) SIZE, lin
                 ^                                          ^

     (31:46) ZE, lines                <--       (16:46) ZE, lines
                 ^                                          ^

     (31:51) ines[line                <--       (16:51) ines[line
                 ^                                          ^

     (31:52) nes[lineS                <--       (16:52) nes[lineS
                 ^                                          ^

     (31:61) tart - 1]                <--       (16:61) tart - 1]
                 ^                                          ^

     (31:64) t - 1].le                <--       (16:64) t - 1].le
                 ^                                          ^

     (31:65)  - 1].len                <--       (16:65)  - 1].len
                 ^                                          ^

     (31:66) - 1].leng                <--       (16:66) - 1].leng
                 ^                                          ^

     (31:67)  1].lengt                <--       (16:67)  1].lengt
                 ^                                          ^

     (31:73) ngth);                   <--       (16:73) ngth);
                 ^                                          ^

     (31:74) gth);                    <--       (16:74) gth);
                 ^                                          ^

      (33:2)   const                  <--        (17:2)   const
               ^                                          ^

      (33:8) nst marke                <--        (17:8) nst marke
                 ^                                          ^

     (33:18) Size = co                <--       (17:18) Size = co
                 ^                                          ^

     (33:21) e = colEn                <--       (17:21) e = colEn
                 ^                                          ^

     (33:27) lEnd - co                <--       (17:27) lEnd - co
                 ^                                          ^

     (33:30) d - colSt                <--       (17:30) d - colSt
                 ^                                          ^

     (33:38) tart;                    <--       (17:38) tart;
                 ^                                          ^

      (34:2)   const                  <--        (18:2)   const
               ^                                          ^

      (34:8) nst marke                <--        (18:8) nst marke
                 ^                                          ^

     (34:14) rker = ma                <--       (18:14) rker = ma
                 ^                                          ^

     (34:17) r = marke                <--       (18:17) r = marke
                 ^                                          ^

     (34:27) Size ===                 <--       (18:27) Size ===
                 ^                                          ^

     (34:32) === 0 ? "                <--       (18:32) === 0 ? "
                 ^                                          ^

     (34:33) == 0 ? ">                <--       (18:33) == 0 ? ">
                 ^                                          ^

     (34:36) 0 ? "><"                 <--       (18:36) 0 ? "><"
                 ^                                          ^

     (34:40) "><" : "                 <--       (18:40) "><" : "
                 ^                                          ^

     (34:43) " : " " +                <--       (18:43) " : " " +
                 ^                                          ^

     (34:46)  " " + "^                <--       (18:46)  " " + "^
                 ^                                          ^

     (34:49) " + "^".r                <--       (18:49) " + "^".r
                 ^                                          ^

     (34:52)  "^".repe                <--       (18:52)  "^".repe
                 ^                                          ^

     (34:53) "^".repea                <--       (18:53) "^".repea
                 ^                                          ^

     (34:59) peat(mark                <--       (18:59) peat(mark
                 ^                                          ^

     (34:60) eat(marke                <--       (18:60) eat(marke
                 ^                                          ^

     (34:70) Size);                   <--       (18:70) Size);
                 ^                                          ^

     (34:71) ize);                    <--       (18:71) ize);
                 ^                                          ^

      (35:2)   const                  <--        (19:2)   const
               ^                                          ^

      (35:8) nst marke                <--        (19:8) nst marke
                 ^                                          ^

     (35:21) ding = co                <--       (19:21) ding = co
                 ^                                          ^

     (35:24) g = colSt                <--       (19:24) g = colSt
                 ^                                          ^

     (35:32) tart - st                <--       (19:32) tart - st
                 ^                                          ^

     (35:35) t - start                <--       (19:35) t - start
                 ^                                          ^

     (35:40) tart - 1;                <--       (19:40) tart - 1;
                 ^                                          ^

     (35:43) t - 1;                   <--       (19:43) t - 1;
                 ^                                          ^

     (35:44)  - 1;                    <--       (19:44)  - 1;
                 ^                                          ^

      (37:2)   const                  <--        (20:2)   const
               ^                                          ^

      (37:8) nst code                 <--        (20:8) nst code
                 ^                                          ^

     (37:12) code = li                <--       (20:12) code = li
                 ^                                          ^

     (37:15) e = lines                <--       (20:15) e = lines
                 ^                                          ^

     (37:20) ines[line                <--       (20:20) ines[line
                 ^                                          ^

     (37:21) nes[lineS                <--       (20:21) nes[lineS
                 ^                                          ^

     (37:30) tart - 1]                <--       (20:30) tart - 1]
                 ^                                          ^

     (37:33) t - 1].sl                <--       (20:33) t - 1].sl
                 ^                                          ^

     (37:34)  - 1].sli                <--       (20:34)  - 1].sli
                 ^                                          ^

     (37:35) - 1].slic                <--       (20:35) - 1].slic
                 ^                                          ^

     (37:36)  1].slice                <--       (20:36)  1].slice
                 ^                                          ^

     (37:41) lice(star                <--       (20:41) lice(star
                 ^                                          ^

     (37:42) ice(start                <--       (20:42) ice(start
                 ^                                          ^

     (37:47) tart, end                <--       (20:47) tart, end
                 ^                                          ^

     (37:49) rt, end);                <--       (20:49) rt, end);
                 ^                                          ^

     (37:52)  end);                   <--       (20:52)  end);
                 ^                                          ^

     (37:53) end);                    <--       (20:53) end);
                 ^                                          ^

      (38:2)   const                  <--        (21:2)   const
               ^                                          ^

      (38:8) nst loc =                <--        (21:8) nst loc =
                 ^                                          ^

     (38:11)  loc = `(                <--       (21:11)  loc = `(
                 ^                                          ^

     (38:14) c = `(${l                <--       (21:14) c = `(${l
                 ^                                          ^

     (38:18) `(${lineS                <--       (21:18) `(${lineS
                 ^                                          ^

     (38:27) tart}:${c                <--       (21:27) tart}:${c
                 ^                                          ^

     (38:31) }:${colSt                <--       (21:31) }:${colSt
                 ^                                          ^

     (38:39) tart}-${c                <--       (21:39) tart}-${c
                 ^                                          ^

     (38:43) }-${colEn                <--       (21:43) }-${colEn
                 ^                                          ^

     (38:49) lEnd}) `.                <--       (21:49) lEnd}) `.
                 ^                                          ^

     (38:53) }) `.padS                <--       (21:53) }) `.padS
                 ^                                          ^

     (38:54) ) `.padSt                <--       (21:54) ) `.padSt
                 ^                                          ^

     (38:62) tart(LOC_                <--       (21:62) tart(LOC_
                 ^                                          ^

     (38:63) art(LOC_S                <--       (21:63) art(LOC_S
                 ^                                          ^

     (38:71) SIZE, " "                <--       (21:71) SIZE, " "
                 ^                                          ^

     (38:73) ZE, " ");                <--       (21:73) ZE, " ");
                 ^                                          ^

     (38:76)  " ");                   <--       (21:76)  " ");
                 ^                                          ^

     (38:77) " ");                    <--       (21:77) " ");
                 ^                                          ^

      (39:2)   retur                  <--        (22:2)   retur
               ^                                          ^

      (39:9) urn loc +                <--        (22:9) urn loc +
                 ^                                          ^

     (39:12)  loc + co                <--       (22:12)  loc + co
                 ^                                          ^

     (39:15) c + code                 <--       (22:15) c + code
                 ^                                          ^

     (39:19) code + "\                <--       (22:19) code + "\
                 ^                                          ^

     (39:22) e + "\n"                 <--       (22:22) e + "\n"
                 ^                                          ^

     (39:26) "\n" + "                 <--       (22:26) "\n" + "
                 ^                                          ^

     (39:29) " + " ".r                <--       (22:29) " + " ".r
                 ^                                          ^

     (39:32)  " ".repe                <--       (22:32)  " ".repe
                 ^                                          ^

     (39:33) " ".repea                <--       (22:33) " ".repea
                 ^                                          ^

     (39:39) peat(mark                <--       (22:39) peat(mark
                 ^                                          ^

     (39:40) eat(marke                <--       (22:40) eat(marke
                 ^                                          ^

     (39:53) ding + lo                <--       (22:53) ding + lo
                 ^                                          ^

     (39:56) g + loc.l                <--       (22:56) g + loc.l
                 ^                                          ^

     (39:59)  loc.leng                <--       (22:59)  loc.leng
                 ^                                          ^

     (39:60) loc.lengt                <--       (22:60) loc.lengt
                 ^                                          ^

     (39:66) ngth) + m                <--       (22:66) ngth) + m
                 ^                                          ^

     (39:67) gth) + ma                <--       (22:67) gth) + ma
                 ^                                          ^

     (39:70) ) + marke                <--       (22:70) ) + marke
                 ^                                          ^

     (39:76) rker;                    <--       (22:76) rker;
                 ^                                          ^

      (40:0) }                        <--        (23:0) }
             ^                                          ^

      (42:0) funct                    <--        (24:0) funct
             ^                                          ^

      (42:9) ion joinM                <--        (24:9) ion joinM
                 ^                                          ^

     (42:22) line(left                <--       (24:22) line(left
                 ^                                          ^

     (42:23) ine(left:                <--       (24:23) ine(left,
                 ^                                          ^

     (42:35) ring, rig                <--       (24:27) left, rig
                 ^                                          ^

     (42:37) ng, right                <--       (24:29) ft, right
                 ^                                          ^

     (42:50) ring, lef                <--       (24:34) ight, lef
                 ^                                          ^

     (42:52) ng, leftL                <--       (24:36) ht, leftL
                 ^                                          ^

     (42:68) mber) {                  <--       (24:43) tLen) {
                 ^                                          ^

     (42:70) er) {                    <--       (24:45) en) {
                 ^                                          ^

      (43:2)   const                  <--        (25:2)   const
               ^                                          ^

      (43:8) nst leftL                <--        (25:8) nst leftL
                 ^                                          ^

     (43:17) ines = le                <--       (25:17) ines = le
                 ^                                          ^

     (43:20) s = left.                <--       (25:20) s = left.
                 ^                                          ^

     (43:24) left.spli                <--       (25:24) left.spli
                 ^                                          ^

     (43:25) eft.split                <--       (25:25) eft.split
                 ^                                          ^

     (43:30) plit("\n"                <--       (25:30) plit("\n"
                 ^                                          ^

     (43:31) lit("\n")                <--       (25:31) lit("\n")
                 ^                                          ^

     (43:35) "\n");                   <--       (25:35) "\n");
                 ^                                          ^

     (43:36) \n");                    <--       (25:36) \n");
                 ^                                          ^

      (44:2)   const                  <--        (26:2)   const
               ^                                          ^

      (44:8) nst right                <--        (26:8) nst right
                 ^                                          ^

     (44:18) ines = ri                <--       (26:18) ines = ri
                 ^                                          ^

     (44:21) s = right                <--       (26:21) s = right
                 ^                                          ^

     (44:26) ight.spli                <--       (26:26) ight.spli
                 ^                                          ^

     (44:27) ght.split                <--       (26:27) ght.split
                 ^                                          ^

     (44:32) plit("\n"                <--       (26:32) plit("\n"
                 ^                                          ^

     (44:33) lit("\n")                <--       (26:33) lit("\n")
                 ^                                          ^

     (44:37) "\n");                   <--       (26:37) "\n");
                 ^                                          ^

     (44:38) \n");                    <--       (26:38) \n");
                 ^                                          ^

      (46:2)   leftL                  <--        (27:2)   leftL
               ^                                          ^

      (46:9) tLen ??=                 <--        (27:9) tLen ??=
                 ^                                          ^

     (46:14) ??= leftL                <--       (27:14) ??= leftL
                 ^                                          ^

     (46:23) ines.redu                <--       (27:23) ines.redu
                 ^                                          ^

     (46:24) nes.reduc                <--       (27:24) nes.reduc
                 ^                                          ^

     (46:30) duce((len                <--       (27:30) duce((len
                 ^                                          ^

     (46:31) uce((len,                <--       (27:31) uce((len,
                 ^                                          ^

     (46:32) ce((len,                 <--       (27:32) ce((len,
                 ^                                          ^

     (46:35) (len, lin                <--       (27:35) (len, lin
                 ^                                          ^

     (46:37) en, line)                <--       (27:37) en, line)
                 ^                                          ^

     (46:41) line) =>                 <--       (27:41) line) =>
                 ^                                          ^

     (46:46)  => Math.                <--       (27:46)  => Math.
                 ^                                          ^

     (46:50) Math.max(                <--       (27:50) Math.max(
                 ^                                          ^

     (46:51) ath.max(l                <--       (27:51) ath.max(l
                 ^                                          ^

     (46:54) .max(len,                <--       (27:54) .max(len,
                 ^                                          ^

     (46:55) max(len,                 <--       (27:55) max(len,
                 ^                                          ^

     (46:58) (len, lin                <--       (27:58) (len, lin
                 ^                                          ^

     (46:60) en, line.                <--       (27:60) en, line.
                 ^                                          ^

     (46:64) line.leng                <--       (27:64) line.leng
                 ^                                          ^

     (46:65) ine.lengt                <--       (27:65) ine.lengt
                 ^                                          ^

     (46:71) ngth), 0)                <--       (27:71) ngth), 0)
                 ^                                          ^

     (46:72) gth), 0);                <--       (27:72) gth), 0);
                 ^                                          ^

     (46:74) h), 0);                  <--       (27:74) h), 0);
                 ^                                          ^

     (46:75) ), 0);                   <--       (27:75) ), 0);
                 ^                                          ^

     (46:76) , 0);                    <--       (27:76) , 0);
                 ^                                          ^

      (48:2)   const                  <--        (28:2)   const
               ^                                          ^

      (48:8) nst lines                <--        (28:8) nst lines
                 ^                                          ^

     (48:18) ount = Ma                <--       (28:18) ount = Ma
                 ^                                          ^

     (48:21) t = Math.                <--       (28:21) t = Math.
                 ^                                          ^

     (48:25) Math.max(                <--       (28:25) Math.max(
                 ^                                          ^

     (48:26) ath.max(l                <--       (28:26) ath.max(l
                 ^                                          ^

     (48:29) .max(left                <--       (28:29) .max(left
                 ^                                          ^

     (48:30) max(leftL                <--       (28:30) max(leftL
                 ^                                          ^

     (48:39) ines.leng                <--       (28:39) ines.leng
                 ^                                          ^

     (48:40) nes.lengt                <--       (28:40) nes.lengt
                 ^                                          ^

     (48:46) ngth, rig                <--       (28:46) ngth, rig
                 ^                                          ^

     (48:48) th, right                <--       (28:48) th, right
                 ^                                          ^

     (48:58) ines.leng                <--       (28:58) ines.leng
                 ^                                          ^

     (48:59) nes.lengt                <--       (28:59) nes.lengt
                 ^                                          ^

     (48:65) ngth);                   <--       (28:65) ngth);
                 ^                                          ^

     (48:66) gth);                    <--       (28:66) gth);
                 ^                                          ^

      (49:2)   let r                  <--        (29:2)   let r
               ^                                          ^

      (49:6) let res =                <--        (29:6) let res =
                 ^                                          ^

      (49:9)  res = ""                <--        (29:9)  res = ""
                 ^                                          ^

     (49:12) s = "";                  <--       (29:12) s = "";
                 ^                                          ^

     (49:14) = "";                    <--       (29:14) = "";
                 ^                                          ^

      (50:2)   for (                  <--        (30:2)   for (
               ^                                          ^

      (50:7) or (let i                <--        (30:7) or (let i
                 ^                                          ^

     (50:11) let i = 0                <--       (30:11) let i = 0
                 ^                                          ^

     (50:12) et i = 0;                <--       (30:12) et i = 0;
                 ^                                          ^

     (50:15) i = 0; i                 <--       (30:15) i = 0; i
                 ^                                          ^

     (50:16)  = 0; i <                <--       (30:16)  = 0; i <
                 ^                                          ^

     (50:18)  0; i < l                <--       (30:18)  0; i < l
                 ^                                          ^

     (50:19) 0; i < li                <--       (30:19) 0; i < li
                 ^                                          ^

     (50:22) i < lines                <--       (30:22) i < lines
                 ^                                          ^

     (50:32) ount; i++                <--       (30:32) ount; i++
                 ^                                          ^

     (50:34) nt; i++)                 <--       (30:34) nt; i++)
                 ^                                          ^

     (50:35) t; i++) {                <--       (30:35) t; i++) {
                 ^                                          ^

     (50:37)  i++) {                  <--       (30:37)  i++) {
                 ^                                          ^

     (50:39) ++) {                    <--       (30:39) ++) {
                 ^                                          ^

      (51:4)     if (r                <--        (31:4)     if (r
                 ^                                          ^

      (51:8) if (res !                <--        (31:8) if (res !
                 ^                                          ^

     (51:11) (res !==                 <--       (31:11) (res !==
                 ^                                          ^

     (51:16) !== "") r                <--       (31:16) !== "") r
                 ^                                          ^

     (51:18) = "") res                <--       (31:18) = "") res
                 ^                                          ^

     (51:20) "") res +                <--       (31:20) "") res +
                 ^                                          ^

     (51:23)  res += "                <--       (31:23)  res += "
                 ^                                          ^

     (51:27)  += "\n";                <--       (31:27)  += "\n";
                 ^                                          ^

     (51:31) "\n";                    <--       (31:31) "\n";
                 ^                                          ^

      (52:4)     if (i                <--        (32:4)     if (i
                 ^                                          ^

      (52:8) if (i < l                <--        (32:8) if (i < l
                 ^                                          ^

      (52:9) f (i < le                <--        (32:9) f (i < le
                 ^                                          ^

     (52:12) i < leftL                <--       (32:12) i < leftL
                 ^                                          ^

     (52:21) ines.leng                <--       (32:21) ines.leng
                 ^                                          ^

     (52:22) nes.lengt                <--       (32:22) nes.lengt
                 ^                                          ^

     (52:28) ngth) res                <--       (32:28) ngth) res
                 ^                                          ^

     (52:30) th) res +                <--       (32:30) th) res +
                 ^                                          ^

     (52:33)  res += l                <--       (32:33)  res += l
                 ^                                          ^

     (52:37)  += leftL                <--       (32:37)  += leftL
                 ^                                          ^

     (52:46) ines[i].p                <--       (32:46) ines[i].p
                 ^                                          ^

     (52:47) nes[i].pa                <--       (32:47) nes[i].pa
                 ^                                          ^

     (52:48) es[i].pad                <--       (32:48) es[i].pad
                 ^                                          ^

     (52:49) s[i].padE                <--       (32:49) s[i].padE
                 ^                                          ^

     (52:50) [i].padEn                <--       (32:50) [i].padEn
                 ^                                          ^

     (52:56) dEnd(left                <--       (32:56) dEnd(left
                 ^                                          ^

     (52:57) End(leftL                <--       (32:57) End(leftL
                 ^                                          ^

     (52:64) tLen, " "                <--       (32:64) tLen, " "
                 ^                                          ^

     (52:66) en, " ");                <--       (32:66) en, " ");
                 ^                                          ^

     (52:69)  " ");                   <--       (32:69)  " ");els
                 ^                                          ^

     (52:70) " ");                    <--       (32:70) " ");else
                 ^                                          ^

     (52:71)  ");                     <--       (32:71)  ");else
                 ^                                          ^

      (53:9) lse res +                <--       (32:76) lse res +
                 ^                                          ^

     (53:12)  res += "                <--       (32:79)  res += "
                 ^                                          ^

     (53:16)  += " ".r                <--       (32:83)  += " ".r
                 ^                                          ^

     (53:19)  " ".repe                <--       (32:86)  " ".repe
                 ^                                          ^

     (53:20) " ".repea                <--       (32:87) " ".repea
                 ^                                          ^

     (53:26) peat(left                <--       (32:93) peat(left
                 ^                                          ^

     (53:27) eat(leftL                <--       (32:94) eat(leftL
                 ^                                          ^

     (53:34) tLen);                   <--      (32:101) tLen);
                 ^                                          ^

     (53:35) Len);                    <--      (32:102) Len);
                 ^                                          ^

      (54:4)     if (i                <--        (33:4)     if (i
                 ^                                          ^

      (54:8) if (i < r                <--        (33:8) if (i < r
                 ^                                          ^

      (54:9) f (i < ri                <--        (33:9) f (i < ri
                 ^                                          ^

     (54:12) i < right                <--       (33:12) i < right
                 ^                                          ^

     (54:22) ines.leng                <--       (33:22) ines.leng
                 ^                                          ^

     (54:23) nes.lengt                <--       (33:23) nes.lengt
                 ^                                          ^

     (54:29) ngth) res                <--       (33:29) ngth) res
                 ^                                          ^

     (54:31) th) res +                <--       (33:31) th) res +
                 ^                                          ^

     (54:34)  res += r                <--       (33:34)  res += r
                 ^                                          ^

     (54:38)  += right                <--       (33:38)  += right
                 ^                                          ^

     (54:48) ines[i];                 <--       (33:48) ines[i];
                 ^                                          ^

     (54:49) nes[i];                  <--       (33:49) nes[i];
                 ^                                          ^

     (54:50) es[i];                   <--       (33:50) es[i];
                 ^                                          ^

     (54:51) s[i];                    <--       (33:51) s[i];
                 ^                                          ^

      (55:2)   }                      <--        (34:2)   }
               ^                                          ^

      (56:2)   retur                  <--        (35:2)   retur
               ^                                          ^

      (56:9) urn res;                 <--        (35:9) urn res;
                 ^                                          ^

     (56:12)  res;                    <--       (35:12)  res;
                 ^                                          ^

      (57:0) }                        <--        (36:0) }
             ^                                          ^

      (59:0) expor                    <--        (37:0) expor
             ^                                          ^

     (59:15) ult funct                <--       (37:15) ult funct
                 ^                                          ^

     (59:24) ion visua                <--       (37:24) ion visua
                 ^                                          ^

     (59:33) lize(outp                <--       (37:33) lize(outp
                 ^                                          ^

     (59:34) ize(outpu                <--       (37:34) ize(outpu
                 ^                                          ^

     (59:48) ring, map                <--       (37:40) tput, map
                 ^                                          ^

     (59:50) ng, map:                 <--       (37:42) ut, map)
                 ^                                          ^

     (59:58)  any) {                  <--       (37:45)  map) {
                 ^                                          ^

     (59:60) ny) {                    <--       (37:47) ap) {
                 ^                                          ^

      (60:2)   const                  <--        (38:2)   const
               ^                                          ^

      (60:8) nst sourc                <--        (38:8) nst sourc
                 ^                                          ^

     (60:20) ines = ne                <--       (38:20) ines = ne
                 ^                                          ^

     (60:23) s = new M                <--       (38:23) s = new M
                 ^                                          ^

     (60:27) new Map<s                <--       (38:27) new Map(m
                 ^                                          ^

     (60:30)  Map<stri                <--       (38:30)  Map(map.
                 ^                                          ^

      (61:4)     map.s                <--       (38:31) Map(map.s
                 ^                                          ^

      (61:7)  map.sour                <--       (38:34) (map.sour
                 ^                                          ^

      (61:8) map.sourc                <--       (38:35) map.sourc
                 ^                                          ^

     (61:15) rces.map(                <--       (38:42) rces.map(
                 ^                                          ^

     (61:16) ces.map((                <--       (38:43) ces.map((
                 ^                                          ^

     (61:19) .map((sou                <--       (38:46) .map((sou
                 ^                                          ^

     (61:20) map((sour                <--       (38:47) map((sour
                 ^                                          ^

     (61:21) ap((sourc                <--       (38:48) ap((sourc
                 ^                                          ^

     (61:35) ring, ind                <--       (38:54) urce, ind
                 ^                                          ^

     (61:37) ng, index                <--       (38:56) ce, index
                 ^                                          ^

     (61:50) mber) =>                 <--       (38:61) ndex) =>
                 ^                                          ^

     (61:55)  => [                    <--       (38:66)  => [sour
                 ^                                          ^

      (62:6)     sourc                <--       (38:67) => [sourc
                 ^                                          ^

     (62:12) urce,                    <--       (38:73) urce, map
                 ^                                          ^

      (63:6)     map.s                <--       (38:75) ce, map.s
                 ^                                          ^

      (63:9)  map.sour                <--       (38:78)  map.sour
                 ^                                          ^

     (63:10) map.sourc                <--       (38:79) map.sourc
                 ^                                          ^

     (63:24) tent[inde                <--       (38:93) tent[inde
                 ^                                          ^

     (63:25) ent[index                <--       (38:94) ent[index
                 ^                                          ^

     (63:30) ndex].spl                <--       (38:99) ndex].spl
                 ^                                          ^

     (63:31) dex].spli                <--      (38:100) dex].spli
                 ^                                          ^

     (63:32) ex].split                <--      (38:101) ex].split
                 ^                                          ^

     (63:37) plit("\n"                <--      (38:106) plit("\n"
                 ^                                          ^

     (63:38) lit("\n")                <--      (38:107) lit("\n")
                 ^                                          ^

     (63:42) "\n"),                   <--      (38:111) "\n")]));
                 ^                                          ^

     (63:43) \n"),                    <--      (38:112) \n")]));
                 ^                                          ^

      (64:5)    ]),                   <--      (38:113) n")]));
                 ^                                          ^

      (65:2)   );                     <--      (38:114) ")]));
               ^                                            ^

      (65:3)   );                     <--      (38:115) )]));
                ^                                           ^

      (66:2)   const                  <--        (39:2)   const
               ^                                          ^

      (66:8) nst outpu                <--        (39:8) nst outpu
                 ^                                          ^

     (66:19) ines = ou                <--       (39:19) ines = ou
                 ^                                          ^

     (66:22) s = outpu                <--       (39:22) s = outpu
                 ^                                          ^

     (66:28) tput.spli                <--       (39:28) tput.spli
                 ^                                          ^

     (66:29) put.split                <--       (39:29) put.split
                 ^                                          ^

     (66:34) plit("\n"                <--       (39:34) plit("\n"
                 ^                                          ^

     (66:35) lit("\n")                <--       (39:35) lit("\n")
                 ^                                          ^

     (66:39) "\n");                   <--       (39:39) "\n");
                 ^                                          ^

     (66:40) \n");                    <--       (39:40) \n");
                 ^                                          ^

      (70:2)   const                  <--        (40:2)   const
               ^                                          ^

      (70:8) nst range                <--        (40:8) nst range
                 ^                                          ^

      (74:5)  }[] = []                <--       (40:14) nges = []
                 ^                                          ^

      (74:8) ] = [];                  <--       (40:17) s = [];
                 ^                                          ^

     (74:10) = [];                    <--       (40:19) = [];
                 ^                                          ^

      (75:2)   let p                  <--        (41:2)   let p
               ^                                          ^

      (75:6) let prev:                <--        (41:6) let prev
                 ^                                          ^

     (75:30) null = nu                <--       (41:10) prev = nu
                 ^                                          ^

     (75:33) l = null;                <--       (41:13) v = null;
                 ^                                          ^

     (75:37) null;                    <--       (41:17) null;
                 ^                                          ^

      (76:2)   let p                  <--        (42:2)   let p
               ^                                          ^

      (76:6) let prevI                <--        (42:6) let prevI
                 ^                                          ^

     (76:19) Line = fa                <--       (42:19) Line = fa
                 ^                                          ^

     (76:22) e = false                <--       (42:22) e = false
                 ^                                          ^

     (76:27) alse;                    <--       (42:27) alse;
                 ^                                          ^

      (77:2)   let i                  <--        (43:2)   let i
               ^                                          ^

      (77:6) let index                <--        (43:6) let index
                 ^                                          ^

     (77:19) mber = 0;                <--       (43:11) ndex = 0;
                 ^                                          ^

     (77:22) r = 0;                   <--       (43:14) x = 0;
                 ^                                          ^

     (77:23)  = 0;                    <--       (43:15)  = 0;
                 ^                                          ^

      (79:2)   const                  <--        (44:2)   const
               ^                                          ^

      (79:8) nst range                <--        (44:8) nst range
                 ^                                          ^

     (79:21) ings = ma                <--       (44:21) ings = ma
                 ^                                          ^

     (79:24) s = map.r                <--       (44:24) s = map.r
                 ^                                          ^

     (79:27)  map.rang                <--       (44:27)  map.rang
                 ^                                          ^

     (79:28) map.range                <--       (44:28) map.range
                 ^                                          ^

     (79:41) ings                     <--       (44:41) ings ? de
                 ^                                          ^

      (80:6)   ? decod                <--       (44:44) s ? decod
                 ^                                          ^

     (80:25) ings(map.                <--       (44:63) ings(map.
                 ^                                          ^

     (80:26) ngs(map.r                <--       (44:64) ngs(map.r
                 ^                                          ^

     (80:29) (map.rang                <--       (44:67) (map.rang
                 ^                                          ^

     (80:30) map.range                <--       (44:68) map.range
                 ^                                          ^

     (80:43) ings)                    <--       (44:81) ings) : n
                 ^                                          ^

     (80:44) ngs)                     <--       (44:82) ngs) : nu
                 ^                                          ^

      (81:6)   : null;                <--       (44:85) ) : null;
                 ^                                          ^

     (81:10) null;                    <--       (44:89) null;
                 ^                                          ^

      (83:2)   eachM                  <--        (45:2)   eachM
               ^                                          ^

     (83:13) ping(new                 <--       (45:13) ping(new
                 ^                                          ^

     (83:14) ing(new T                <--       (45:14) ing(new T
                 ^                                          ^

     (83:18) new Trace                <--       (45:18) new Trace
                 ^                                          ^

     (83:26) eMap(map)                <--       (45:26) eMap(map)
                 ^                                          ^

     (83:27) Map(map),                <--       (45:27) Map(map),
                 ^                                          ^

     (83:30) (map), ma                <--       (45:30) (map), ma
                 ^                                          ^

     (83:31) map), map                <--       (45:31) map), map
                 ^                                          ^

     (83:33) p), mappi                <--       (45:33) p), mappi
                 ^                                          ^

     (83:40) ping => {                <--       (45:40) ping => {
                 ^                                          ^

     (83:44)  => {                    <--       (45:44)  => {
                 ^                                          ^

      (84:4)     if (p                <--        (46:4)     if (p
                 ^                                          ^

      (84:8) if (prev                 <--        (46:8) if (prev
                 ^                                          ^

     (84:12) prev ===                 <--       (46:12) prev ===
                 ^                                          ^

     (84:17) === null)                <--       (46:17) === null)
                 ^                                          ^

     (84:21) null) {                  <--       (46:21) null) {
                 ^                                          ^

     (84:23) ll) {                    <--       (46:23) ll) {
                 ^                                          ^

      (85:6)     prev                 <--        (47:6)     prev
                 ^                                          ^

     (85:10) prev = ma                <--       (47:10) prev = ma
                 ^                                          ^

     (85:13) v = mappi                <--       (47:13) v = mappi
                 ^                                          ^

     (85:20) ping;                    <--       (47:20) ping;
                 ^                                          ^

      (86:6)     prevI                <--        (48:6)     prevI
                 ^                                          ^

     (86:19) Line = tr                <--       (48:19) Line = tr
                 ^                                          ^

     (86:22) e = true;                <--       (48:22) e = true;
                 ^                                          ^

     (86:26) true;                    <--       (48:26) true;
                 ^                                          ^

      (87:6)     retur                <--        (49:6)     retur
                 ^                                          ^

      (88:4)     }                    <--        (50:4)     }
                 ^                                          ^

      (90:4)     if (p                <--        (51:4)     if (p
                 ^                                          ^

      (90:8) if (prevI                <--        (51:8) if (prevI
                 ^                                          ^

     (90:21) Line) {                  <--       (51:21) Line) {
                 ^                                          ^

     (90:23) ne) {                    <--       (51:23) ne) {
                 ^                                          ^

      (91:6)     index                <--        (52:6)     index
                 ^                                          ^

     (91:11) ndex = 0;                <--       (52:11) ndex = 0;
                 ^                                          ^

     (91:14) x = 0;                   <--       (52:14) x = 0;
                 ^                                          ^

     (91:15)  = 0;                    <--       (52:15)  = 0;
                 ^                                          ^

      (92:4)     } els                <--        (53:4)     } els
                 ^                                          ^

      (92:5)    } else                <--        (53:5)    } else
                 ^                                          ^

     (92:11) lse {                    <--       (53:11) lse {
                 ^                                          ^

      (93:6)     index                <--        (54:6)     index
                 ^                                          ^

     (93:11) ndex++;                  <--       (54:11) ndex++;
                 ^                                          ^

     (93:13) ex++;                    <--       (54:13) ex++;
                 ^                                          ^

      (94:4)     }                    <--        (55:4)     }
                 ^                                          ^

      (96:4)     // NO                <--        (57:4)     // NO
                 ^                                          ^

      (97:4)     // _r                <--        (58:4)     // _r
                 ^                                          ^

      (99:4)     const                <--        (60:4)     const
                 ^                                          ^

     (99:10) nst origi                <--       (60:10) nst origi
                 ^                                          ^

     (99:25) ange = {                 <--       (60:18) inal = {
                 ^                                          ^

     (99:28) e = {                    <--       (60:21) l = {
                 ^                                          ^

     (100:6)     from:                <--        (61:6)     from:
                 ^                                          ^

    (100:10) from: { l                <--       (61:10) from: {
                 ^                                          ^

    (100:12) om: { lin                <--       (61:12) om: {
                 ^                                          ^

    (100:14) : { line:                <--        (62:8)     line:
                 ^                                          ^

    (100:18) line: pre                <--       (62:12) line: pre
                 ^                                          ^

    (100:20) ne: prev.                <--       (62:14) ne: prev.
                 ^                                          ^

    (100:24) prev.orig                <--       (62:18) prev.orig
                 ^                                          ^

    (100:25) rev.origi                <--       (62:19) rev.origi
                 ^                                          ^

    (100:38) ine!, col                <--       (62:31) Line,
                 ^                                          ^

    (100:40) e!, colum                <--        (63:8)     colum
                 ^                                          ^

    (100:46) lumn: pre                <--       (63:14) lumn: pre
                 ^                                          ^

    (100:48) mn: prev.                <--       (63:16) mn: prev.
                 ^                                          ^

    (100:52) prev.orig                <--       (63:20) prev.orig
                 ^                                          ^

    (100:53) rev.origi                <--       (63:21) rev.origi
                 ^                                          ^

    (100:69) mn! },                   <--        (64:6)     },
                 ^                                          ^

    (100:70) n! },                    <--        (64:7)    },
                 ^                                          ^

     (101:6)     to: n                <--        (65:6)     to: n
                 ^                                          ^

     (101:8)   to: nul                <--        (65:8)   to: nul
                 ^                                          ^

    (101:10) to: null,                <--       (65:10) to: null
                 ^                                          ^

     (102:4)     };                   <--        (66:4)     };
                 ^                                          ^

     (102:5)    };                    <--        (66:5)    };
                 ^                                          ^

     (103:4)     const                <--        (67:4)     const
                 ^                                          ^

    (103:10) nst gener                <--       (67:10) nst gener
                 ^                                          ^

    (103:26) ange = {                 <--       (67:19) ated = {
                 ^                                          ^

    (103:29) e = {                    <--       (67:22) d = {
                 ^                                          ^

     (104:6)     from:                <--        (68:6)     from:
                 ^                                          ^

    (104:10) from: { l                <--       (68:10) from: {
                 ^                                          ^

    (104:12) om: { lin                <--       (68:12) om: {
                 ^                                          ^

    (104:14) : { line:                <--        (69:8)     line:
                 ^                                          ^

    (104:18) line: pre                <--       (69:12) line: pre
                 ^                                          ^

    (104:20) ne: prev.                <--       (69:14) ne: prev.
                 ^                                          ^

    (104:24) prev.gene                <--       (69:18) prev.gene
                 ^                                          ^

    (104:25) rev.gener                <--       (69:19) rev.gener
                 ^                                          ^

    (104:38) Line, col                <--       (69:32) Line,
                 ^                                          ^

    (104:40) ne, colum                <--        (70:8)     colum
                 ^                                          ^

    (104:46) lumn: pre                <--       (70:14) lumn: pre
                 ^                                          ^

    (104:48) mn: prev.                <--       (70:16) mn: prev.
                 ^                                          ^

    (104:52) prev.gene                <--       (70:20) prev.gene
                 ^                                          ^

    (104:53) rev.gener                <--       (70:21) rev.gener
                 ^                                          ^

    (104:69) umn },                   <--        (71:6)     },
                 ^                                          ^

    (104:70) mn },                    <--        (71:7)    },
                 ^                                          ^

     (105:6)     to: n                <--        (72:6)     to: n
                 ^                                          ^

     (105:8)   to: nul                <--        (72:8)   to: nul
                 ^                                          ^

    (105:10) to: null,                <--       (72:10) to: null
                 ^                                          ^

     (106:4)     };                   <--        (73:4)     };
                 ^                                          ^

     (106:5)    };                    <--        (73:5)    };
                 ^                                          ^

     (108:4)     if (r                <--        (74:4)     if (r
                 ^                                          ^

     (108:8) if (range                <--        (74:8) if (range
                 ^                                          ^

    (108:21) ings?.[pr                <--       (74:21) ings?.[pr
                 ^                                          ^

    (108:24) s?.[prev.                <--       (74:24) s?.[prev.
                 ^                                          ^

    (108:28) prev.gene                <--       (74:28) prev.gene
                 ^                                          ^

    (108:29) rev.gener                <--       (74:29) rev.gener
                 ^                                          ^

    (108:42) Line - 1]                <--       (74:42) Line - 1]
                 ^                                          ^

    (108:45) e - 1]?.i                <--       (74:45) e - 1]?.i
                 ^                                          ^

    (108:46)  - 1]?.in                <--       (74:46)  - 1]?.in
                 ^                                          ^

    (108:47) - 1]?.inc                <--       (74:47) - 1]?.inc
                 ^                                          ^

    (108:49) 1]?.inclu                <--       (74:49) 1]?.inclu
                 ^                                          ^

    (108:57) udes(inde                <--       (74:57) udes(inde
                 ^                                          ^

    (108:58) des(index                <--       (74:58) des(index
                 ^                                          ^

    (108:63) ndex)) {                 <--       (74:63) ndex)) {
                 ^                                          ^

    (108:64) dex)) {                  <--       (74:64) dex)) {
                 ^                                          ^

    (108:66) x)) {                    <--       (74:66) x)) {
                 ^                                          ^

     (109:6)     origi                <--        (75:6)     origi
                 ^                                          ^

    (109:14) inal.to =                <--       (75:14) inal.to =
                 ^                                          ^

    (109:15) nal.to =                 <--       (75:15) nal.to =
                 ^                                          ^

    (109:17) l.to = {                 <--       (75:17) l.to = {
                 ^                                          ^

    (109:20) o = {                    <--       (75:20) o = {
                 ^                                          ^

     (110:8)     line:                <--        (76:8)     line:
                 ^                                          ^

    (110:12) line: map                <--       (76:12) line: map
                 ^                                          ^

    (110:14) ne: mappi                <--       (76:14) ne: mappi
                 ^                                          ^

    (110:21) ping.orig                <--       (76:21) ping.orig
                 ^                                          ^

    (110:22) ing.origi                <--       (76:22) ing.origi
                 ^                                          ^

    (110:35) ine!,                    <--       (76:34) Line,
                 ^                                          ^

     (111:8)     colum                <--        (77:8)     colum
                 ^                                          ^

    (111:14) lumn: map                <--       (77:14) lumn: map
                 ^                                          ^

    (111:16) mn: mappi                <--       (77:16) mn: mappi
                 ^                                          ^

    (111:23) ping.orig                <--       (77:23) ping.orig
                 ^                                          ^

    (111:24) ing.origi                <--       (77:24) ing.origi
                 ^                                          ^

     (112:6)     };                   <--        (78:6)     };
                 ^                                          ^

     (112:7)    };                    <--        (78:7)    };
                 ^                                          ^

     (113:6)     gener                <--        (79:6)     gener
                 ^                                          ^

    (113:15) ated.to =                <--       (79:15) ated.to =
                 ^                                          ^

    (113:16) ted.to =                 <--       (79:16) ted.to =
                 ^                                          ^

    (113:18) d.to = {                 <--       (79:18) d.to = {
                 ^                                          ^

    (113:21) o = {                    <--       (79:21) o = {
                 ^                                          ^

     (114:8)     line:                <--        (80:8)     line:
                 ^                                          ^

    (114:12) line:                    <--       (80:12) line: gen
                 ^                                          ^

    (115:10)     gener                <--       (80:14) ne: gener
                 ^                                          ^

    (115:19) ated.from                <--       (80:23) ated.from
                 ^                                          ^

    (115:20) ted.from.                <--       (80:24) ted.from.
                 ^                                          ^

    (115:24) from.line                <--       (80:28) from.line
                 ^                                          ^

    (115:25) rom.line                 <--       (80:29) rom.line
                 ^                                          ^

    (115:29) line + (m                <--       (80:33) line + (m
                 ^                                          ^

    (115:33)  + (mappi                <--       (80:37)  + (mappi
                 ^                                          ^

    (115:40) ping.gene                <--       (80:44) ping.gene
                 ^                                          ^

    (115:41) ing.gener                <--       (80:45) ing.gener
                 ^                                          ^

    (115:54) Line - pr                <--       (80:58) Line - pr
                 ^                                          ^

    (115:57) e - prev.                <--       (80:61) e - prev.
                 ^                                          ^

    (115:61) prev.gene                <--       (80:65) prev.gene
                 ^                                          ^

    (115:62) rev.gener                <--       (80:66) rev.gener
                 ^                                          ^

    (115:75) Line),                   <--       (80:79) Line),
                 ^                                          ^

    (115:76) ine),                    <--       (80:80) ine),
                 ^                                          ^

     (116:8)     colum                <--        (81:8)     colum
                 ^                                          ^

    (116:14) lumn: map                <--       (81:14) lumn: map
                 ^                                          ^

    (116:16) mn: mappi                <--       (81:16) mn: mappi
                 ^                                          ^

    (116:23) ping.gene                <--       (81:23) ping.gene
                 ^                                          ^

    (116:24) ing.gener                <--       (81:24) ing.gener
                 ^                                          ^

     (117:6)     };                   <--        (82:6)     };
                 ^                                          ^

     (117:7)    };                    <--        (82:7)    };
                 ^                                          ^

     (118:6)     if (m                <--        (83:6)     if (m
                 ^                                          ^

    (118:10) if (mappi                <--       (83:10) if (mappi
                 ^                                          ^

    (118:17) ping.gene                <--       (83:17) ping.gene
                 ^                                          ^

    (118:18) ing.gener                <--       (83:18) ing.gener
                 ^                                          ^

    (118:31) Line ===                 <--       (83:31) Line ===
                 ^                                          ^

    (118:36) === prev.                <--       (83:36) === prev.
                 ^                                          ^

    (118:40) prev.gene                <--       (83:40) prev.gene
                 ^                                          ^

    (118:41) rev.gener                <--       (83:41) rev.gener
                 ^                                          ^

    (118:54) Line) {                  <--       (83:54) Line) {
                 ^                                          ^

    (118:56) ne) {                    <--       (83:56) ne) {
                 ^                                          ^

     (119:8)     gener                <--        (84:8)     gener
                 ^                                          ^

    (119:17) ated.to.c                <--       (84:17) ated.to.c
                 ^                                          ^

    (119:18) ted.to.co                <--       (84:18) ted.to.co
                 ^                                          ^

    (119:20) d.to.colu                <--       (84:20) d.to.colu
                 ^                                          ^

    (119:21) .to.colum                <--       (84:21) .to.colum
                 ^                                          ^

    (119:27) lumn =                   <--       (84:27) lumn = ge
                 ^                                          ^

    (120:10)     gener                <--       (84:30) n = gener
                 ^                                          ^

    (120:19) ated.from                <--       (84:39) ated.from
                 ^                                          ^

    (120:20) ted.from.                <--       (84:40) ted.from.
                 ^                                          ^

    (120:24) from.colu                <--       (84:44) from.colu
                 ^                                          ^

    (120:25) rom.colum                <--       (84:45) rom.colum
                 ^                                          ^

    (120:31) lumn +                   <--       (84:51) lumn + (m
                 ^                                          ^

    (121:11)    (mappi                <--       (84:55)  + (mappi
                 ^                                          ^

    (121:18) ping.gene                <--       (84:62) ping.gene
                 ^                                          ^

    (121:19) ing.gener                <--       (84:63) ing.gener
                 ^                                          ^

    (121:34) lumn - pr                <--       (84:78) lumn - pr
                 ^                                          ^

    (121:37) n - prev.                <--       (84:81) n - prev.
                 ^                                          ^

    (121:41) prev.gene                <--       (84:85) prev.gene
                 ^                                          ^

    (121:42) rev.gener                <--       (84:86) rev.gener
                 ^                                          ^

    (121:57) lumn);                   <--      (84:101) lumn);
                 ^                                          ^

    (121:58) umn);                    <--      (84:102) umn);
                 ^                                          ^

     (122:6)     } els                <--        (85:6)     } els
                 ^                                          ^

     (122:7)    } else                <--        (85:7)    } else
                 ^                                          ^

    (122:13) lse {                    <--       (85:13) lse {
                 ^                                          ^

     (123:8)     gener                <--        (86:8)     gener
                 ^                                          ^

    (123:17) ated.to.c                <--       (86:17) ated.to.c
                 ^                                          ^

    (123:18) ted.to.co                <--       (86:18) ted.to.co
                 ^                                          ^

    (123:20) d.to.colu                <--       (86:20) d.to.colu
                 ^                                          ^

    (123:21) .to.colum                <--       (86:21) .to.colum
                 ^                                          ^

    (123:27) lumn = ma                <--       (86:27) lumn = ma
                 ^                                          ^

    (123:30) n = mappi                <--       (86:30) n = mappi
                 ^                                          ^

    (123:37) ping.gene                <--       (86:37) ping.gene
                 ^                                          ^

    (123:38) ing.gener                <--       (86:38) ing.gener
                 ^                                          ^

    (123:53) lumn;                    <--       (86:53) lumn;
                 ^                                          ^

     (124:6)     }                    <--        (87:6)     }
                 ^                                          ^

     (126:6)     if (o                <--        (88:6)     if (o
                 ^                                          ^

    (126:10) if (origi                <--       (88:10) if (origi
                 ^                                          ^

    (126:18) inal.from                <--       (88:18) inal.from
                 ^                                          ^

    (126:19) nal.from.                <--       (88:19) nal.from.
                 ^                                          ^

    (126:23) from.line                <--       (88:23) from.line
                 ^                                          ^

    (126:24) rom.line                 <--       (88:24) rom.line
                 ^                                          ^

    (126:28) line !==                 <--       (88:28) line !==
                 ^                                          ^

    (126:33) !== origi                <--       (88:33) !== origi
                 ^                                          ^

    (126:41) inal.to.l                <--       (88:41) inal.to.l
                 ^                                          ^

    (126:42) nal.to.li                <--       (88:42) nal.to.li
                 ^                                          ^

    (126:44) l.to.line                <--       (88:44) l.to.line
                 ^                                          ^

    (126:45) .to.line)                <--       (88:45) .to.line)
                 ^                                          ^

    (126:49) line) {                  <--       (88:49) line) {
                 ^                                          ^

    (126:51) ne) {                    <--       (88:51) ne) {
                 ^                                          ^

     (127:8)     origi                <--        (89:8)     origi
                 ^                                          ^

    (127:16) inal.to.l                <--       (89:16) inal.to.l
                 ^                                          ^

    (127:17) nal.to.li                <--       (89:17) nal.to.li
                 ^                                          ^

    (127:19) l.to.line                <--       (89:19) l.to.line
                 ^                                          ^

    (127:20) .to.line                 <--       (89:20) .to.line
                 ^                                          ^

    (127:24) line = or                <--       (89:24) line = or
                 ^                                          ^

    (127:27) e = origi                <--       (89:27) e = origi
                 ^                                          ^

    (127:35) inal.from                <--       (89:35) inal.from
                 ^                                          ^

    (127:36) nal.from.                <--       (89:36) nal.from.
                 ^                                          ^

    (127:40) from.line                <--       (89:40) from.line
                 ^                                          ^

    (127:41) rom.line;                <--       (89:41) rom.line;
                 ^                                          ^

    (127:45) line;                    <--       (89:45) line;
                 ^                                          ^

     (128:8)     origi                <--        (90:8)     origi
                 ^                                          ^

    (128:16) inal.to.c                <--       (90:16) inal.to.c
                 ^                                          ^

    (128:17) nal.to.co                <--       (90:17) nal.to.co
                 ^                                          ^

    (128:19) l.to.colu                <--       (90:19) l.to.colu
                 ^                                          ^

    (128:20) .to.colum                <--       (90:20) .to.colum
                 ^                                          ^

    (128:26) lumn = In                <--       (90:26) lumn = In
                 ^                                          ^

    (128:29) n = Infin                <--       (90:29) n = Infin
                 ^                                          ^

    (128:37) nity;                    <--       (90:37) nity;
                 ^                                          ^

     (129:6)     } els                <--        (91:6)     } els
                 ^                                          ^

     (129:7)    } else                <--        (91:7)    } else
                 ^                                          ^

    (129:13) lse if (o                <--       (91:13) lse if (o
                 ^                                          ^

    (129:17) if (origi                <--       (91:17) if (origi
                 ^                                          ^

    (129:25) inal.to.c                <--       (91:25) inal.to.c
                 ^                                          ^

    (129:26) nal.to.co                <--       (91:26) nal.to.co
                 ^                                          ^

    (129:28) l.to.colu                <--       (91:28) l.to.colu
                 ^                                          ^

    (129:29) .to.colum                <--       (91:29) .to.colum
                 ^                                          ^

    (129:35) lumn < or                <--       (91:35) lumn < or
                 ^                                          ^

    (129:38) n < origi                <--       (91:38) n < origi
                 ^                                          ^

    (129:46) inal.from                <--       (91:46) inal.from
                 ^                                          ^

    (129:47) nal.from.                <--       (91:47) nal.from.
                 ^                                          ^

    (129:51) from.colu                <--       (91:51) from.colu
                 ^                                          ^

    (129:52) rom.colum                <--       (91:52) rom.colum
                 ^                                          ^

    (129:58) lumn) {                  <--       (91:58) lumn) {
                 ^                                          ^

    (129:60) mn) {                    <--       (91:60) mn) {
                 ^                                          ^

     (130:8)     origi                <--        (92:8)     origi
                 ^                                          ^

    (130:16) inal.to.c                <--       (92:16) inal.to.c
                 ^                                          ^

    (130:17) nal.to.co                <--       (92:17) nal.to.co
                 ^                                          ^

    (130:19) l.to.colu                <--       (92:19) l.to.colu
                 ^                                          ^

    (130:20) .to.colum                <--       (92:20) .to.colum
                 ^                                          ^

    (130:26) lumn = or                <--       (92:26) lumn = or
                 ^                                          ^

    (130:29) n = origi                <--       (92:29) n = origi
                 ^                                          ^

    (130:37) inal.from                <--       (92:37) inal.from
                 ^                                          ^

    (130:38) nal.from.                <--       (92:38) nal.from.
                 ^                                          ^

    (130:42) from.colu                <--       (92:42) from.colu
                 ^                                          ^

    (130:43) rom.colum                <--       (92:43) rom.colum
                 ^                                          ^

    (130:49) lumn;                    <--       (92:49) lumn;
                 ^                                          ^

     (131:6)     }                    <--        (93:6)     }
                 ^                                          ^

     (132:6)     if (g                <--        (94:6)     if (g
                 ^                                          ^

    (132:10) if (gener                <--       (94:10) if (gener
                 ^                                          ^

    (132:19) ated.from                <--       (94:19) ated.from
                 ^                                          ^

    (132:20) ted.from.                <--       (94:20) ted.from.
                 ^                                          ^

    (132:24) from.line                <--       (94:24) from.line
                 ^                                          ^

    (132:25) rom.line                 <--       (94:25) rom.line
                 ^                                          ^

    (132:29) line !==                 <--       (94:29) line !==
                 ^                                          ^

    (132:34) !== gener                <--       (94:34) !== gener
                 ^                                          ^

    (132:43) ated.to.l                <--       (94:43) ated.to.l
                 ^                                          ^

    (132:44) ted.to.li                <--       (94:44) ted.to.li
                 ^                                          ^

    (132:46) d.to.line                <--       (94:46) d.to.line
                 ^                                          ^

    (132:47) .to.line)                <--       (94:47) .to.line)
                 ^                                          ^

    (132:51) line) {                  <--       (94:51) line) {
                 ^                                          ^

    (132:53) ne) {                    <--       (94:53) ne) {
                 ^                                          ^

     (133:8)     gener                <--        (95:8)     gener
                 ^                                          ^

    (133:17) ated.to.l                <--       (95:17) ated.to.l
                 ^                                          ^

    (133:18) ted.to.li                <--       (95:18) ted.to.li
                 ^                                          ^

    (133:20) d.to.line                <--       (95:20) d.to.line
                 ^                                          ^

    (133:21) .to.line                 <--       (95:21) .to.line
                 ^                                          ^

    (133:25) line = ge                <--       (95:25) line = ge
                 ^                                          ^

    (133:28) e = gener                <--       (95:28) e = gener
                 ^                                          ^

    (133:37) ated.from                <--       (95:37) ated.from
                 ^                                          ^

    (133:38) ted.from.                <--       (95:38) ted.from.
                 ^                                          ^

    (133:42) from.line                <--       (95:42) from.line
                 ^                                          ^

    (133:43) rom.line;                <--       (95:43) rom.line;
                 ^                                          ^

    (133:47) line;                    <--       (95:47) line;
                 ^                                          ^

     (134:8)     gener                <--        (96:8)     gener
                 ^                                          ^

    (134:17) ated.to.c                <--       (96:17) ated.to.c
                 ^                                          ^

    (134:18) ted.to.co                <--       (96:18) ted.to.co
                 ^                                          ^

    (134:20) d.to.colu                <--       (96:20) d.to.colu
                 ^                                          ^

    (134:21) .to.colum                <--       (96:21) .to.colum
                 ^                                          ^

    (134:27) lumn = In                <--       (96:27) lumn = In
                 ^                                          ^

    (134:30) n = Infin                <--       (96:30) n = Infin
                 ^                                          ^

    (134:38) nity;                    <--       (96:38) nity;
                 ^                                          ^

     (135:6)     } els                <--        (97:6)     } els
                 ^                                          ^

     (135:7)    } else                <--        (97:7)    } else
                 ^                                          ^

    (135:13) lse if (g                <--       (97:13) lse if (g
                 ^                                          ^

    (135:17) if (gener                <--       (97:17) if (gener
                 ^                                          ^

    (135:26) ated.to.c                <--       (97:26) ated.to.c
                 ^                                          ^

    (135:27) ted.to.co                <--       (97:27) ted.to.co
                 ^                                          ^

    (135:29) d.to.colu                <--       (97:29) d.to.colu
                 ^                                          ^

    (135:30) .to.colum                <--       (97:30) .to.colum
                 ^                                          ^

    (135:36) lumn < ge                <--       (97:36) lumn < ge
                 ^                                          ^

    (135:39) n < gener                <--       (97:39) n < gener
                 ^                                          ^

    (135:48) ated.from                <--       (97:48) ated.from
                 ^                                          ^

    (135:49) ted.from.                <--       (97:49) ted.from.
                 ^                                          ^

    (135:53) from.colu                <--       (97:53) from.colu
                 ^                                          ^

    (135:54) rom.colum                <--       (97:54) rom.colum
                 ^                                          ^

    (135:60) lumn) {                  <--       (97:60) lumn) {
                 ^                                          ^

    (135:62) mn) {                    <--       (97:62) mn) {
                 ^                                          ^

     (136:8)     gener                <--        (98:8)     gener
                 ^                                          ^

    (136:17) ated.to.c                <--       (98:17) ated.to.c
                 ^                                          ^

    (136:18) ted.to.co                <--       (98:18) ted.to.co
                 ^                                          ^

    (136:20) d.to.colu                <--       (98:20) d.to.colu
                 ^                                          ^

    (136:21) .to.colum                <--       (98:21) .to.colum
                 ^                                          ^

    (136:27) lumn = ge                <--       (98:27) lumn = ge
                 ^                                          ^

    (136:30) n = gener                <--       (98:30) n = gener
                 ^                                          ^

    (136:39) ated.from                <--       (98:39) ated.from
                 ^                                          ^

    (136:40) ted.from.                <--       (98:40) ted.from.
                 ^                                          ^

    (136:44) from.colu                <--       (98:44) from.colu
                 ^                                          ^

    (136:45) rom.colum                <--       (98:45) rom.colum
                 ^                                          ^

    (136:51) lumn;                    <--       (98:51) lumn;
                 ^                                          ^

     (137:6)     }                    <--        (99:6)     }
                 ^                                          ^

     (138:4)     }                    <--       (100:4)     }
                 ^                                          ^

     (139:4)     range                <--       (101:4)     range
                 ^                                          ^

    (139:10) nges.push                <--      (101:10) nges.push
                 ^                                          ^

    (139:11) ges.push(                <--      (101:11) ges.push(
                 ^                                          ^

    (139:15) push({ or                <--      (101:15) push({
                 ^                                          ^

    (139:16) ush({ ori                <--      (101:16) ush({
                 ^                                          ^

    (139:18) h({ origi                <--       (102:6)     origi
                 ^                                          ^

    (139:26) inal, gen                <--      (102:14) inal,
                 ^                                          ^

    (139:28) al, gener                <--       (103:6)     gener
                 ^                                          ^

    (139:37) ated, sou                <--      (103:15) ated,
                 ^                                          ^

    (139:39) ed, sourc                <--       (104:6)     sourc
                 ^                                          ^

    (139:45) urce: pre                <--      (104:12) urce: pre
                 ^                                          ^

    (139:47) ce: prev.                <--      (104:14) ce: prev.
                 ^                                          ^

    (139:51) prev.sour                <--      (104:18) prev.sour
                 ^                                          ^

    (139:52) rev.sourc                <--      (104:19) rev.sourc
                 ^                                          ^

    (139:60) ce! });                  <--       (105:4)     });
                 ^                                          ^

    (139:61) e! });                   <--       (105:5)    });
                 ^                                          ^

    (139:62) ! });                    <--       (105:6)   });
                 ^                                          ^

     (141:4)     prevI                <--       (106:4)     prevI
                 ^                                          ^

    (141:17) Line = ma                <--      (106:17) Line = ma
                 ^                                          ^

    (141:20) e = mappi                <--      (106:20) e = mappi
                 ^                                          ^

    (141:27) ping.gene                <--      (106:27) ping.gene
                 ^                                          ^

    (141:28) ing.gener                <--      (106:28) ing.gener
                 ^                                          ^

    (141:41) Line !==                 <--      (106:41) Line !==
                 ^                                          ^

    (141:46) !== prev?                <--      (106:46) !== prev?
                 ^                                          ^

    (141:50) prev?.gen                <--      (106:50) prev?.gen
                 ^                                          ^

    (141:52) ev?.gener                <--      (106:52) ev?.gener
                 ^                                          ^

    (141:65) Line;                    <--      (106:65) Line;
                 ^                                          ^

     (142:4)     prev                 <--       (107:4)     prev
                 ^                                          ^

     (142:8) prev = ma                <--       (107:8) prev = ma
                 ^                                          ^

    (142:11) v = mappi                <--      (107:11) v = mappi
                 ^                                          ^

    (142:18) ping;                    <--      (107:18) ping;
                 ^                                          ^

     (143:2)   });                    <--       (108:2)   });
               ^                                          ^

     (143:3)   });                    <--       (108:3)   });
                ^                                          ^

     (143:4)   });                    <--       (108:4)   });
                 ^                                          ^

     (144:2)   // TO                  <--       (109:2)   // TO
               ^                                          ^

     (145:2)   // @b                  <--       (110:2)   // @b
               ^                                          ^

     (146:2)   // or                  <--       (111:2)   // or
               ^                                          ^

     (147:2)   // th                  <--       (112:2)   // th
               ^                                          ^

     (148:2)   if (p                  <--       (113:2)   if (p
               ^                                          ^

     (148:6) if (prev!                <--       (113:6) if (prev.
                 ^                                          ^

    (148:10) prev!.ori                <--      (113:10) prev.orig
                 ^                                          ^

    (148:12) ev!.origi                <--      (113:11) rev.origi
                 ^                                          ^

    (148:24) Line) {                  <--      (113:23) Line) {
                 ^                                          ^

    (148:26) ne) {                    <--      (113:25) ne) {
                 ^                                          ^

     (149:4)     range                <--       (114:4)     range
                 ^                                          ^

    (149:10) nges.push                <--      (114:10) nges.push
                 ^                                          ^

    (149:11) ges.push(                <--      (114:11) ges.push(
                 ^                                          ^

    (149:15) push({                   <--      (114:15) push({
                 ^                                          ^

    (149:16) ush({                    <--      (114:16) ush({
                 ^                                          ^

     (150:6)     origi                <--       (115:6)     origi
                 ^                                          ^

    (150:14) inal: {                  <--      (115:14) inal: {
                 ^                                          ^

    (150:16) al: {                    <--      (115:16) al: {
                 ^                                          ^

     (151:8)     from:                <--       (116:8)     from:
                 ^                                          ^

    (151:12) from: { l                <--      (116:12) from: {
                 ^                                          ^

    (151:14) om: { lin                <--      (116:14) om: {
                 ^                                          ^

    (151:16) : { line:                <--      (117:10)     line:
                 ^                                          ^

    (151:20) line: pre                <--      (117:14) line: pre
                 ^                                          ^

    (151:22) ne: prev!                <--      (117:16) ne: prev.
                 ^                                          ^

    (151:26) prev!.ori                <--      (117:20) prev.orig
                 ^                                          ^

    (151:28) ev!.origi                <--      (117:21) rev.origi
                 ^                                          ^

    (151:40) Line, col                <--      (117:33) Line,
                 ^                                          ^

    (151:42) ne, colum                <--      (118:10)     colum
                 ^                                          ^

    (151:48) lumn: pre                <--      (118:16) lumn: pre
                 ^                                          ^

    (151:50) mn: prev!                <--      (118:18) mn: prev.
                 ^                                          ^

    (151:54) prev!.ori                <--      (118:22) prev.orig
                 ^                                          ^

    (151:56) ev!.origi                <--      (118:23) rev.origi
                 ^                                          ^

    (151:72) mn! },                   <--       (119:8)     },
                 ^                                          ^

    (151:73) n! },                    <--       (119:9)    },
                 ^                                          ^

     (152:8)     to: n                <--       (120:8)     to: n
                 ^                                          ^

    (152:10)   to: nul                <--      (120:10)   to: nul
                 ^                                          ^

    (152:12) to: null,                <--      (120:12) to: null
                 ^                                          ^

     (153:6)     },                   <--       (121:6)     },
                 ^                                          ^

     (153:7)    },                    <--       (121:7)    },
                 ^                                          ^

     (154:6)     gener                <--       (122:6)     gener
                 ^                                          ^

    (154:15) ated: {                  <--      (122:15) ated: {
                 ^                                          ^

    (154:17) ed: {                    <--      (122:17) ed: {
                 ^                                          ^

     (155:8)     from:                <--       (123:8)     from:
                 ^                                          ^

    (155:12) from: { l                <--      (123:12) from: {
                 ^                                          ^

    (155:14) om: { lin                <--      (123:14) om: {
                 ^                                          ^

    (155:16) : { line:                <--      (124:10)     line:
                 ^                                          ^

    (155:20) line: pre                <--      (124:14) line: pre
                 ^                                          ^

    (155:22) ne: prev!                <--      (124:16) ne: prev.
                 ^                                          ^

    (155:26) prev!.gen                <--      (124:20) prev.gene
                 ^                                          ^

    (155:28) ev!.gener                <--      (124:21) rev.gener
                 ^                                          ^

    (155:41) Line, col                <--      (124:34) Line,
                 ^                                          ^

    (155:43) ne, colum                <--      (125:10)     colum
                 ^                                          ^

    (155:49) lumn: pre                <--      (125:16) lumn: pre
                 ^                                          ^

    (155:51) mn: prev!                <--      (125:18) mn: prev.
                 ^                                          ^

    (155:55) prev!.gen                <--      (125:22) prev.gene
                 ^                                          ^

    (155:57) ev!.gener                <--      (125:23) rev.gener
                 ^                                          ^

    (155:73) umn },                   <--       (126:8)     },
                 ^                                          ^

    (155:74) mn },                    <--       (126:9)    },
                 ^                                          ^

     (156:8)     to: n                <--       (127:8)     to: n
                 ^                                          ^

    (156:10)   to: nul                <--      (127:10)   to: nul
                 ^                                          ^

    (156:12) to: null,                <--      (127:12) to: null
                 ^                                          ^

     (157:6)     },                   <--       (128:6)     },
                 ^                                          ^

     (157:7)    },                    <--       (128:7)    },
                 ^                                          ^

     (158:6)     sourc                <--       (129:6)     sourc
                 ^                                          ^

    (158:12) urce: pre                <--      (129:12) urce: pre
                 ^                                          ^

    (158:14) ce: prev!                <--      (129:14) ce: prev.
                 ^                                          ^

    (158:18) prev!.sou                <--      (129:18) prev.sour
                 ^                                          ^

    (158:20) ev!.sourc                <--      (129:19) rev.sourc
                 ^                                          ^

     (159:4)     });                  <--       (130:4)     });
                 ^                                          ^

     (159:5)    });                   <--       (130:5)    });
                 ^                                          ^

     (159:6)   });                    <--       (130:6)   });
                 ^                                          ^

     (160:2)   }                      <--       (131:2)   }
               ^                                          ^

     (162:2)   const                  <--       (132:2)   const
               ^                                          ^

     (162:8) nst res =                <--       (132:8) nst res =
                 ^                                          ^

    (162:11)  res = ra                <--      (132:11)  res = ra
                 ^                                          ^

    (162:14) s = range                <--      (132:14) s = range
                 ^                                          ^

    (162:20) nges.map(                <--      (132:20) nges.map(
                 ^                                          ^

    (162:21) ges.map((                <--      (132:21) ges.map((
                 ^                                          ^

    (162:24) .map(({ o                <--      (132:24) .map(({
                 ^                                          ^

    (162:25) map(({ or                <--      (132:25) map(({
                 ^                                          ^

    (162:26) ap(({ ori                <--      (132:26) ap(({
                 ^                                          ^

    (162:28) (({ origi                <--       (133:4)     origi
                 ^                                          ^

    (162:36) inal, gen                <--      (133:12) inal,
                 ^                                          ^

    (162:38) al, gener                <--       (134:4)     gener
                 ^                                          ^

    (162:47) ated, sou                <--      (134:13) ated,
                 ^                                          ^

    (162:49) ed, sourc                <--       (135:4)     sourc
                 ^                                          ^

    (162:56) rce }) =>                <--       (136:2)   }) =>
                 ^                                        ^

    (162:57) ce }) =>                 <--       (136:3)   }) =>
                 ^                                         ^

    (162:62)  => {                    <--       (136:8)  => {
                 ^                                          ^

     (163:4)     let i                <--       (137:4)     let i
                 ^                                          ^

     (163:8) let input                <--       (137:8) let input
                 ^                                          ^

    (163:13) nput;                    <--      (137:13) nput;
                 ^                                          ^

     (164:4)     let o                <--       (138:4)     let o
                 ^                                          ^

     (164:8) let outpu                <--       (138:8) let outpu
                 ^                                          ^

    (164:14) tput;                    <--      (138:14) tput;
                 ^                                          ^

     (166:4)     if (o                <--       (139:4)     if (o
                 ^                                          ^

     (166:8) if (origi                <--       (139:8) if (origi
                 ^                                          ^

    (166:16) inal.to)                 <--      (139:16) inal.to)
                 ^                                          ^

    (166:17) nal.to) {                <--      (139:17) nal.to) {
                 ^                                          ^

    (166:19) l.to) {                  <--      (139:19) l.to) {
                 ^                                          ^

    (166:21) to) {                    <--      (139:21) to) {
                 ^                                          ^

     (167:6)     input                <--       (140:6)     input
                 ^                                          ^

    (167:11) nput = si                <--      (140:11) nput = si
                 ^                                          ^

    (167:14) t = simpl                <--      (140:14) t = simpl
                 ^                                          ^

    (167:34) ange(                    <--      (140:34) ange(sour
                 ^                                          ^

     (168:8)     sourc                <--      (140:35) nge(sourc
                 ^                                          ^

    (168:20) ines.get(                <--      (140:47) ines.get(
                 ^                                          ^

    (168:21) nes.get(s                <--      (140:48) nes.get(s
                 ^                                          ^

    (168:24) .get(sour                <--      (140:51) .get(sour
                 ^                                          ^

    (168:25) get(sourc                <--      (140:52) get(sourc
                 ^                                          ^

    (168:31) urce)!,                  <--      (140:58) urce), or
                 ^                                          ^

    (168:32) rce)!,                   <--      (140:59) rce), ori
                 ^                                          ^

     (169:8)     origi                <--      (140:61) e), origi
                 ^                                          ^

    (169:16) inal.from                <--      (140:69) inal.from
                 ^                                          ^

    (169:17) nal.from.                <--      (140:70) nal.from.
                 ^                                          ^

    (169:21) from.line                <--      (140:74) from.line
                 ^                                          ^

    (169:22) rom.line,                <--      (140:75) rom.line,
                 ^                                          ^

    (169:26) line,                    <--      (140:79) line, ori
                 ^                                          ^

     (170:8)     origi                <--      (140:81) ne, origi
                 ^                                          ^

    (170:16) inal.from                <--      (140:89) inal.from
                 ^                                          ^

    (170:17) nal.from.                <--      (140:90) nal.from.
                 ^                                          ^

    (170:21) from.colu                <--      (140:94) from.colu
                 ^                                          ^

    (170:22) rom.colum                <--      (140:95) rom.colum
                 ^                                          ^

    (170:28) lumn,                    <--     (140:101) lumn, ori
                 ^                                          ^

     (171:8)     origi                <--     (140:103) mn, origi
                 ^                                          ^

    (171:16) inal.to.l                <--     (140:111) inal.to.l
                 ^                                          ^

    (171:17) nal.to.li                <--     (140:112) nal.to.li
                 ^                                          ^

    (171:19) l.to.line                <--     (140:114) l.to.line
                 ^                                          ^

    (171:20) .to.line,                <--     (140:115) .to.line,
                 ^                                          ^

    (171:24) line,                    <--     (140:119) line, ori
                 ^                                          ^

     (172:8)     origi                <--     (140:121) ne, origi
                 ^                                          ^

    (172:16) inal.to.c                <--     (140:129) inal.to.c
                 ^                                          ^

    (172:17) nal.to.co                <--     (140:130) nal.to.co
                 ^                                          ^

    (172:19) l.to.colu                <--     (140:132) l.to.colu
                 ^                                          ^

    (172:20) .to.colum                <--     (140:133) .to.colum
                 ^                                          ^

     (173:6)     );                   <--     (140:139) lumn);
                 ^                                          ^

     (173:7)    );                    <--     (140:140) umn);
                 ^                                          ^

     (174:6)     outpu                <--       (141:6)     outpu
                 ^                                          ^

    (174:12) tput = si                <--      (141:12) tput = si
                 ^                                          ^

    (174:15) t = simpl                <--      (141:15) t = simpl
                 ^                                          ^

    (174:35) ange(                    <--      (141:35) ange(outp
                 ^                                          ^

     (175:8)     outpu                <--      (141:36) nge(outpu
                 ^                                          ^

    (175:19) ines,                    <--      (141:47) ines, gen
                 ^                                          ^

     (176:8)     gener                <--      (141:49) es, gener
                 ^                                          ^

    (176:17) ated.from                <--      (141:58) ated.from
                 ^                                          ^

    (176:18) ted.from.                <--      (141:59) ted.from.
                 ^                                          ^

    (176:22) from.line                <--      (141:63) from.line
                 ^                                          ^

    (176:23) rom.line,                <--      (141:64) rom.line,
                 ^                                          ^

    (176:27) line,                    <--      (141:68) line, gen
                 ^                                          ^

     (177:8)     gener                <--      (141:70) ne, gener
                 ^                                          ^

    (177:17) ated.from                <--      (141:79) ated.from
                 ^                                          ^

    (177:18) ted.from.                <--      (141:80) ted.from.
                 ^                                          ^

    (177:22) from.colu                <--      (141:84) from.colu
                 ^                                          ^

    (177:23) rom.colum                <--      (141:85) rom.colum
                 ^                                          ^

    (177:29) lumn,                    <--      (141:91) lumn, gen
                 ^                                          ^

     (178:8)     gener                <--      (141:93) mn, gener
                 ^                                          ^

    (178:17) ated.to!.                <--     (141:102) ated.to.l
                 ^                                          ^

    (178:18) ted.to!.l                <--     (141:103) ted.to.li
                 ^                                          ^

    (178:20) d.to!.lin                <--     (141:105) d.to.line
                 ^                                          ^

    (178:22) to!.line,                <--     (141:106) .to.line,
                 ^                                          ^

    (178:26) line,                    <--     (141:110) line, gen
                 ^                                          ^

     (179:8)     gener                <--     (141:112) ne, gener
                 ^                                          ^

    (179:17) ated.to!.                <--     (141:121) ated.to.c
                 ^                                          ^

    (179:18) ted.to!.c                <--     (141:122) ted.to.co
                 ^                                          ^

    (179:20) d.to!.col                <--     (141:124) d.to.colu
                 ^                                          ^

    (179:22) to!.colum                <--     (141:125) .to.colum
                 ^                                          ^

     (180:6)     );                   <--     (141:131) lumn);
                 ^                                          ^

     (180:7)    );                    <--     (141:132) umn);
                 ^                                          ^

     (181:4)     } els                <--       (142:4)     } els
                 ^                                          ^

     (181:5)    } else                <--       (142:5)    } else
                 ^                                          ^

    (181:11) lse {                    <--      (142:11) lse {
                 ^                                          ^

     (182:6)     input                <--       (143:6)     input
                 ^                                          ^

    (182:11) nput = si                <--      (143:11) nput = si
                 ^                                          ^

    (182:14) t = simpl                <--      (143:14) t = simpl
                 ^                                          ^

    (182:34) oint(                    <--      (143:34) oint(sour
                 ^                                          ^

     (183:8)     sourc                <--      (143:35) int(sourc
                 ^                                          ^

    (183:20) ines.get(                <--      (143:47) ines.get(
                 ^                                          ^

    (183:21) nes.get(s                <--      (143:48) nes.get(s
                 ^                                          ^

    (183:24) .get(sour                <--      (143:51) .get(sour
                 ^                                          ^

    (183:25) get(sourc                <--      (143:52) get(sourc
                 ^                                          ^

    (183:31) urce)!,                  <--      (143:58) urce), or
                 ^                                          ^

    (183:32) rce)!,                   <--      (143:59) rce), ori
                 ^                                          ^

     (184:8)     origi                <--      (143:61) e), origi
                 ^                                          ^

    (184:16) inal.from                <--      (143:69) inal.from
                 ^                                          ^

    (184:17) nal.from.                <--      (143:70) nal.from.
                 ^                                          ^

    (184:21) from.line                <--      (143:74) from.line
                 ^                                          ^

    (184:22) rom.line,                <--      (143:75) rom.line,
                 ^                                          ^

    (184:26) line,                    <--      (143:79) line, ori
                 ^                                          ^

     (185:8)     origi                <--      (143:81) ne, origi
                 ^                                          ^

    (185:16) inal.from                <--      (143:89) inal.from
                 ^                                          ^

    (185:17) nal.from.                <--      (143:90) nal.from.
                 ^                                          ^

    (185:21) from.colu                <--      (143:94) from.colu
                 ^                                          ^

    (185:22) rom.colum                <--      (143:95) rom.colum
                 ^                                          ^

     (186:6)     );                   <--     (143:101) lumn);
                 ^                                          ^

     (186:7)    );                    <--     (143:102) umn);
                 ^                                          ^

     (187:6)     outpu                <--       (144:6)     outpu
                 ^                                          ^

    (187:12) tput = si                <--      (144:12) tput = si
                 ^                                          ^

    (187:15) t = simpl                <--      (144:15) t = simpl
                 ^                                          ^

    (187:35) oint(                    <--      (144:35) oint(outp
                 ^                                          ^

     (188:8)     outpu                <--      (144:36) int(outpu
                 ^                                          ^

    (188:19) ines,                    <--      (144:47) ines, gen
                 ^                                          ^

     (189:8)     gener                <--      (144:49) es, gener
                 ^                                          ^

    (189:17) ated.from                <--      (144:58) ated.from
                 ^                                          ^

    (189:18) ted.from.                <--      (144:59) ted.from.
                 ^                                          ^

    (189:22) from.line                <--      (144:63) from.line
                 ^                                          ^

    (189:23) rom.line,                <--      (144:64) rom.line,
                 ^                                          ^

    (189:27) line,                    <--      (144:68) line, gen
                 ^                                          ^

     (190:8)     gener                <--      (144:70) ne, gener
                 ^                                          ^

    (190:17) ated.from                <--      (144:79) ated.from
                 ^                                          ^

    (190:18) ted.from.                <--      (144:80) ted.from.
                 ^                                          ^

    (190:22) from.colu                <--      (144:84) from.colu
                 ^                                          ^

    (190:23) rom.colum                <--      (144:85) rom.colum
                 ^                                          ^

     (191:6)     );                   <--      (144:91) lumn);
                 ^                                          ^

     (191:7)    );                    <--      (144:92) umn);
                 ^                                          ^

     (192:4)     }                    <--       (145:4)     }
                 ^                                          ^

     (194:4)     retur                <--       (146:4)     retur
                 ^                                          ^

    (194:11) urn joinM                <--      (146:11) urn joinM
                 ^                                          ^

    (194:24) line(                    <--      (146:24) line(join
                 ^                                          ^

     (195:6)     joinM                <--      (146:25) ine(joinM
                 ^                                          ^

    (195:19) line(                    <--      (146:38) line(inpu
                 ^                                          ^

     (196:8)     input                <--      (146:39) ine(input
                 ^                                          ^

    (196:13) nput,                    <--      (146:44) nput, " <
                 ^                                          ^

     (197:8)     " <--                <--      (146:46) ut, " <--
                 ^                                          ^

    (197:16) -  ",                    <--      (146:54) -  ", LOC
                 ^                                          ^

     (198:8)     LOC_S                <--      (146:56)  ", LOC_S
                 ^                                          ^

    (198:16) SIZE + CO                <--      (146:64) SIZE + CO
                 ^                                          ^

    (198:19) E + CONTE                <--      (146:67) E + CONTE
                 ^                                          ^

    (198:31) SIZE * 2                 <--      (146:79) SIZE * 2
                 ^                                          ^

    (198:34) E * 2 + C                <--      (146:82) E * 2 + C
                 ^                                          ^

    (198:35)  * 2 + CO                <--      (146:83)  * 2 + CO
                 ^                                          ^

    (198:38) 2 + CONTE                <--      (146:86) 2 + CONTE
                 ^                                          ^

     (199:6)     ),                   <--      (146:98) SIZE), ou
                 ^                                          ^

     (199:7)    ),                    <--      (146:99) IZE), out
                 ^                                          ^

     (200:6)     outpu                <--     (146:101) E), outpu
                 ^                                          ^

     (201:4)     );                   <--     (146:107) tput);
                 ^                                          ^

     (201:5)    );                    <--     (146:108) put);
                 ^                                          ^

     (202:2)   });                    <--       (147:2)   });
               ^                                          ^

     (202:3)   });                    <--       (147:3)   });
                ^                                          ^

     (202:4)   });                    <--       (147:4)   });
                 ^                                          ^

     (204:2)   retur                  <--       (148:2)   retur
               ^                                          ^

     (204:9) urn res.j                <--       (148:9) urn res.j
                 ^                                          ^

    (204:12)  res.join                <--      (148:12)  res.join
                 ^                                          ^

    (204:13) res.join(                <--      (148:13) res.join(
                 ^                                          ^

    (204:17) join("\n\                <--      (148:17) join("\n\
                 ^                                          ^

    (204:18) oin("\n\n                <--      (148:18) oin("\n\n
                 ^                                          ^

    (204:24) n\n");                   <--      (148:24) n\n");
                 ^                                          ^

    (204:25) \n");                    <--      (148:25) \n");
                 ^                                          ^

     (205:0) }                        <--       (149:0) }
             ^                                          ^
