---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "lib",
    default: None,
   },
  ],
  ellipsis: false,
 },
 definition: LetIn {
  bindings: [
   Inherit {
    from: Some(
     Variable {
      identifier: "builtins",
      position: (5, 10),
     },
    ),
    attributes: [
     Raw {
      content: "length",
      position: (5, 20),
     },
    ],
   },
  ],
  target: Map {
   bindings: [
    Inherit {
     from: Some(
      Variable {
       identifier: "builtins",
       position: (11, 12),
      },
     ),
     attributes: [
      Raw {
       content: "compareVersions",
       position: (12, 5),
      },
      Raw {
       content: "elem",
       position: (13, 5),
      },
      Raw {
       content: "elemAt",
       position: (14, 5),
      },
      Raw {
       content: "filter",
       position: (15, 5),
      },
      Raw {
       content: "fromJSON",
       position: (16, 5),
      },
      Raw {
       content: "head",
       position: (17, 5),
      },
      Raw {
       content: "isInt",
       position: (18, 5),
      },
      Raw {
       content: "isList",
       position: (19, 5),
      },
      Raw {
       content: "isString",
       position: (20, 5),
      },
      Raw {
       content: "match",
       position: (21, 5),
      },
      Raw {
       content: "parseDrvName",
       position: (22, 5),
      },
      Raw {
       content: "readFile",
       position: (23, 5),
      },
      Raw {
       content: "replaceStrings",
       position: (24, 5),
      },
      Raw {
       content: "split",
       position: (25, 5),
      },
      Raw {
       content: "storeDir",
       position: (26, 5),
      },
      Raw {
       content: "stringLength",
       position: (27, 5),
      },
      Raw {
       content: "substring",
       position: (28, 5),
      },
      Raw {
       content: "tail",
       position: (29, 5),
      },
      Raw {
       content: "toJSON",
       position: (30, 5),
      },
      Raw {
       content: "typeOf",
       position: (31, 5),
      },
      Raw {
       content: "unsafeDiscardStringContext",
       position: (32, 5),
      },
     ],
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "concatStrings",
        position: (43, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "builtins",
        position: (43, 19),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "concatStringsSep",
          position: (43, 28),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [],
        position: (43, 45),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "concatMapStrings",
        position: (53, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "f",
      },
      definition: Function {
       argument: Simple {
        identifier: "list",
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "concatStrings",
         position: (53, 31),
        },
        arguments: [
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "map",
            position: (53, 46),
           },
           arguments: [
            Variable {
             identifier: "f",
             position: (53, 50),
            },
            Variable {
             identifier: "list",
             position: (53, 52),
            },
           ],
          },
          position: (53, 45),
         },
        ],
       },
       position: (53, 25),
      },
      position: (53, 22),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "concatImapStrings",
        position: (64, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "f",
      },
      definition: Function {
       argument: Simple {
        identifier: "list",
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "concatStrings",
         position: (64, 32),
        },
        arguments: [
         Parentheses {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (64, 47),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "imap1",
               position: (64, 51),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "f",
             position: (64, 57),
            },
            Variable {
             identifier: "list",
             position: (64, 59),
            },
           ],
          },
          position: (64, 46),
         },
        ],
       },
       position: (64, 26),
      },
      position: (64, 23),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "intersperse",
        position: (74, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "separator",
      },
      definition: Function {
       argument: Simple {
        identifier: "list",
       },
       definition: IfThenElse {
        predicate: BinaryOperation {
         operator: LogicalOr,
         operands: [
          BinaryOperation {
           operator: EqualTo,
           operands: [
            Variable {
             identifier: "list",
             position: (79, 8),
            },
            List {
             elements: [],
             position: (79, 16),
            },
           ],
           position: (79, 13),
          },
          BinaryOperation {
           operator: EqualTo,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "length",
              position: (79, 22),
             },
             arguments: [
              Variable {
               identifier: "list",
               position: (79, 29),
              },
             ],
            },
            Int {
             value: 1,
             position: (79, 37),
            },
           ],
           position: (79, 34),
          },
         ],
         position: (79, 19),
        },
        then: Variable {
         identifier: "list",
         position: (80, 10),
        },
        else_: FunctionApplication {
         function: Variable {
          identifier: "tail",
          position: (81, 10),
         },
         arguments: [
          Parentheses {
           expression: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (81, 16),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "concatMap",
                position: (81, 20),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Parentheses {
              expression: Function {
               argument: Simple {
                identifier: "x",
               },
               definition: List {
                elements: [
                 Variable {
                  identifier: "separator",
                  position: (81, 35),
                 },
                 Variable {
                  identifier: "x",
                  position: (81, 45),
                 },
                ],
                position: (81, 34),
               },
               position: (81, 31),
              },
              position: (81, 30),
             },
             Variable {
              identifier: "list",
              position: (81, 49),
             },
            ],
           },
           position: (81, 15),
          },
         ],
        },
        position: (79, 5),
       },
       position: (78, 5),
      },
      position: (76, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "concatStringsSep",
        position: (91, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "builtins",
       position: (91, 22),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "concatStringsSep",
         position: (91, 31),
        },
       ],
      },
      default: Some(
       Parentheses {
        expression: Function {
         argument: Simple {
          identifier: "separator",
         },
         definition: Function {
          argument: Simple {
           identifier: "list",
          },
          definition: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (92, 5),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "foldl'",
               position: (92, 9),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "x",
              },
              definition: Function {
               argument: Simple {
                identifier: "y",
               },
               definition: BinaryOperation {
                operator: Addition,
                operands: [
                 Variable {
                  identifier: "x",
                  position: (92, 23),
                 },
                 Variable {
                  identifier: "y",
                  position: (92, 27),
                 },
                ],
                position: (92, 25),
               },
               position: (92, 20),
              },
              position: (92, 17),
             },
             position: (92, 16),
            },
            String {
             parts: [],
             position: (92, 30),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "intersperse",
               position: (92, 34),
              },
              arguments: [
               Variable {
                identifier: "separator",
                position: (92, 46),
               },
               Variable {
                identifier: "list",
                position: (92, 56),
               },
              ],
             },
             position: (92, 33),
            },
           ],
          },
          position: (91, 63),
         },
         position: (91, 52),
        },
        position: (91, 51),
       },
      ),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "concatMapStringsSep",
        position: (104, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "sep",
      },
      definition: Function {
       argument: Simple {
        identifier: "f",
       },
       definition: Function {
        argument: Simple {
         identifier: "list",
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "concatStringsSep",
          position: (110, 11),
         },
         arguments: [
          Variable {
           identifier: "sep",
           position: (110, 28),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "map",
             position: (110, 33),
            },
            arguments: [
             Variable {
              identifier: "f",
              position: (110, 37),
             },
             Variable {
              identifier: "list",
              position: (110, 39),
             },
            ],
           },
           position: (110, 32),
          },
         ],
        },
        position: (110, 5),
       },
       position: (108, 5),
      },
      position: (106, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "concatImapStringsSep",
        position: (121, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "sep",
      },
      definition: Function {
       argument: Simple {
        identifier: "f",
       },
       definition: Function {
        argument: Simple {
         identifier: "list",
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "concatStringsSep",
          position: (127, 11),
         },
         arguments: [
          Variable {
           identifier: "sep",
           position: (127, 28),
          },
          Parentheses {
           expression: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (127, 33),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "imap1",
                position: (127, 37),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "f",
              position: (127, 43),
             },
             Variable {
              identifier: "list",
              position: (127, 45),
             },
            ],
           },
           position: (127, 32),
          },
         ],
        },
        position: (127, 5),
       },
       position: (125, 5),
      },
      position: (123, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "makeSearchPath",
        position: (140, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "subDir",
      },
      definition: Function {
       argument: Simple {
        identifier: "paths",
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "concatStringsSep",
         position: (145, 5),
        },
        arguments: [
         String {
          parts: [
           Raw {
            content: ":",
            position: (145, 23),
           },
          ],
          position: (145, 22),
         },
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "map",
            position: (145, 27),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "path",
              },
              definition: BinaryOperation {
               operator: Addition,
               operands: [
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  Variable {
                   identifier: "path",
                   position: (145, 38),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "/",
                     position: (145, 46),
                    },
                   ],
                   position: (145, 45),
                  },
                 ],
                 position: (145, 43),
                },
                Variable {
                 identifier: "subDir",
                 position: (145, 51),
                },
               ],
               position: (145, 49),
              },
              position: (145, 32),
             },
             position: (145, 31),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "filter",
               position: (145, 60),
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "x",
                 },
                 definition: BinaryOperation {
                  operator: NotEqualTo,
                  operands: [
                   Variable {
                    identifier: "x",
                    position: (145, 71),
                   },
                   Variable {
                    identifier: "null",
                    position: (145, 76),
                   },
                  ],
                  position: (145, 73),
                 },
                 position: (145, 68),
                },
                position: (145, 67),
               },
               Variable {
                identifier: "paths",
                position: (145, 82),
               },
              ],
             },
             position: (145, 59),
            },
           ],
          },
          position: (145, 26),
         },
        ],
       },
       position: (144, 5),
      },
      position: (142, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "makeSearchPathOutput",
        position: (158, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "output",
      },
      definition: Function {
       argument: Simple {
        identifier: "subDir",
       },
       definition: Function {
        argument: Simple {
         identifier: "pkgs",
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "makeSearchPath",
          position: (164, 11),
         },
         arguments: [
          Variable {
           identifier: "subDir",
           position: (164, 26),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "map",
             position: (164, 34),
            },
            arguments: [
             Parentheses {
              expression: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (164, 39),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "getOutput",
                   position: (164, 43),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "output",
                 position: (164, 53),
                },
               ],
              },
              position: (164, 38),
             },
             Variable {
              identifier: "pkgs",
              position: (164, 61),
             },
            ],
           },
           position: (164, 33),
          },
         ],
        },
        position: (164, 5),
       },
       position: (162, 5),
      },
      position: (160, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "makeLibraryPath",
        position: (176, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "makeSearchPathOutput",
       position: (176, 21),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "lib",
          position: (176, 43),
         },
        ],
        position: (176, 42),
       },
       String {
        parts: [
         Raw {
          content: "lib",
          position: (176, 49),
         },
        ],
        position: (176, 48),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "makeBinPath",
        position: (185, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "makeSearchPathOutput",
       position: (185, 17),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "bin",
          position: (185, 39),
         },
        ],
        position: (185, 38),
       },
       String {
        parts: [
         Raw {
          content: "bin",
          position: (185, 45),
         },
        ],
        position: (185, 44),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "optionalString",
        position: (198, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "cond",
      },
      definition: Function {
       argument: Simple {
        identifier: "string",
       },
       definition: IfThenElse {
        predicate: Variable {
         identifier: "cond",
         position: (202, 16),
        },
        then: Variable {
         identifier: "string",
         position: (202, 26),
        },
        else_: String {
         parts: [],
         position: (202, 38),
        },
        position: (202, 13),
       },
       position: (202, 5),
      },
      position: (200, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "hasPrefix",
        position: (214, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "pref",
      },
      definition: Function {
       argument: Simple {
        identifier: "str",
       },
       definition: BinaryOperation {
        operator: EqualTo,
        operands: [
         FunctionApplication {
          function: Variable {
           identifier: "substring",
           position: (218, 10),
          },
          arguments: [
           Int {
            value: 0,
            position: (218, 20),
           },
           Parentheses {
            expression: FunctionApplication {
             function: Variable {
              identifier: "stringLength",
              position: (218, 23),
             },
             arguments: [
              Variable {
               identifier: "pref",
               position: (218, 36),
              },
             ],
            },
            position: (218, 22),
           },
           Variable {
            identifier: "str",
            position: (218, 42),
           },
          ],
         },
         Variable {
          identifier: "pref",
          position: (218, 49),
         },
        ],
        position: (218, 46),
       },
       position: (218, 5),
      },
      position: (216, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "hasSuffix",
        position: (230, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "suffix",
      },
      definition: Function {
       argument: Simple {
        identifier: "content",
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "lenContent",
             position: (236, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "stringLength",
            position: (236, 20),
           },
           arguments: [
            Variable {
             identifier: "content",
             position: (236, 33),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "lenSuffix",
             position: (237, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "stringLength",
            position: (237, 19),
           },
           arguments: [
            Variable {
             identifier: "suffix",
             position: (237, 32),
            },
           ],
          },
         },
        ],
        target: BinaryOperation {
         operator: LogicalAnd,
         operands: [
          BinaryOperation {
           operator: GreaterThanOrEqualTo,
           operands: [
            Variable {
             identifier: "lenContent",
             position: (238, 8),
            },
            Variable {
             identifier: "lenSuffix",
             position: (238, 22),
            },
           ],
           position: (238, 19),
          },
          BinaryOperation {
           operator: EqualTo,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "substring",
              position: (239, 8),
             },
             arguments: [
              Parentheses {
               expression: BinaryOperation {
                operator: Subtraction,
                operands: [
                 Variable {
                  identifier: "lenContent",
                  position: (239, 19),
                 },
                 Variable {
                  identifier: "lenSuffix",
                  position: (239, 32),
                 },
                ],
                position: (239, 30),
               },
               position: (239, 18),
              },
              Variable {
               identifier: "lenContent",
               position: (239, 43),
              },
              Variable {
               identifier: "content",
               position: (239, 54),
              },
             ],
            },
            Variable {
             identifier: "suffix",
             position: (239, 65),
            },
           ],
           position: (239, 62),
          },
         ],
         position: (238, 32),
        },
        position: (235, 5),
       },
       position: (234, 5),
      },
      position: (232, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "hasInfix",
        position: (255, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "infix",
      },
      definition: Function {
       argument: Simple {
        identifier: "content",
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "drop",
             position: (257, 7),
            },
           ],
          },
          to: Function {
           argument: Simple {
            identifier: "x",
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "substring",
             position: (257, 17),
            },
            arguments: [
             Int {
              value: 1,
              position: (257, 27),
             },
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "stringLength",
                position: (257, 30),
               },
               arguments: [
                Variable {
                 identifier: "x",
                 position: (257, 43),
                },
               ],
              },
              position: (257, 29),
             },
             Variable {
              identifier: "x",
              position: (257, 46),
             },
            ],
           },
           position: (257, 14),
          },
         },
        ],
        target: BinaryOperation {
         operator: LogicalOr,
         operands: [
          FunctionApplication {
           function: Variable {
            identifier: "hasPrefix",
            position: (258, 8),
           },
           arguments: [
            Variable {
             identifier: "infix",
             position: (258, 18),
            },
            Variable {
             identifier: "content",
             position: (258, 24),
            },
           ],
          },
          BinaryOperation {
           operator: LogicalAnd,
           operands: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              Variable {
               identifier: "content",
               position: (259, 10),
              },
              String {
               parts: [],
               position: (259, 21),
              },
             ],
             position: (259, 18),
            },
            FunctionApplication {
             function: Variable {
              identifier: "hasInfix",
              position: (259, 27),
             },
             arguments: [
              Variable {
               identifier: "infix",
               position: (259, 36),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "drop",
                 position: (259, 43),
                },
                arguments: [
                 Variable {
                  identifier: "content",
                  position: (259, 48),
                 },
                ],
               },
               position: (259, 42),
              },
             ],
            },
           ],
           position: (259, 24),
          },
         ],
         position: (259, 7),
        },
        position: (256, 5),
       },
       position: (255, 21),
      },
      position: (255, 14),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "stringToCharacters",
        position: (279, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "s",
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "map",
        position: (280, 5),
       },
       arguments: [
        Parentheses {
         expression: Function {
          argument: Simple {
           identifier: "p",
          },
          definition: FunctionApplication {
           function: Variable {
            identifier: "substring",
            position: (280, 13),
           },
           arguments: [
            Variable {
             identifier: "p",
             position: (280, 23),
            },
            Int {
             value: 1,
             position: (280, 25),
            },
            Variable {
             identifier: "s",
             position: (280, 27),
            },
           ],
          },
          position: (280, 10),
         },
         position: (280, 9),
        },
        Parentheses {
         expression: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (280, 31),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "range",
              position: (280, 35),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Int {
            value: 0,
            position: (280, 41),
           },
           Parentheses {
            expression: BinaryOperation {
             operator: Subtraction,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "stringLength",
                position: (280, 44),
               },
               arguments: [
                Variable {
                 identifier: "s",
                 position: (280, 57),
                },
               ],
              },
              Int {
               value: 1,
               position: (280, 61),
              },
             ],
             position: (280, 59),
            },
            position: (280, 43),
           },
          ],
         },
         position: (280, 30),
        },
       ],
      },
      position: (279, 24),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "stringAsChars",
        position: (291, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "f",
      },
      definition: Function {
       argument: Simple {
        identifier: "s",
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "concatStrings",
         position: (295, 8),
        },
        arguments: [
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "map",
            position: (296, 7),
           },
           arguments: [
            Variable {
             identifier: "f",
             position: (296, 11),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "stringToCharacters",
               position: (296, 14),
              },
              arguments: [
               Variable {
                identifier: "s",
                position: (296, 33),
               },
              ],
             },
             position: (296, 13),
            },
           ],
          },
          position: (295, 22),
         },
        ],
       },
       position: (295, 5),
      },
      position: (293, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "escape",
        position: (308, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "list",
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "replaceChars",
        position: (308, 18),
       },
       arguments: [
        Variable {
         identifier: "list",
         position: (308, 31),
        },
        Parentheses {
         expression: FunctionApplication {
          function: Variable {
           identifier: "map",
           position: (308, 37),
          },
          arguments: [
           Parentheses {
            expression: Function {
             argument: Simple {
              identifier: "c",
             },
             definition: String {
              parts: [
               Raw {
                content: "\\",
                position: (308, 46),
               },
               Interpolation {
                expression: Variable {
                 identifier: "c",
                 position: (308, 50),
                },
               },
              ],
              position: (308, 45),
             },
             position: (308, 42),
            },
            position: (308, 41),
           },
           Variable {
            identifier: "list",
            position: (308, 55),
           },
          ],
         },
         position: (308, 36),
        },
       ],
      },
      position: (308, 12),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "escapeShellArg",
        position: (318, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "arg",
      },
      definition: String {
       parts: [
        Raw {
         content: "'",
         position: (318, 26),
        },
        Interpolation {
         expression: FunctionApplication {
          function: Variable {
           identifier: "replaceStrings",
           position: (318, 29),
          },
          arguments: [
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "'",
                position: (318, 46),
               },
              ],
              position: (318, 45),
             },
            ],
            position: (318, 44),
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "'\\''",
                position: (318, 52),
               },
              ],
              position: (318, 51),
             },
            ],
            position: (318, 50),
           },
           Parentheses {
            expression: FunctionApplication {
             function: Variable {
              identifier: "toString",
              position: (318, 61),
             },
             arguments: [
              Variable {
               identifier: "arg",
               position: (318, 70),
              },
             ],
            },
            position: (318, 60),
           },
          ],
         },
        },
        Raw {
         content: "'",
         position: (318, 75),
        },
       ],
       position: (318, 25),
      },
      position: (318, 20),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "escapeShellArgs",
        position: (328, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "concatMapStringsSep",
       position: (328, 21),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: " ",
          position: (328, 42),
         },
        ],
        position: (328, 41),
       },
       Variable {
        identifier: "escapeShellArg",
        position: (328, 45),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "escapeNixString",
        position: (338, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "s",
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "escape",
        position: (338, 24),
       },
       arguments: [
        List {
         elements: [
          String {
           parts: [
            Raw {
             content: "$",
             position: (338, 33),
            },
           ],
           position: (338, 32),
          },
         ],
         position: (338, 31),
        },
        Parentheses {
         expression: FunctionApplication {
          function: Variable {
           identifier: "toJSON",
           position: (338, 38),
          },
          arguments: [
           Variable {
            identifier: "s",
            position: (338, 45),
           },
          ],
         },
         position: (338, 37),
        },
       ],
      },
      position: (338, 21),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "escapeRegex",
        position: (348, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "escape",
       position: (348, 17),
      },
      arguments: [
       Parentheses {
        expression: FunctionApplication {
         function: Variable {
          identifier: "stringToCharacters",
          position: (348, 25),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "\\[{()^$?*+|.",
             position: (348, 45),
            },
           ],
           position: (348, 44),
          },
         ],
        },
        position: (348, 24),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "escapeNixIdentifier",
        position: (360, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "s",
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: NotEqualTo,
        operands: [
         FunctionApplication {
          function: Variable {
           identifier: "match",
           position: (362, 8),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "[a-zA-Z_][a-zA-Z0-9_'-]*",
              position: (362, 15),
             },
            ],
            position: (362, 14),
           },
           Variable {
            identifier: "s",
            position: (362, 41),
           },
          ],
         },
         Variable {
          identifier: "null",
          position: (362, 46),
         },
        ],
        position: (362, 43),
       },
       then: Variable {
        identifier: "s",
        position: (363, 10),
       },
       else_: FunctionApplication {
        function: Variable {
         identifier: "escapeNixString",
         position: (363, 17),
        },
        arguments: [
         Variable {
          identifier: "s",
          position: (363, 33),
         },
        ],
       },
       position: (362, 5),
      },
      position: (360, 25),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "escapeXML",
        position: (374, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "builtins",
        position: (374, 15),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "replaceStrings",
          position: (374, 24),
         },
        ],
       },
       default: None,
      },
      arguments: [
       List {
        elements: [
         String {
          parts: [
           Raw {
            content: "\"",
            position: (375, 7),
           },
          ],
          position: (375, 6),
         },
         String {
          parts: [
           Raw {
            content: "'",
            position: (375, 12),
           },
          ],
          position: (375, 11),
         },
         String {
          parts: [
           Raw {
            content: "<",
            position: (375, 16),
           },
          ],
          position: (375, 15),
         },
         String {
          parts: [
           Raw {
            content: ">",
            position: (375, 20),
           },
          ],
          position: (375, 19),
         },
         String {
          parts: [
           Raw {
            content: "&",
            position: (375, 24),
           },
          ],
          position: (375, 23),
         },
        ],
        position: (375, 5),
       },
       List {
        elements: [
         String {
          parts: [
           Raw {
            content: "&quot;",
            position: (376, 7),
           },
          ],
          position: (376, 6),
         },
         String {
          parts: [
           Raw {
            content: "&apos;",
            position: (376, 16),
           },
          ],
          position: (376, 15),
         },
         String {
          parts: [
           Raw {
            content: "&lt;",
            position: (376, 25),
           },
          ],
          position: (376, 24),
         },
         String {
          parts: [
           Raw {
            content: "&gt;",
            position: (376, 32),
           },
          ],
          position: (376, 31),
         },
         String {
          parts: [
           Raw {
            content: "&amp;",
            position: (376, 39),
           },
          ],
          position: (376, 38),
         },
        ],
        position: (376, 5),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "replaceChars",
        position: (379, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "builtins",
       position: (379, 18),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "replaceStrings",
         position: (379, 27),
        },
       ],
      },
      default: Some(
       Parentheses {
        expression: Function {
         argument: Simple {
          identifier: "del",
         },
         definition: Function {
          argument: Simple {
           identifier: "new",
          },
          definition: Function {
           argument: Simple {
            identifier: "s",
           },
           definition: LetIn {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "substList",
                 position: (382, 7),
                },
               ],
              },
              to: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (382, 19),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "zipLists",
                   position: (382, 23),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "del",
                 position: (382, 32),
                },
                Variable {
                 identifier: "new",
                 position: (382, 36),
                },
               ],
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "subst",
                 position: (383, 7),
                },
               ],
              },
              to: Function {
               argument: Simple {
                identifier: "c",
               },
               definition: LetIn {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "found",
                     position: (384, 13),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (384, 21),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "findFirst",
                       position: (384, 25),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Parentheses {
                     expression: Function {
                      argument: Simple {
                       identifier: "sub",
                      },
                      definition: BinaryOperation {
                       operator: EqualTo,
                       operands: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "sub",
                          position: (384, 41),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "fst",
                            position: (384, 45),
                           },
                          ],
                         },
                         default: None,
                        },
                        Variable {
                         identifier: "c",
                         position: (384, 52),
                        },
                       ],
                       position: (384, 49),
                      },
                      position: (384, 36),
                     },
                     position: (384, 35),
                    },
                    Variable {
                     identifier: "null",
                     position: (384, 55),
                    },
                    Variable {
                     identifier: "substList",
                     position: (384, 60),
                    },
                   ],
                  },
                 },
                ],
                target: IfThenElse {
                 predicate: BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   Variable {
                    identifier: "found",
                    position: (385, 12),
                   },
                   Variable {
                    identifier: "null",
                    position: (385, 21),
                   },
                  ],
                  position: (385, 18),
                 },
                 then: Variable {
                  identifier: "c",
                  position: (386, 11),
                 },
                 else_: PropertyAccess {
                  expression: Variable {
                   identifier: "found",
                   position: (388, 11),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "snd",
                     position: (388, 17),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (385, 9),
                },
                position: (384, 9),
               },
               position: (383, 15),
              },
             },
            ],
            target: FunctionApplication {
             function: Variable {
              identifier: "stringAsChars",
              position: (390, 7),
             },
             arguments: [
              Variable {
               identifier: "subst",
               position: (390, 21),
              },
              Variable {
               identifier: "s",
               position: (390, 27),
              },
             ],
            },
            position: (381, 5),
           },
           position: (380, 15),
          },
          position: (380, 10),
         },
         position: (380, 5),
        },
        position: (379, 45),
       },
      ),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "lowerChars",
        position: (393, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "stringToCharacters",
       position: (393, 16),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "abcdefghijklmnopqrstuvwxyz",
          position: (393, 36),
         },
        ],
        position: (393, 35),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "upperChars",
        position: (394, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "stringToCharacters",
       position: (394, 16),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
          position: (394, 36),
         },
        ],
        position: (394, 35),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "toLower",
        position: (404, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "replaceChars",
       position: (404, 13),
      },
      arguments: [
       Variable {
        identifier: "upperChars",
        position: (404, 26),
       },
       Variable {
        identifier: "lowerChars",
        position: (404, 37),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "toUpper",
        position: (414, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "replaceChars",
       position: (414, 13),
      },
      arguments: [
       Variable {
        identifier: "lowerChars",
        position: (414, 26),
       },
       Variable {
        identifier: "upperChars",
        position: (414, 37),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "addContextFrom",
        position: (429, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "a",
      },
      definition: Function {
       argument: Simple {
        identifier: "b",
       },
       definition: BinaryOperation {
        operator: Addition,
        operands: [
         FunctionApplication {
          function: Variable {
           identifier: "substring",
           position: (429, 26),
          },
          arguments: [
           Int {
            value: 0,
            position: (429, 36),
           },
           Int {
            value: 0,
            position: (429, 38),
           },
           Variable {
            identifier: "a",
            position: (429, 40),
           },
          ],
         },
         Variable {
          identifier: "b",
          position: (429, 44),
         },
        ],
        position: (429, 42),
       },
       position: (429, 23),
      },
      position: (429, 20),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "splitString",
        position: (440, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "_sep",
      },
      definition: Function {
       argument: Simple {
        identifier: "_s",
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "sep",
             position: (442, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (442, 13),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "unsafeDiscardStringContext",
               position: (442, 22),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "_sep",
             position: (442, 49),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "s",
             position: (443, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (443, 11),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "unsafeDiscardStringContext",
               position: (443, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "_s",
             position: (443, 47),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "splits",
             position: (444, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (444, 16),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "filter",
               position: (444, 25),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (444, 32),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "isString",
                position: (444, 41),
               },
              ],
             },
             default: None,
            },
            Parentheses {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (444, 51),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "split",
                  position: (444, 60),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "escapeRegex",
                  position: (444, 67),
                 },
                 arguments: [
                  Variable {
                   identifier: "sep",
                   position: (444, 79),
                  },
                 ],
                },
                position: (444, 66),
               },
               Variable {
                identifier: "s",
                position: (444, 84),
               },
              ],
             },
             position: (444, 50),
            },
           ],
          },
         },
        ],
        target: FunctionApplication {
         function: Variable {
          identifier: "map",
          position: (446, 7),
         },
         arguments: [
          Parentheses {
           expression: Function {
            argument: Simple {
             identifier: "v",
            },
            definition: FunctionApplication {
             function: Variable {
              identifier: "addContextFrom",
              position: (446, 15),
             },
             arguments: [
              Variable {
               identifier: "_sep",
               position: (446, 30),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "addContextFrom",
                 position: (446, 36),
                },
                arguments: [
                 Variable {
                  identifier: "_s",
                  position: (446, 51),
                 },
                 Variable {
                  identifier: "v",
                  position: (446, 54),
                 },
                ],
               },
               position: (446, 35),
              },
             ],
            },
            position: (446, 12),
           },
           position: (446, 11),
          },
          Variable {
           identifier: "splits",
           position: (446, 58),
          },
         ],
        },
        position: (441, 5),
       },
       position: (440, 23),
      },
      position: (440, 17),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "removePrefix",
        position: (458, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "prefix",
      },
      definition: Function {
       argument: Simple {
        identifier: "str",
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "preLen",
             position: (464, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "stringLength",
            position: (464, 16),
           },
           arguments: [
            Variable {
             identifier: "prefix",
             position: (464, 29),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "sLen",
             position: (465, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "stringLength",
            position: (465, 14),
           },
           arguments: [
            Variable {
             identifier: "str",
             position: (465, 27),
            },
           ],
          },
         },
        ],
        target: IfThenElse {
         predicate: FunctionApplication {
          function: Variable {
           identifier: "hasPrefix",
           position: (467, 10),
          },
          arguments: [
           Variable {
            identifier: "prefix",
            position: (467, 20),
           },
           Variable {
            identifier: "str",
            position: (467, 27),
           },
          ],
         },
         then: FunctionApplication {
          function: Variable {
           identifier: "substring",
           position: (468, 9),
          },
          arguments: [
           Variable {
            identifier: "preLen",
            position: (468, 19),
           },
           Parentheses {
            expression: BinaryOperation {
             operator: Subtraction,
             operands: [
              Variable {
               identifier: "sLen",
               position: (468, 27),
              },
              Variable {
               identifier: "preLen",
               position: (468, 34),
              },
             ],
             position: (468, 32),
            },
            position: (468, 26),
           },
           Variable {
            identifier: "str",
            position: (468, 42),
           },
          ],
         },
         else_: Variable {
          identifier: "str",
          position: (470, 9),
         },
         position: (467, 7),
        },
        position: (463, 5),
       },
       position: (462, 5),
      },
      position: (460, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "removeSuffix",
        position: (482, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "suffix",
      },
      definition: Function {
       argument: Simple {
        identifier: "str",
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "sufLen",
             position: (488, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "stringLength",
            position: (488, 16),
           },
           arguments: [
            Variable {
             identifier: "suffix",
             position: (488, 29),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "sLen",
             position: (489, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "stringLength",
            position: (489, 14),
           },
           arguments: [
            Variable {
             identifier: "str",
             position: (489, 27),
            },
           ],
          },
         },
        ],
        target: IfThenElse {
         predicate: BinaryOperation {
          operator: LogicalAnd,
          operands: [
           BinaryOperation {
            operator: LessThanOrEqualTo,
            operands: [
             Variable {
              identifier: "sufLen",
              position: (491, 10),
             },
             Variable {
              identifier: "sLen",
              position: (491, 20),
             },
            ],
            position: (491, 17),
           },
           BinaryOperation {
            operator: EqualTo,
            operands: [
             Variable {
              identifier: "suffix",
              position: (491, 28),
             },
             FunctionApplication {
              function: Variable {
               identifier: "substring",
               position: (491, 38),
              },
              arguments: [
               Parentheses {
                expression: BinaryOperation {
                 operator: Subtraction,
                 operands: [
                  Variable {
                   identifier: "sLen",
                   position: (491, 49),
                  },
                  Variable {
                   identifier: "sufLen",
                   position: (491, 56),
                  },
                 ],
                 position: (491, 54),
                },
                position: (491, 48),
               },
               Variable {
                identifier: "sufLen",
                position: (491, 64),
               },
               Variable {
                identifier: "str",
                position: (491, 71),
               },
              ],
             },
            ],
            position: (491, 35),
           },
          ],
          position: (491, 25),
         },
         then: FunctionApplication {
          function: Variable {
           identifier: "substring",
           position: (492, 9),
          },
          arguments: [
           Int {
            value: 0,
            position: (492, 19),
           },
           Parentheses {
            expression: BinaryOperation {
             operator: Subtraction,
             operands: [
              Variable {
               identifier: "sLen",
               position: (492, 22),
              },
              Variable {
               identifier: "sufLen",
               position: (492, 29),
              },
             ],
             position: (492, 27),
            },
            position: (492, 21),
           },
           Variable {
            identifier: "str",
            position: (492, 37),
           },
          ],
         },
         else_: Variable {
          identifier: "str",
          position: (494, 9),
         },
         position: (491, 7),
        },
        position: (487, 5),
       },
       position: (486, 5),
      },
      position: (484, 5),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "versionOlder",
        position: (504, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "v1",
      },
      definition: Function {
       argument: Simple {
        identifier: "v2",
       },
       definition: BinaryOperation {
        operator: EqualTo,
        operands: [
         FunctionApplication {
          function: Variable {
           identifier: "compareVersions",
           position: (504, 26),
          },
          arguments: [
           Variable {
            identifier: "v2",
            position: (504, 42),
           },
           Variable {
            identifier: "v1",
            position: (504, 45),
           },
          ],
         },
         Int {
          value: 1,
          position: (504, 51),
         },
        ],
        position: (504, 48),
       },
       position: (504, 22),
      },
      position: (504, 18),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "versionAtLeast",
        position: (516, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "v1",
      },
      definition: Function {
       argument: Simple {
        identifier: "v2",
       },
       definition: UnaryOperation {
        operator: Not,
        operand: FunctionApplication {
         function: Variable {
          identifier: "versionOlder",
          position: (516, 29),
         },
         arguments: [
          Variable {
           identifier: "v1",
           position: (516, 42),
          },
          Variable {
           identifier: "v2",
           position: (516, 45),
          },
         ],
        },
        position: (516, 28),
       },
       position: (516, 24),
      },
      position: (516, 20),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "getName",
        position: (528, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "x",
      },
      definition: LetIn {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "parse",
            position: (530, 6),
           },
          ],
         },
         to: Function {
          argument: Simple {
           identifier: "drv",
          },
          definition: PropertyAccess {
           expression: Parentheses {
            expression: FunctionApplication {
             function: Variable {
              identifier: "parseDrvName",
              position: (530, 20),
             },
             arguments: [
              Variable {
               identifier: "drv",
               position: (530, 33),
              },
             ],
            },
            position: (530, 19),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "name",
              position: (530, 38),
             },
            ],
           },
           default: None,
          },
          position: (530, 14),
         },
        },
       ],
       target: IfThenElse {
        predicate: FunctionApplication {
         function: Variable {
          identifier: "isString",
          position: (531, 10),
         },
         arguments: [
          Variable {
           identifier: "x",
           position: (531, 19),
          },
         ],
        },
        then: FunctionApplication {
         function: Variable {
          identifier: "parse",
          position: (532, 12),
         },
         arguments: [
          Variable {
           identifier: "x",
           position: (532, 18),
          },
         ],
        },
        else_: PropertyAccess {
         expression: Variable {
          identifier: "x",
          position: (533, 12),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "pname",
            position: (533, 14),
           },
          ],
         },
         default: Some(
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "parse",
             position: (533, 24),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "x",
               position: (533, 30),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "name",
                 position: (533, 32),
                },
               ],
              },
              default: None,
             },
            ],
           },
           position: (533, 23),
          },
         ),
        },
        position: (531, 7),
       },
       position: (529, 4),
      },
      position: (528, 13),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "getVersion",
        position: (545, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "x",
      },
      definition: LetIn {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "parse",
            position: (547, 6),
           },
          ],
         },
         to: Function {
          argument: Simple {
           identifier: "drv",
          },
          definition: PropertyAccess {
           expression: Parentheses {
            expression: FunctionApplication {
             function: Variable {
              identifier: "parseDrvName",
              position: (547, 20),
             },
             arguments: [
              Variable {
               identifier: "drv",
               position: (547, 33),
              },
             ],
            },
            position: (547, 19),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "version",
              position: (547, 38),
             },
            ],
           },
           default: None,
          },
          position: (547, 14),
         },
        },
       ],
       target: IfThenElse {
        predicate: FunctionApplication {
         function: Variable {
          identifier: "isString",
          position: (548, 10),
         },
         arguments: [
          Variable {
           identifier: "x",
           position: (548, 19),
          },
         ],
        },
        then: FunctionApplication {
         function: Variable {
          identifier: "parse",
          position: (549, 12),
         },
         arguments: [
          Variable {
           identifier: "x",
           position: (549, 18),
          },
         ],
        },
        else_: PropertyAccess {
         expression: Variable {
          identifier: "x",
          position: (550, 12),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "version",
            position: (550, 14),
           },
          ],
         },
         default: Some(
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "parse",
             position: (550, 26),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "x",
               position: (550, 32),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "name",
                 position: (550, 34),
                },
               ],
              },
              default: None,
             },
            ],
           },
           position: (550, 25),
          },
         ),
        },
        position: (548, 7),
       },
       position: (546, 4),
      },
      position: (545, 16),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "nameFromURL",
        position: (561, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "url",
      },
      definition: Function {
       argument: Simple {
        identifier: "sep",
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "components",
             position: (563, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "splitString",
            position: (563, 20),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "/",
               position: (563, 33),
              },
             ],
             position: (563, 32),
            },
            Variable {
             identifier: "url",
             position: (563, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "filename",
             position: (564, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (564, 18),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "last",
               position: (564, 22),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "components",
             position: (564, 27),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "name",
             position: (565, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "head",
            position: (565, 14),
           },
           arguments: [
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "splitString",
               position: (565, 20),
              },
              arguments: [
               Variable {
                identifier: "sep",
                position: (565, 32),
               },
               Variable {
                identifier: "filename",
                position: (565, 36),
               },
              ],
             },
             position: (565, 19),
            },
           ],
          },
         },
        ],
        target: Assert {
         expression: BinaryOperation {
          operator: NotEqualTo,
          operands: [
           Variable {
            identifier: "name",
            position: (566, 15),
           },
           Variable {
            identifier: "filename",
            position: (566, 23),
           },
          ],
          position: (566, 20),
         },
         target: Variable {
          identifier: "name",
          position: (566, 33),
         },
         position: (566, 8),
        },
        position: (562, 5),
       },
       position: (561, 22),
      },
      position: (561, 17),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "enableFeature",
        position: (577, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "enable",
      },
      definition: Function {
       argument: Simple {
        identifier: "feat",
       },
       definition: Assert {
        expression: FunctionApplication {
         function: Variable {
          identifier: "isString",
          position: (578, 12),
         },
         arguments: [
          Variable {
           identifier: "feat",
           position: (578, 21),
          },
         ],
        },
        target: String {
         parts: [
          Raw {
           content: "--",
           position: (579, 6),
          },
          Interpolation {
           expression: IfThenElse {
            predicate: Variable {
             identifier: "enable",
             position: (579, 13),
            },
            then: String {
             parts: [
              Raw {
               content: "enable",
               position: (579, 26),
              },
             ],
             position: (579, 25),
            },
            else_: String {
             parts: [
              Raw {
               content: "disable",
               position: (579, 40),
              },
             ],
             position: (579, 39),
            },
            position: (579, 10),
           },
          },
          Raw {
           content: "-",
           position: (579, 49),
          },
          Interpolation {
           expression: Variable {
            identifier: "feat",
            position: (579, 52),
           },
          },
         ],
         position: (579, 5),
        },
        position: (578, 5),
       },
       position: (577, 27),
      },
      position: (577, 19),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "enableFeatureAs",
        position: (590, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "enable",
      },
      definition: Function {
       argument: Simple {
        identifier: "feat",
       },
       definition: Function {
        argument: Simple {
         identifier: "value",
        },
        definition: BinaryOperation {
         operator: Addition,
         operands: [
          FunctionApplication {
           function: Variable {
            identifier: "enableFeature",
            position: (590, 42),
           },
           arguments: [
            Variable {
             identifier: "enable",
             position: (590, 56),
            },
            Variable {
             identifier: "feat",
             position: (590, 63),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (590, 70),
           },
           arguments: [
            Variable {
             identifier: "enable",
             position: (590, 85),
            },
            String {
             parts: [
              Raw {
               content: "=",
               position: (590, 93),
              },
              Interpolation {
               expression: Variable {
                identifier: "value",
                position: (590, 96),
               },
              },
             ],
             position: (590, 92),
            },
           ],
          },
         ],
         position: (590, 68),
        },
        position: (590, 35),
       },
       position: (590, 29),
      },
      position: (590, 21),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "withFeature",
        position: (601, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "with_",
      },
      definition: Function {
       argument: Simple {
        identifier: "feat",
       },
       definition: Assert {
        expression: FunctionApplication {
         function: Variable {
          identifier: "isString",
          position: (602, 12),
         },
         arguments: [
          Variable {
           identifier: "feat",
           position: (602, 21),
          },
         ],
        },
        target: String {
         parts: [
          Raw {
           content: "--",
           position: (603, 6),
          },
          Interpolation {
           expression: IfThenElse {
            predicate: Variable {
             identifier: "with_",
             position: (603, 13),
            },
            then: String {
             parts: [
              Raw {
               content: "with",
               position: (603, 25),
              },
             ],
             position: (603, 24),
            },
            else_: String {
             parts: [
              Raw {
               content: "without",
               position: (603, 37),
              },
             ],
             position: (603, 36),
            },
            position: (603, 10),
           },
          },
          Raw {
           content: "-",
           position: (603, 46),
          },
          Interpolation {
           expression: Variable {
            identifier: "feat",
            position: (603, 49),
           },
          },
         ],
         position: (603, 5),
        },
        position: (602, 5),
       },
       position: (601, 24),
      },
      position: (601, 17),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "withFeatureAs",
        position: (614, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "with_",
      },
      definition: Function {
       argument: Simple {
        identifier: "feat",
       },
       definition: Function {
        argument: Simple {
         identifier: "value",
        },
        definition: BinaryOperation {
         operator: Addition,
         operands: [
          FunctionApplication {
           function: Variable {
            identifier: "withFeature",
            position: (614, 39),
           },
           arguments: [
            Variable {
             identifier: "with_",
             position: (614, 51),
            },
            Variable {
             identifier: "feat",
             position: (614, 57),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (614, 64),
           },
           arguments: [
            Variable {
             identifier: "with_",
             position: (614, 79),
            },
            String {
             parts: [
              Raw {
               content: "=",
               position: (614, 86),
              },
              Interpolation {
               expression: Variable {
                identifier: "value",
                position: (614, 89),
               },
              },
             ],
             position: (614, 85),
            },
           ],
          },
         ],
         position: (614, 62),
        },
        position: (614, 32),
       },
       position: (614, 26),
      },
      position: (614, 19),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "fixedWidthString",
        position: (628, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "width",
      },
      definition: Function {
       argument: Simple {
        identifier: "filler",
       },
       definition: Function {
        argument: Simple {
         identifier: "str",
        },
        definition: LetIn {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "strw",
              position: (630, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (630, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "stringLength",
                position: (630, 18),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "str",
              position: (630, 31),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "reqWidth",
              position: (631, 7),
             },
            ],
           },
           to: BinaryOperation {
            operator: Subtraction,
            operands: [
             Variable {
              identifier: "width",
              position: (631, 18),
             },
             Parentheses {
              expression: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (631, 27),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "stringLength",
                   position: (631, 31),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "filler",
                 position: (631, 44),
                },
               ],
              },
              position: (631, 26),
             },
            ],
            position: (631, 24),
           },
          },
         ],
         target: Assert {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (633, 14),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "assertMsg",
               position: (633, 18),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Parentheses {
             expression: BinaryOperation {
              operator: LessThanOrEqualTo,
              operands: [
               Variable {
                identifier: "strw",
                position: (633, 29),
               },
               Variable {
                identifier: "width",
                position: (633, 37),
               },
              ],
              position: (633, 34),
             },
             position: (633, 28),
            },
            String {
             parts: [
              Raw {
               content: "fixedWidthString: requested string length (",
               position: (634, 10),
              },
              Interpolation {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (635, 11),
                },
                arguments: [
                 Variable {
                  identifier: "width",
                  position: (635, 20),
                 },
                ],
               },
              },
              Raw {
               content: ") must not be shorter than actual length (",
               position: (635, 26),
              },
              Interpolation {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (636, 13),
                },
                arguments: [
                 Variable {
                  identifier: "strw",
                  position: (636, 22),
                 },
                ],
               },
              },
              Raw {
               content: ")",
               position: (636, 27),
              },
             ],
             position: (634, 9),
            },
           ],
          },
          target: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             Variable {
              identifier: "strw",
              position: (637, 10),
             },
             Variable {
              identifier: "width",
              position: (637, 18),
             },
            ],
            position: (637, 15),
           },
           then: Variable {
            identifier: "str",
            position: (637, 29),
           },
           else_: BinaryOperation {
            operator: Addition,
            operands: [
             Variable {
              identifier: "filler",
              position: (637, 38),
             },
             FunctionApplication {
              function: Variable {
               identifier: "fixedWidthString",
               position: (637, 47),
              },
              arguments: [
               Variable {
                identifier: "reqWidth",
                position: (637, 64),
               },
               Variable {
                identifier: "filler",
                position: (637, 73),
               },
               Variable {
                identifier: "str",
                position: (637, 80),
               },
              ],
             },
            ],
            position: (637, 45),
           },
           position: (637, 7),
          },
          position: (633, 7),
         },
         position: (629, 5),
        },
        position: (628, 37),
       },
       position: (628, 29),
      },
      position: (628, 22),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "fixedWidthNumber",
        position: (645, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "width",
      },
      definition: Function {
       argument: Simple {
        identifier: "n",
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "fixedWidthString",
         position: (645, 32),
        },
        arguments: [
         Variable {
          identifier: "width",
          position: (645, 49),
         },
         String {
          parts: [
           Raw {
            content: "0",
            position: (645, 56),
           },
          ],
          position: (645, 55),
         },
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (645, 60),
           },
           arguments: [
            Variable {
             identifier: "n",
             position: (645, 69),
            },
           ],
          },
          position: (645, 59),
         },
        ],
       },
       position: (645, 29),
      },
      position: (645, 22),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "floatToString",
        position: (657, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "float",
      },
      definition: LetIn {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "result",
            position: (658, 5),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "toString",
           position: (658, 14),
          },
          arguments: [
           Variable {
            identifier: "float",
            position: (658, 23),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "precise",
            position: (659, 5),
           },
          ],
         },
         to: BinaryOperation {
          operator: EqualTo,
          operands: [
           Variable {
            identifier: "float",
            position: (659, 15),
           },
           FunctionApplication {
            function: Variable {
             identifier: "fromJSON",
             position: (659, 24),
            },
            arguments: [
             Variable {
              identifier: "result",
              position: (659, 33),
             },
            ],
           },
          ],
          position: (659, 21),
         },
        },
       ],
       target: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "lib",
          position: (660, 6),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "warnIf",
            position: (660, 10),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Parentheses {
          expression: UnaryOperation {
           operator: Not,
           operand: Variable {
            identifier: "precise",
            position: (660, 19),
           },
           position: (660, 18),
          },
          position: (660, 17),
         },
         String {
          parts: [
           Raw {
            content: "Imprecise conversion from float to string ",
            position: (660, 29),
           },
           Interpolation {
            expression: Variable {
             identifier: "result",
             position: (660, 73),
            },
           },
          ],
          position: (660, 28),
         },
         Variable {
          identifier: "result",
          position: (661, 5),
         },
        ],
       },
       position: (657, 26),
      },
      position: (657, 19),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "isCoercibleToString",
        position: (664, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "x",
      },
      definition: BinaryOperation {
       operator: LogicalOr,
       operands: [
        BinaryOperation {
         operator: LogicalOr,
         operands: [
          BinaryOperation {
           operator: LogicalOr,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "elem",
              position: (665, 5),
             },
             arguments: [
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "typeOf",
                 position: (665, 11),
                },
                arguments: [
                 Variable {
                  identifier: "x",
                  position: (665, 18),
                 },
                ],
               },
               position: (665, 10),
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "path",
                   position: (665, 24),
                  },
                 ],
                 position: (665, 23),
                },
                String {
                 parts: [
                  Raw {
                   content: "string",
                   position: (665, 31),
                  },
                 ],
                 position: (665, 30),
                },
                String {
                 parts: [
                  Raw {
                   content: "null",
                   position: (665, 40),
                  },
                 ],
                 position: (665, 39),
                },
                String {
                 parts: [
                  Raw {
                   content: "int",
                   position: (665, 47),
                  },
                 ],
                 position: (665, 46),
                },
                String {
                 parts: [
                  Raw {
                   content: "float",
                   position: (665, 53),
                  },
                 ],
                 position: (665, 52),
                },
                String {
                 parts: [
                  Raw {
                   content: "bool",
                   position: (665, 61),
                  },
                 ],
                 position: (665, 60),
                },
               ],
               position: (665, 21),
              },
             ],
            },
            Parentheses {
             expression: BinaryOperation {
              operator: LogicalAnd,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "isList",
                 position: (666, 6),
                },
                arguments: [
                 Variable {
                  identifier: "x",
                  position: (666, 13),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "lib",
                  position: (666, 18),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "all",
                    position: (666, 22),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "isCoercibleToString",
                  position: (666, 26),
                 },
                 Variable {
                  identifier: "x",
                  position: (666, 46),
                 },
                ],
               },
              ],
              position: (666, 15),
             },
             position: (666, 5),
            },
           ],
           position: (665, 69),
          },
          HasProperty {
           expression: Variable {
            identifier: "x",
            position: (667, 5),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "outPath",
              position: (667, 9),
             },
            ],
           },
           position: (667, 7),
          },
         ],
         position: (666, 49),
        },
        HasProperty {
         expression: Variable {
          identifier: "x",
          position: (668, 5),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "__toString",
            position: (668, 9),
           },
          ],
         },
         position: (668, 7),
        },
       ],
       position: (667, 17),
      },
      position: (664, 25),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "isStorePath",
        position: (682, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "x",
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: LogicalAnd,
        operands: [
         UnaryOperation {
          operator: Not,
          operand: Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "isList",
             position: (683, 10),
            },
            arguments: [
             Variable {
              identifier: "x",
              position: (683, 17),
             },
            ],
           },
           position: (683, 9),
          },
          position: (683, 8),
         },
         FunctionApplication {
          function: Variable {
           identifier: "isCoercibleToString",
           position: (683, 23),
          },
          arguments: [
           Variable {
            identifier: "x",
            position: (683, 43),
           },
          ],
         },
        ],
        position: (683, 20),
       },
       then: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "str",
             position: (684, 11),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (684, 17),
           },
           arguments: [
            Variable {
             identifier: "x",
             position: (684, 26),
            },
           ],
          },
         },
        ],
        target: BinaryOperation {
         operator: LogicalAnd,
         operands: [
          BinaryOperation {
           operator: EqualTo,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "substring",
              position: (685, 7),
             },
             arguments: [
              Int {
               value: 0,
               position: (685, 17),
              },
              Int {
               value: 1,
               position: (685, 19),
              },
              Variable {
               identifier: "str",
               position: (685, 21),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "/",
               position: (685, 29),
              },
             ],
             position: (685, 28),
            },
           ],
           position: (685, 25),
          },
          BinaryOperation {
           operator: EqualTo,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "dirOf",
              position: (686, 10),
             },
             arguments: [
              Variable {
               identifier: "str",
               position: (686, 16),
              },
             ],
            },
            Variable {
             identifier: "storeDir",
             position: (686, 23),
            },
           ],
           position: (686, 20),
          },
         ],
         position: (686, 7),
        },
        position: (684, 7),
       },
       else_: Variable {
        identifier: "false",
        position: (688, 7),
       },
       position: (683, 5),
      },
      position: (682, 17),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "toInt",
        position: (703, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "str",
      },
      definition: LetIn {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "may_be_int",
            position: (704, 9),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "fromJSON",
           position: (704, 22),
          },
          arguments: [
           Variable {
            identifier: "str",
            position: (704, 31),
           },
          ],
         },
        },
       ],
       target: IfThenElse {
        predicate: FunctionApplication {
         function: Variable {
          identifier: "isInt",
          position: (705, 8),
         },
         arguments: [
          Variable {
           identifier: "may_be_int",
           position: (705, 14),
          },
         ],
        },
        then: Variable {
         identifier: "may_be_int",
         position: (706, 10),
        },
        else_: FunctionApplication {
         function: Variable {
          identifier: "throw",
          position: (707, 10),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "Could not convert ",
             position: (707, 17),
            },
            Interpolation {
             expression: Variable {
              identifier: "str",
              position: (707, 37),
             },
            },
            Raw {
             content: " to int.",
             position: (707, 41),
            },
           ],
           position: (707, 16),
          },
         ],
        },
        position: (705, 5),
       },
       position: (704, 5),
      },
      position: (703, 11),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "readPathsFromFile",
        position: (724, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (724, 23),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "warn",
          position: (724, 27),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "lib.readPathsFromFile is deprecated, use a list instead",
          position: (724, 33),
         },
        ],
        position: (724, 32),
       },
       Parentheses {
        expression: Function {
         argument: Simple {
          identifier: "rootPath",
         },
         definition: Function {
          argument: Simple {
           identifier: "file",
          },
          definition: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "lines",
                position: (727, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (727, 17),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "splitString",
                  position: (727, 21),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "\n",
                  position: (727, 34),
                 },
                ],
                position: (727, 33),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "readFile",
                  position: (727, 39),
                 },
                 arguments: [
                  Variable {
                   identifier: "file",
                   position: (727, 48),
                  },
                 ],
                },
                position: (727, 38),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "removeComments",
                position: (728, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (728, 26),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "filter",
                  position: (728, 30),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "line",
                 },
                 definition: BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     Variable {
                      identifier: "line",
                      position: (728, 44),
                     },
                     String {
                      parts: [],
                      position: (728, 52),
                     },
                    ],
                    position: (728, 49),
                   },
                   UnaryOperation {
                    operator: Not,
                    operand: Parentheses {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "lib",
                        position: (728, 60),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "hasPrefix",
                          position: (728, 64),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "#",
                          position: (728, 75),
                         },
                        ],
                        position: (728, 74),
                       },
                       Variable {
                        identifier: "line",
                        position: (728, 78),
                       },
                      ],
                     },
                     position: (728, 59),
                    },
                    position: (728, 58),
                   },
                  ],
                  position: (728, 55),
                 },
                 position: (728, 38),
                },
                position: (728, 37),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "relativePaths",
                position: (729, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "removeComments",
               position: (729, 25),
              },
              arguments: [
               Variable {
                identifier: "lines",
                position: (729, 40),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "absolutePaths",
                position: (730, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "map",
               position: (730, 25),
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "path",
                 },
                 definition: BinaryOperation {
                  operator: Addition,
                  operands: [
                   Variable {
                    identifier: "rootPath",
                    position: (730, 36),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "/",
                      position: (730, 48),
                     },
                     Interpolation {
                      expression: Variable {
                       identifier: "path",
                       position: (730, 51),
                      },
                     },
                    ],
                    position: (730, 47),
                   },
                  ],
                  position: (730, 45),
                 },
                 position: (730, 30),
                },
                position: (730, 29),
               },
               Variable {
                identifier: "relativePaths",
                position: (730, 59),
               },
              ],
             },
            },
           ],
           target: Variable {
            identifier: "absolutePaths",
            position: (732, 9),
           },
           position: (726, 7),
          },
          position: (725, 16),
         },
         position: (725, 6),
        },
        position: (725, 5),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "fileContents",
        position: (744, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "file",
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "removeSuffix",
        position: (744, 24),
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "\n",
           position: (744, 38),
          },
         ],
         position: (744, 37),
        },
        Parentheses {
         expression: FunctionApplication {
          function: Variable {
           identifier: "readFile",
           position: (744, 43),
          },
          arguments: [
           Variable {
            identifier: "file",
            position: (744, 52),
           },
          ],
         },
         position: (744, 42),
        },
       ],
      },
      position: (744, 18),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "sanitizeDerivationName",
        position: (759, 3),
       },
      ],
     },
     to: LetIn {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "okRegex",
           position: (760, 7),
          },
         ],
        },
        to: FunctionApplication {
         function: Variable {
          identifier: "match",
          position: (760, 17),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "[[:alnum:]+_?=-][[:alnum:]+._?=-]*",
             position: (760, 24),
            },
           ],
           position: (760, 23),
          },
         ],
        },
       },
      ],
      target: Function {
       argument: Simple {
        identifier: "string",
       },
       definition: IfThenElse {
        predicate: BinaryOperation {
         operator: LogicalAnd,
         operands: [
          BinaryOperation {
           operator: LessThanOrEqualTo,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "stringLength",
              position: (764, 6),
             },
             arguments: [
              Variable {
               identifier: "string",
               position: (764, 19),
              },
             ],
            },
            Int {
             value: 207,
             position: (764, 29),
            },
           ],
           position: (764, 26),
          },
          BinaryOperation {
           operator: NotEqualTo,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "okRegex",
              position: (764, 36),
             },
             arguments: [
              Variable {
               identifier: "string",
               position: (764, 44),
              },
             ],
            },
            Variable {
             identifier: "null",
             position: (764, 54),
            },
           ],
           position: (764, 51),
          },
         ],
         position: (764, 33),
        },
        then: FunctionApplication {
         function: Variable {
          identifier: "unsafeDiscardStringContext",
          position: (765, 8),
         },
         arguments: [
          Variable {
           identifier: "string",
           position: (765, 35),
          },
         ],
        },
        else_: FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (766, 8),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "pipe",
             position: (766, 12),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Variable {
           identifier: "string",
           position: (766, 17),
          },
          List {
           elements: [
            Variable {
             identifier: "unsafeDiscardStringContext",
             position: (769, 5),
            },
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "x",
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "elemAt",
                position: (771, 9),
               },
               arguments: [
                Parentheses {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "match",
                   position: (771, 17),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\\.*(.*)",
                      position: (771, 24),
                     },
                    ],
                    position: (771, 23),
                   },
                   Variable {
                    identifier: "x",
                    position: (771, 34),
                   },
                  ],
                 },
                 position: (771, 16),
                },
                Int {
                 value: 0,
                 position: (771, 37),
                },
               ],
              },
              position: (771, 6),
             },
             position: (771, 5),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "split",
               position: (775, 6),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "[^[:alnum:]+._?=-]+",
                  position: (775, 13),
                 },
                ],
                position: (775, 12),
               },
              ],
             },
             position: (775, 5),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "concatMapStrings",
               position: (777, 6),
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "s",
                 },
                 definition: IfThenElse {
                  predicate: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (777, 30),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "isList",
                       position: (777, 34),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "s",
                     position: (777, 41),
                    },
                   ],
                  },
                  then: String {
                   parts: [
                    Raw {
                     content: "-",
                     position: (777, 49),
                    },
                   ],
                   position: (777, 48),
                  },
                  else_: Variable {
                   identifier: "s",
                   position: (777, 57),
                  },
                  position: (777, 27),
                 },
                 position: (777, 24),
                },
                position: (777, 23),
               },
              ],
             },
             position: (777, 5),
            },
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "x",
              },
              definition: FunctionApplication {
               function: Variable {
                identifier: "substring",
                position: (779, 9),
               },
               arguments: [
                Parentheses {
                 expression: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (779, 20),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "max",
                      position: (779, 24),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Parentheses {
                    expression: BinaryOperation {
                     operator: Subtraction,
                     operands: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "stringLength",
                        position: (779, 29),
                       },
                       arguments: [
                        Variable {
                         identifier: "x",
                         position: (779, 42),
                        },
                       ],
                      },
                      Int {
                       value: 207,
                       position: (779, 46),
                      },
                     ],
                     position: (779, 44),
                    },
                    position: (779, 28),
                   },
                   Int {
                    value: 0,
                    position: (779, 51),
                   },
                  ],
                 },
                 position: (779, 19),
                },
                Parentheses {
                 expression: UnaryOperation {
                  operator: Negate,
                  operand: Int {
                   value: 1,
                   position: (779, 56),
                  },
                  position: (779, 55),
                 },
                 position: (779, 54),
                },
                Variable {
                 identifier: "x",
                 position: (779, 59),
                },
               ],
              },
              position: (779, 6),
             },
             position: (779, 5),
            },
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "x",
              },
              definition: IfThenElse {
               predicate: BinaryOperation {
                operator: EqualTo,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "stringLength",
                   position: (781, 12),
                  },
                  arguments: [
                   Variable {
                    identifier: "x",
                    position: (781, 25),
                   },
                  ],
                 },
                 Int {
                  value: 0,
                  position: (781, 30),
                 },
                ],
                position: (781, 27),
               },
               then: String {
                parts: [
                 Raw {
                  content: "unknown",
                  position: (781, 38),
                 },
                ],
                position: (781, 37),
               },
               else_: Variable {
                identifier: "x",
                position: (781, 52),
               },
               position: (781, 9),
              },
              position: (781, 6),
             },
             position: (781, 5),
            },
           ],
           position: (766, 24),
          },
         ],
        },
        position: (764, 3),
       },
       position: (762, 3),
      },
      position: (760, 3),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "levenshtein",
        position: (798, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "a",
      },
      definition: Function {
       argument: Simple {
        identifier: "b",
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "arr",
             position: (800, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (800, 11),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "genList",
               position: (800, 15),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "i",
              },
              definition: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (801, 7),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "genList",
                   position: (801, 11),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Parentheses {
                 expression: Function {
                  argument: Simple {
                   identifier: "j",
                  },
                  definition: FunctionApplication {
                   function: Variable {
                    identifier: "dist",
                    position: (802, 9),
                   },
                   arguments: [
                    Variable {
                     identifier: "i",
                     position: (802, 14),
                    },
                    Variable {
                     identifier: "j",
                     position: (802, 16),
                    },
                   ],
                  },
                  position: (801, 20),
                 },
                 position: (801, 19),
                },
                Parentheses {
                 expression: BinaryOperation {
                  operator: Addition,
                  operands: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "stringLength",
                     position: (803, 10),
                    },
                    arguments: [
                     Variable {
                      identifier: "b",
                      position: (803, 23),
                     },
                    ],
                   },
                   Int {
                    value: 1,
                    position: (803, 27),
                   },
                  ],
                  position: (803, 25),
                 },
                 position: (803, 9),
                },
               ],
              },
              position: (800, 24),
             },
             position: (800, 23),
            },
            Parentheses {
             expression: BinaryOperation {
              operator: Addition,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "stringLength",
                 position: (804, 8),
                },
                arguments: [
                 Variable {
                  identifier: "a",
                  position: (804, 21),
                 },
                ],
               },
               Int {
                value: 1,
                position: (804, 25),
               },
              ],
              position: (804, 23),
             },
             position: (804, 7),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "d",
             position: (805, 5),
            },
           ],
          },
          to: Function {
           argument: Simple {
            identifier: "x",
           },
           definition: Function {
            argument: Simple {
             identifier: "y",
            },
            definition: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "lib",
               position: (805, 15),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "elemAt",
                 position: (805, 19),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Parentheses {
               expression: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "lib",
                  position: (805, 27),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "elemAt",
                    position: (805, 31),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "arr",
                  position: (805, 38),
                 },
                 Variable {
                  identifier: "x",
                  position: (805, 42),
                 },
                ],
               },
               position: (805, 26),
              },
              Variable {
               identifier: "y",
               position: (805, 45),
              },
             ],
            },
            position: (805, 12),
           },
           position: (805, 9),
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "dist",
             position: (806, 5),
            },
           ],
          },
          to: Function {
           argument: Simple {
            identifier: "i",
           },
           definition: Function {
            argument: Simple {
             identifier: "j",
            },
            definition: LetIn {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "c",
                  position: (807, 11),
                 },
                ],
               },
               to: IfThenElse {
                predicate: BinaryOperation {
                 operator: EqualTo,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "substring",
                    position: (807, 18),
                   },
                   arguments: [
                    Parentheses {
                     expression: BinaryOperation {
                      operator: Subtraction,
                      operands: [
                       Variable {
                        identifier: "i",
                        position: (807, 29),
                       },
                       Int {
                        value: 1,
                        position: (807, 33),
                       },
                      ],
                      position: (807, 31),
                     },
                     position: (807, 28),
                    },
                    Int {
                     value: 1,
                     position: (807, 36),
                    },
                    Variable {
                     identifier: "a",
                     position: (807, 38),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "substring",
                    position: (807, 43),
                   },
                   arguments: [
                    Parentheses {
                     expression: BinaryOperation {
                      operator: Subtraction,
                      operands: [
                       Variable {
                        identifier: "j",
                        position: (807, 54),
                       },
                       Int {
                        value: 1,
                        position: (807, 58),
                       },
                      ],
                      position: (807, 56),
                     },
                     position: (807, 53),
                    },
                    Int {
                     value: 1,
                     position: (807, 61),
                    },
                    Variable {
                     identifier: "b",
                     position: (807, 63),
                    },
                   ],
                  },
                 ],
                 position: (807, 40),
                },
                then: Int {
                 value: 0,
                 position: (808, 14),
                },
                else_: Int {
                 value: 1,
                 position: (808, 21),
                },
                position: (807, 15),
               },
              },
             ],
             target: IfThenElse {
              predicate: BinaryOperation {
               operator: EqualTo,
               operands: [
                Variable {
                 identifier: "j",
                 position: (810, 10),
                },
                Int {
                 value: 0,
                 position: (810, 15),
                },
               ],
               position: (810, 12),
              },
              then: Variable {
               identifier: "i",
               position: (810, 22),
              },
              else_: IfThenElse {
               predicate: BinaryOperation {
                operator: EqualTo,
                operands: [
                 Variable {
                  identifier: "i",
                  position: (811, 15),
                 },
                 Int {
                  value: 0,
                  position: (811, 20),
                 },
                ],
                position: (811, 17),
               },
               then: Variable {
                identifier: "j",
                position: (811, 27),
               },
               else_: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "lib",
                  position: (812, 12),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "min",
                    position: (812, 16),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Parentheses {
                  expression: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (813, 11),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "min",
                       position: (813, 15),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Parentheses {
                     expression: BinaryOperation {
                      operator: Addition,
                      operands: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "d",
                         position: (813, 20),
                        },
                        arguments: [
                         Parentheses {
                          expression: BinaryOperation {
                           operator: Subtraction,
                           operands: [
                            Variable {
                             identifier: "i",
                             position: (813, 23),
                            },
                            Int {
                             value: 1,
                             position: (813, 27),
                            },
                           ],
                           position: (813, 25),
                          },
                          position: (813, 22),
                         },
                         Variable {
                          identifier: "j",
                          position: (813, 30),
                         },
                        ],
                       },
                       Int {
                        value: 1,
                        position: (813, 34),
                       },
                      ],
                      position: (813, 32),
                     },
                     position: (813, 19),
                    },
                    Parentheses {
                     expression: BinaryOperation {
                      operator: Addition,
                      operands: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "d",
                         position: (813, 38),
                        },
                        arguments: [
                         Variable {
                          identifier: "i",
                          position: (813, 40),
                         },
                         Parentheses {
                          expression: BinaryOperation {
                           operator: Subtraction,
                           operands: [
                            Variable {
                             identifier: "j",
                             position: (813, 43),
                            },
                            Int {
                             value: 1,
                             position: (813, 47),
                            },
                           ],
                           position: (813, 45),
                          },
                          position: (813, 42),
                         },
                        ],
                       },
                       Int {
                        value: 1,
                        position: (813, 52),
                       },
                      ],
                      position: (813, 50),
                     },
                     position: (813, 37),
                    },
                   ],
                  },
                  position: (813, 9),
                 },
                 Parentheses {
                  expression: BinaryOperation {
                   operator: Addition,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "d",
                      position: (814, 11),
                     },
                     arguments: [
                      Parentheses {
                       expression: BinaryOperation {
                        operator: Subtraction,
                        operands: [
                         Variable {
                          identifier: "i",
                          position: (814, 14),
                         },
                         Int {
                          value: 1,
                          position: (814, 18),
                         },
                        ],
                        position: (814, 16),
                       },
                       position: (814, 13),
                      },
                      Parentheses {
                       expression: BinaryOperation {
                        operator: Subtraction,
                        operands: [
                         Variable {
                          identifier: "j",
                          position: (814, 22),
                         },
                         Int {
                          value: 1,
                          position: (814, 26),
                         },
                        ],
                        position: (814, 24),
                       },
                       position: (814, 21),
                      },
                     ],
                    },
                    Variable {
                     identifier: "c",
                     position: (814, 31),
                    },
                   ],
                   position: (814, 29),
                  },
                  position: (814, 9),
                 },
                ],
               },
               position: (811, 12),
              },
              position: (810, 7),
             },
             position: (807, 7),
            },
            position: (806, 15),
           },
           position: (806, 12),
          },
         },
        ],
        target: FunctionApplication {
         function: Variable {
          identifier: "d",
          position: (815, 6),
         },
         arguments: [
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "stringLength",
             position: (815, 9),
            },
            arguments: [
             Variable {
              identifier: "a",
              position: (815, 22),
             },
            ],
           },
           position: (815, 8),
          },
          Parentheses {
           expression: FunctionApplication {
            function: Variable {
             identifier: "stringLength",
             position: (815, 26),
            },
            arguments: [
             Variable {
              identifier: "b",
              position: (815, 39),
             },
            ],
           },
           position: (815, 25),
          },
         ],
        },
        position: (798, 23),
       },
       position: (798, 20),
      },
      position: (798, 17),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "commonPrefixLength",
        position: (819, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "a",
      },
      definition: Function {
       argument: Simple {
        identifier: "b",
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "m",
             position: (821, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (821, 11),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "min",
               position: (821, 15),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "stringLength",
               position: (821, 20),
              },
              arguments: [
               Variable {
                identifier: "a",
                position: (821, 33),
               },
              ],
             },
             position: (821, 19),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "stringLength",
               position: (821, 37),
              },
              arguments: [
               Variable {
                identifier: "b",
                position: (821, 50),
               },
              ],
             },
             position: (821, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "go",
             position: (822, 7),
            },
           ],
          },
          to: Function {
           argument: Simple {
            identifier: "i",
           },
           definition: IfThenElse {
            predicate: BinaryOperation {
             operator: GreaterThanOrEqualTo,
             operands: [
              Variable {
               identifier: "i",
               position: (822, 18),
              },
              Variable {
               identifier: "m",
               position: (822, 23),
              },
             ],
             position: (822, 20),
            },
            then: Variable {
             identifier: "m",
             position: (822, 30),
            },
            else_: IfThenElse {
             predicate: BinaryOperation {
              operator: EqualTo,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "substring",
                 position: (822, 40),
                },
                arguments: [
                 Variable {
                  identifier: "i",
                  position: (822, 50),
                 },
                 Int {
                  value: 1,
                  position: (822, 52),
                 },
                 Variable {
                  identifier: "a",
                  position: (822, 54),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "substring",
                 position: (822, 59),
                },
                arguments: [
                 Variable {
                  identifier: "i",
                  position: (822, 69),
                 },
                 Int {
                  value: 1,
                  position: (822, 71),
                 },
                 Variable {
                  identifier: "b",
                  position: (822, 73),
                 },
                ],
               },
              ],
              position: (822, 56),
             },
             then: FunctionApplication {
              function: Variable {
               identifier: "go",
               position: (822, 80),
              },
              arguments: [
               Parentheses {
                expression: BinaryOperation {
                 operator: Addition,
                 operands: [
                  Variable {
                   identifier: "i",
                   position: (822, 84),
                  },
                  Int {
                   value: 1,
                   position: (822, 88),
                  },
                 ],
                 position: (822, 86),
                },
                position: (822, 83),
               },
              ],
             },
             else_: Variable {
              identifier: "i",
              position: (822, 96),
             },
             position: (822, 37),
            },
            position: (822, 15),
           },
           position: (822, 12),
          },
         },
        ],
        target: FunctionApplication {
         function: Variable {
          identifier: "go",
          position: (823, 8),
         },
         arguments: [
          Int {
           value: 0,
           position: (823, 11),
          },
         ],
        },
        position: (820, 5),
       },
       position: (819, 27),
      },
      position: (819, 24),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "commonSuffixLength",
        position: (827, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "a",
      },
      definition: Function {
       argument: Simple {
        identifier: "b",
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "m",
             position: (829, 7),
            },
           ],
          },
          to: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (829, 11),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "min",
               position: (829, 15),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "stringLength",
               position: (829, 20),
              },
              arguments: [
               Variable {
                identifier: "a",
                position: (829, 33),
               },
              ],
             },
             position: (829, 19),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "stringLength",
               position: (829, 37),
              },
              arguments: [
               Variable {
                identifier: "b",
                position: (829, 50),
               },
              ],
             },
             position: (829, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "go",
             position: (830, 7),
            },
           ],
          },
          to: Function {
           argument: Simple {
            identifier: "i",
           },
           definition: IfThenElse {
            predicate: BinaryOperation {
             operator: GreaterThanOrEqualTo,
             operands: [
              Variable {
               identifier: "i",
               position: (830, 18),
              },
              Variable {
               identifier: "m",
               position: (830, 23),
              },
             ],
             position: (830, 20),
            },
            then: Variable {
             identifier: "m",
             position: (830, 30),
            },
            else_: IfThenElse {
             predicate: BinaryOperation {
              operator: EqualTo,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "substring",
                 position: (830, 40),
                },
                arguments: [
                 Parentheses {
                  expression: BinaryOperation {
                   operator: Subtraction,
                   operands: [
                    BinaryOperation {
                     operator: Subtraction,
                     operands: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "stringLength",
                        position: (830, 51),
                       },
                       arguments: [
                        Variable {
                         identifier: "a",
                         position: (830, 64),
                        },
                       ],
                      },
                      Variable {
                       identifier: "i",
                       position: (830, 68),
                      },
                     ],
                     position: (830, 66),
                    },
                    Int {
                     value: 1,
                     position: (830, 72),
                    },
                   ],
                   position: (830, 70),
                  },
                  position: (830, 50),
                 },
                 Int {
                  value: 1,
                  position: (830, 75),
                 },
                 Variable {
                  identifier: "a",
                  position: (830, 77),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "substring",
                 position: (830, 82),
                },
                arguments: [
                 Parentheses {
                  expression: BinaryOperation {
                   operator: Subtraction,
                   operands: [
                    BinaryOperation {
                     operator: Subtraction,
                     operands: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "stringLength",
                        position: (830, 93),
                       },
                       arguments: [
                        Variable {
                         identifier: "b",
                         position: (830, 106),
                        },
                       ],
                      },
                      Variable {
                       identifier: "i",
                       position: (830, 110),
                      },
                     ],
                     position: (830, 108),
                    },
                    Int {
                     value: 1,
                     position: (830, 114),
                    },
                   ],
                   position: (830, 112),
                  },
                  position: (830, 92),
                 },
                 Int {
                  value: 1,
                  position: (830, 117),
                 },
                 Variable {
                  identifier: "b",
                  position: (830, 119),
                 },
                ],
               },
              ],
              position: (830, 79),
             },
             then: FunctionApplication {
              function: Variable {
               identifier: "go",
               position: (830, 126),
              },
              arguments: [
               Parentheses {
                expression: BinaryOperation {
                 operator: Addition,
                 operands: [
                  Variable {
                   identifier: "i",
                   position: (830, 130),
                  },
                  Int {
                   value: 1,
                   position: (830, 134),
                  },
                 ],
                 position: (830, 132),
                },
                position: (830, 129),
               },
              ],
             },
             else_: Variable {
              identifier: "i",
              position: (830, 142),
             },
             position: (830, 37),
            },
            position: (830, 15),
           },
           position: (830, 12),
          },
         },
        ],
        target: FunctionApplication {
         function: Variable {
          identifier: "go",
          position: (831, 8),
         },
         arguments: [
          Int {
           value: 0,
           position: (831, 11),
          },
         ],
        },
        position: (828, 5),
       },
       position: (827, 27),
      },
      position: (827, 24),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "levenshteinAtMost",
        position: (851, 3),
       },
      ],
     },
     to: LetIn {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "infixDifferAtMost1",
           position: (852, 5),
          },
         ],
        },
        to: Function {
         argument: Simple {
          identifier: "x",
         },
         definition: Function {
          argument: Simple {
           identifier: "y",
          },
          definition: BinaryOperation {
           operator: LogicalAnd,
           operands: [
            BinaryOperation {
             operator: LessThanOrEqualTo,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "stringLength",
                position: (852, 32),
               },
               arguments: [
                Variable {
                 identifier: "x",
                 position: (852, 45),
                },
               ],
              },
              Int {
               value: 1,
               position: (852, 50),
              },
             ],
             position: (852, 47),
            },
            BinaryOperation {
             operator: LessThanOrEqualTo,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "stringLength",
                position: (852, 55),
               },
               arguments: [
                Variable {
                 identifier: "y",
                 position: (852, 68),
                },
               ],
              },
              Int {
               value: 1,
               position: (852, 73),
              },
             ],
             position: (852, 70),
            },
           ],
           position: (852, 52),
          },
          position: (852, 29),
         },
         position: (852, 26),
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "infixDifferAtMost2",
           position: (860, 5),
          },
         ],
        },
        to: Function {
         argument: Simple {
          identifier: "x",
         },
         definition: Function {
          argument: Simple {
           identifier: "y",
          },
          definition: LetIn {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "xlen",
                position: (862, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "stringLength",
               position: (862, 16),
              },
              arguments: [
               Variable {
                identifier: "x",
                position: (862, 29),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "ylen",
                position: (863, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "stringLength",
               position: (863, 16),
              },
              arguments: [
               Variable {
                identifier: "y",
                position: (863, 29),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "diff",
                position: (866, 9),
               },
              ],
             },
             to: BinaryOperation {
              operator: Subtraction,
              operands: [
               Variable {
                identifier: "xlen",
                position: (866, 16),
               },
               Variable {
                identifier: "ylen",
                position: (866, 23),
               },
              ],
              position: (866, 21),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "xinfix",
                position: (869, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "substring",
               position: (869, 18),
              },
              arguments: [
               Int {
                value: 1,
                position: (869, 28),
               },
               Parentheses {
                expression: BinaryOperation {
                 operator: Subtraction,
                 operands: [
                  Variable {
                   identifier: "xlen",
                   position: (869, 31),
                  },
                  Int {
                   value: 2,
                   position: (869, 38),
                  },
                 ],
                 position: (869, 36),
                },
                position: (869, 30),
               },
               Variable {
                identifier: "x",
                position: (869, 41),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "yinfix",
                position: (870, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "substring",
               position: (870, 18),
              },
              arguments: [
               Int {
                value: 1,
                position: (870, 28),
               },
               Parentheses {
                expression: BinaryOperation {
                 operator: Subtraction,
                 operands: [
                  Variable {
                   identifier: "ylen",
                   position: (870, 31),
                  },
                  Int {
                   value: 2,
                   position: (870, 38),
                  },
                 ],
                 position: (870, 36),
                },
                position: (870, 30),
               },
               Variable {
                identifier: "y",
                position: (870, 41),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "xdelr",
                position: (873, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "substring",
               position: (873, 17),
              },
              arguments: [
               Int {
                value: 0,
                position: (873, 27),
               },
               Parentheses {
                expression: BinaryOperation {
                 operator: Subtraction,
                 operands: [
                  Variable {
                   identifier: "xlen",
                   position: (873, 30),
                  },
                  Int {
                   value: 1,
                   position: (873, 37),
                  },
                 ],
                 position: (873, 35),
                },
                position: (873, 29),
               },
               Variable {
                identifier: "x",
                position: (873, 40),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "xdell",
                position: (874, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "substring",
               position: (874, 17),
              },
              arguments: [
               Int {
                value: 1,
                position: (874, 27),
               },
               Parentheses {
                expression: BinaryOperation {
                 operator: Subtraction,
                 operands: [
                  Variable {
                   identifier: "xlen",
                   position: (874, 30),
                  },
                  Int {
                   value: 1,
                   position: (874, 37),
                  },
                 ],
                 position: (874, 35),
                },
                position: (874, 29),
               },
               Variable {
                identifier: "x",
                position: (874, 40),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "ydelr",
                position: (875, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "substring",
               position: (875, 17),
              },
              arguments: [
               Int {
                value: 0,
                position: (875, 27),
               },
               Parentheses {
                expression: BinaryOperation {
                 operator: Subtraction,
                 operands: [
                  Variable {
                   identifier: "ylen",
                   position: (875, 30),
                  },
                  Int {
                   value: 1,
                   position: (875, 37),
                  },
                 ],
                 position: (875, 35),
                },
                position: (875, 29),
               },
               Variable {
                identifier: "y",
                position: (875, 40),
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "ydell",
                position: (876, 9),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "substring",
               position: (876, 17),
              },
              arguments: [
               Int {
                value: 1,
                position: (876, 27),
               },
               Parentheses {
                expression: BinaryOperation {
                 operator: Subtraction,
                 operands: [
                  Variable {
                   identifier: "ylen",
                   position: (876, 30),
                  },
                  Int {
                   value: 1,
                   position: (876, 37),
                  },
                 ],
                 position: (876, 35),
                },
                position: (876, 29),
               },
               Variable {
                identifier: "y",
                position: (876, 40),
               },
              ],
             },
            },
           ],
           target: IfThenElse {
            predicate: BinaryOperation {
             operator: EqualTo,
             operands: [
              Variable {
               identifier: "diff",
               position: (881, 12),
              },
              Int {
               value: 2,
               position: (881, 20),
              },
             ],
             position: (881, 17),
            },
            then: BinaryOperation {
             operator: EqualTo,
             operands: [
              Variable {
               identifier: "xinfix",
               position: (881, 27),
              },
              Variable {
               identifier: "y",
               position: (881, 37),
              },
             ],
             position: (881, 34),
            },
            else_: IfThenElse {
             predicate: BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "diff",
                position: (885, 17),
               },
               Int {
                value: 1,
                position: (885, 25),
               },
              ],
              position: (885, 22),
             },
             then: BinaryOperation {
              operator: LogicalOr,
              operands: [
               BinaryOperation {
                operator: EqualTo,
                operands: [
                 Variable {
                  identifier: "xinfix",
                  position: (885, 32),
                 },
                 Variable {
                  identifier: "ydelr",
                  position: (885, 42),
                 },
                ],
                position: (885, 39),
               },
               BinaryOperation {
                operator: EqualTo,
                operands: [
                 Variable {
                  identifier: "xinfix",
                  position: (885, 51),
                 },
                 Variable {
                  identifier: "ydell",
                  position: (885, 61),
                 },
                ],
                position: (885, 58),
               },
              ],
              position: (885, 48),
             },
             else_: BinaryOperation {
              operator: LogicalOr,
              operands: [
               BinaryOperation {
                operator: LogicalOr,
                operands: [
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   Variable {
                    identifier: "xinfix",
                    position: (890, 14),
                   },
                   Variable {
                    identifier: "yinfix",
                    position: (890, 24),
                   },
                  ],
                  position: (890, 21),
                 },
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   Variable {
                    identifier: "xdelr",
                    position: (890, 34),
                   },
                   Variable {
                    identifier: "ydell",
                    position: (890, 43),
                   },
                  ],
                  position: (890, 40),
                 },
                ],
                position: (890, 31),
               },
               BinaryOperation {
                operator: EqualTo,
                operands: [
                 Variable {
                  identifier: "xdell",
                  position: (890, 52),
                 },
                 Variable {
                  identifier: "ydelr",
                  position: (890, 61),
                 },
                ],
                position: (890, 58),
               },
              ],
              position: (890, 49),
             },
             position: (885, 14),
            },
            position: (881, 9),
           },
           position: (861, 7),
          },
          position: (860, 29),
         },
         position: (860, 26),
        },
       },
      ],
      target: Function {
       argument: Simple {
        identifier: "k",
       },
       definition: IfThenElse {
        predicate: BinaryOperation {
         operator: LessThanOrEqualTo,
         operands: [
          Variable {
           identifier: "k",
           position: (892, 14),
          },
          Int {
           value: 0,
           position: (892, 19),
          },
         ],
         position: (892, 16),
        },
        then: Function {
         argument: Simple {
          identifier: "a",
         },
         definition: Function {
          argument: Simple {
           identifier: "b",
          },
          definition: BinaryOperation {
           operator: EqualTo,
           operands: [
            Variable {
             identifier: "a",
             position: (892, 32),
            },
            Variable {
             identifier: "b",
             position: (892, 37),
            },
           ],
           position: (892, 34),
          },
          position: (892, 29),
         },
         position: (892, 26),
        },
        else_: LetIn {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "f",
              position: (893, 11),
             },
            ],
           },
           to: Function {
            argument: Simple {
             identifier: "a",
            },
            definition: Function {
             argument: Simple {
              identifier: "b",
             },
             definition: LetIn {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "alen",
                   position: (895, 11),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "stringLength",
                  position: (895, 18),
                 },
                 arguments: [
                  Variable {
                   identifier: "a",
                   position: (895, 31),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "blen",
                   position: (896, 11),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "stringLength",
                  position: (896, 18),
                 },
                 arguments: [
                  Variable {
                   identifier: "b",
                   position: (896, 31),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "prelen",
                   position: (897, 11),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "commonPrefixLength",
                  position: (897, 20),
                 },
                 arguments: [
                  Variable {
                   identifier: "a",
                   position: (897, 39),
                  },
                  Variable {
                   identifier: "b",
                   position: (897, 41),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "suflen",
                   position: (898, 11),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "commonSuffixLength",
                  position: (898, 20),
                 },
                 arguments: [
                  Variable {
                   identifier: "a",
                   position: (898, 39),
                  },
                  Variable {
                   identifier: "b",
                   position: (898, 41),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "presuflen",
                   position: (899, 11),
                  },
                 ],
                },
                to: BinaryOperation {
                 operator: Addition,
                 operands: [
                  Variable {
                   identifier: "prelen",
                   position: (899, 23),
                  },
                  Variable {
                   identifier: "suflen",
                   position: (899, 32),
                  },
                 ],
                 position: (899, 30),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "ainfix",
                   position: (900, 11),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "substring",
                  position: (900, 20),
                 },
                 arguments: [
                  Variable {
                   identifier: "prelen",
                   position: (900, 30),
                  },
                  Parentheses {
                   expression: BinaryOperation {
                    operator: Subtraction,
                    operands: [
                     Variable {
                      identifier: "alen",
                      position: (900, 38),
                     },
                     Variable {
                      identifier: "presuflen",
                      position: (900, 45),
                     },
                    ],
                    position: (900, 43),
                   },
                   position: (900, 37),
                  },
                  Variable {
                   identifier: "a",
                   position: (900, 56),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "binfix",
                   position: (901, 11),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "substring",
                  position: (901, 20),
                 },
                 arguments: [
                  Variable {
                   identifier: "prelen",
                   position: (901, 30),
                  },
                  Parentheses {
                   expression: BinaryOperation {
                    operator: Subtraction,
                    operands: [
                     Variable {
                      identifier: "blen",
                      position: (901, 38),
                     },
                     Variable {
                      identifier: "presuflen",
                      position: (901, 45),
                     },
                    ],
                    position: (901, 43),
                   },
                   position: (901, 37),
                  },
                  Variable {
                   identifier: "b",
                   position: (901, 56),
                  },
                 ],
                },
               },
              ],
              target: IfThenElse {
               predicate: BinaryOperation {
                operator: LessThan,
                operands: [
                 Variable {
                  identifier: "alen",
                  position: (904, 12),
                 },
                 Variable {
                  identifier: "blen",
                  position: (904, 19),
                 },
                ],
                position: (904, 17),
               },
               then: FunctionApplication {
                function: Variable {
                 identifier: "f",
                 position: (904, 29),
                },
                arguments: [
                 Variable {
                  identifier: "b",
                  position: (904, 31),
                 },
                 Variable {
                  identifier: "a",
                  position: (904, 33),
                 },
                ],
               },
               else_: IfThenElse {
                predicate: BinaryOperation {
                 operator: GreaterThan,
                 operands: [
                  BinaryOperation {
                   operator: Subtraction,
                   operands: [
                    Variable {
                     identifier: "alen",
                     position: (906, 17),
                    },
                    Variable {
                     identifier: "blen",
                     position: (906, 24),
                    },
                   ],
                   position: (906, 22),
                  },
                  Variable {
                   identifier: "k",
                   position: (906, 31),
                  },
                 ],
                 position: (906, 29),
                },
                then: Variable {
                 identifier: "false",
                 position: (906, 38),
                },
                else_: IfThenElse {
                 predicate: BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   Variable {
                    identifier: "k",
                    position: (907, 17),
                   },
                   Int {
                    value: 1,
                    position: (907, 22),
                   },
                  ],
                  position: (907, 19),
                 },
                 then: FunctionApplication {
                  function: Variable {
                   identifier: "infixDifferAtMost1",
                   position: (907, 29),
                  },
                  arguments: [
                   Variable {
                    identifier: "ainfix",
                    position: (907, 48),
                   },
                   Variable {
                    identifier: "binfix",
                    position: (907, 55),
                   },
                  ],
                 },
                 else_: IfThenElse {
                  predicate: BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    Variable {
                     identifier: "k",
                     position: (908, 17),
                    },
                    Int {
                     value: 2,
                     position: (908, 22),
                    },
                   ],
                   position: (908, 19),
                  },
                  then: FunctionApplication {
                   function: Variable {
                    identifier: "infixDifferAtMost2",
                    position: (908, 29),
                   },
                   arguments: [
                    Variable {
                     identifier: "ainfix",
                     position: (908, 48),
                    },
                    Variable {
                     identifier: "binfix",
                     position: (908, 55),
                    },
                   ],
                  },
                  else_: BinaryOperation {
                   operator: LessThanOrEqualTo,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "levenshtein",
                      position: (909, 14),
                     },
                     arguments: [
                      Variable {
                       identifier: "ainfix",
                       position: (909, 26),
                      },
                      Variable {
                       identifier: "binfix",
                       position: (909, 33),
                      },
                     ],
                    },
                    Variable {
                     identifier: "k",
                     position: (909, 43),
                    },
                   ],
                   position: (909, 40),
                  },
                  position: (908, 14),
                 },
                 position: (907, 14),
                },
                position: (906, 14),
               },
               position: (904, 9),
              },
              position: (894, 9),
             },
             position: (893, 18),
            },
            position: (893, 15),
           },
          },
         ],
         target: Variable {
          identifier: "f",
          position: (910, 10),
         },
         position: (893, 7),
        },
        position: (892, 11),
       },
       position: (892, 8),
      },
      position: (851, 23),
     },
    },
   ],
   recursive: true,
   position: (9, 1),
  },
  position: (3, 1),
 },
 position: (2, 1),
}