---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
  ],
  ellipsis: false,
 },
 definition: Map {
  bindings: [
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "id",
       position: (12, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "x",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Variable {
      identifier: "x",
      position: (14, 8),
     },
     position: (14, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "const",
       position: (26, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "x",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "y",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Variable {
       identifier: "x",
       position: (30, 8),
      },
      position: (30, 5),
     },
     position: (28, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "pipe",
       position: (61, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "val",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "functions",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "reverseApply",
            position: (62, 9),
           },
          ],
         },
         Function {
          argument: Some(
           "x",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "f",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "f",
             position: (62, 30),
            },
            arguments: [
             Variable {
              identifier: "x",
              position: (62, 32),
             },
            ],
           },
           position: (62, 27),
          },
          position: (62, 24),
         },
        ),
       ],
       target: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (63, 8),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "foldl'",
            position: (63, 17),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "reverseApply",
          position: (63, 24),
         },
         Variable {
          identifier: "val",
          position: (63, 37),
         },
         Variable {
          identifier: "functions",
          position: (63, 41),
         },
        ],
       },
       position: (62, 5),
      },
      position: (61, 15),
     },
     position: (61, 10),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "concat",
       position: (80, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "x",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "y",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: Concatenation,
       operands: [
        Variable {
         identifier: "x",
         position: (80, 18),
        },
        Variable {
         identifier: "y",
         position: (80, 23),
        },
       ],
       position: (80, 20),
      },
      position: (80, 15),
     },
     position: (80, 12),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "or",
       position: (83, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "x",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "y",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: LogicalOr,
       operands: [
        Variable {
         identifier: "x",
         position: (83, 14),
        },
        Variable {
         identifier: "y",
         position: (83, 19),
        },
       ],
       position: (83, 16),
      },
      position: (83, 11),
     },
     position: (83, 8),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "and",
       position: (86, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "x",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "y",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: LogicalAnd,
       operands: [
        Variable {
         identifier: "x",
         position: (86, 15),
        },
        Variable {
         identifier: "y",
         position: (86, 20),
        },
       ],
       position: (86, 17),
      },
      position: (86, 12),
     },
     position: (86, 9),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "bitAnd",
       position: (89, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "builtins",
      position: (89, 12),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "bitAnd",
        position: (89, 21),
       },
      ],
     },
     default: Some(
      FunctionApplication {
       function: Variable {
        identifier: "import",
        position: (90, 9),
       },
       arguments: [
        Path {
         parts: [
          Raw {
           content: "./zip-int-bits.nix",
          },
         ],
         position: (90, 16),
        },
        Function {
         argument: Some(
          "a",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "b",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: LogicalAnd,
            operands: [
             BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "a",
                position: (91, 19),
               },
               Int {
                value: 1,
                position: (91, 22),
               },
              ],
              position: (91, 20),
             },
             BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "b",
                position: (91, 27),
               },
               Int {
                value: 1,
                position: (91, 30),
               },
              ],
              position: (91, 28),
             },
            ],
            position: (91, 24),
           },
           then: Int {
            value: 1,
            position: (91, 37),
           },
           else_: Int {
            value: 0,
            position: (91, 44),
           },
           position: (91, 16),
          },
          position: (91, 13),
         },
         position: (91, 10),
        },
       ],
      },
     ),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "bitOr",
       position: (94, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "builtins",
      position: (94, 11),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "bitOr",
        position: (94, 20),
       },
      ],
     },
     default: Some(
      FunctionApplication {
       function: Variable {
        identifier: "import",
        position: (95, 9),
       },
       arguments: [
        Path {
         parts: [
          Raw {
           content: "./zip-int-bits.nix",
          },
         ],
         position: (95, 16),
        },
        Function {
         argument: Some(
          "a",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "b",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: LogicalOr,
            operands: [
             BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "a",
                position: (96, 19),
               },
               Int {
                value: 1,
                position: (96, 22),
               },
              ],
              position: (96, 20),
             },
             BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "b",
                position: (96, 27),
               },
               Int {
                value: 1,
                position: (96, 30),
               },
              ],
              position: (96, 28),
             },
            ],
            position: (96, 24),
           },
           then: Int {
            value: 1,
            position: (96, 37),
           },
           else_: Int {
            value: 0,
            position: (96, 44),
           },
           position: (96, 16),
          },
          position: (96, 13),
         },
         position: (96, 10),
        },
       ],
      },
     ),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "bitXor",
       position: (99, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "builtins",
      position: (99, 12),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "bitXor",
        position: (99, 21),
       },
      ],
     },
     default: Some(
      FunctionApplication {
       function: Variable {
        identifier: "import",
        position: (100, 9),
       },
       arguments: [
        Path {
         parts: [
          Raw {
           content: "./zip-int-bits.nix",
          },
         ],
         position: (100, 16),
        },
        Function {
         argument: Some(
          "a",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "b",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: NotEqualTo,
            operands: [
             Variable {
              identifier: "a",
              position: (101, 19),
             },
             Variable {
              identifier: "b",
              position: (101, 22),
             },
            ],
            position: (101, 20),
           },
           then: Int {
            value: 1,
            position: (101, 29),
           },
           else_: Int {
            value: 0,
            position: (101, 36),
           },
           position: (101, 16),
          },
          position: (101, 13),
         },
         position: (101, 10),
        },
       ],
      },
     ),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "bitNot",
       position: (104, 3),
      },
     ],
    },
    FunctionApplication {
     function: PropertyAccess {
      expression: Variable {
       identifier: "builtins",
       position: (104, 12),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "sub",
         position: (104, 21),
        },
       ],
      },
      default: None,
     },
     arguments: [
      UnaryOperation {
       operator: Negate,
       operand: Int {
        value: 1,
        position: (104, 27),
       },
       position: (104, 26),
      },
     ],
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "boolToString",
       position: (114, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "b",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: IfThenElse {
      predicate: Variable {
       identifier: "b",
       position: (114, 24),
      },
      then: String {
       parts: [
        Raw {
         content: "true",
        },
       ],
       position: (114, 31),
      },
      else_: String {
       parts: [
        Raw {
         content: "false",
        },
       ],
       position: (114, 43),
      },
      position: (114, 21),
     },
     position: (114, 18),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "mergeAttrs",
       position: (124, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "x",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "y",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: Update,
       operands: [
        Variable {
         identifier: "x",
         position: (128, 8),
        },
        Variable {
         identifier: "y",
         position: (128, 13),
        },
       ],
       position: (128, 10),
      },
      position: (128, 5),
     },
     position: (126, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "flip",
       position: (138, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "f",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "a",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "b",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "f",
         position: (138, 19),
        },
        arguments: [
         Variable {
          identifier: "b",
          position: (138, 21),
         },
         Variable {
          identifier: "a",
          position: (138, 23),
         },
        ],
       },
       position: (138, 16),
      },
      position: (138, 13),
     },
     position: (138, 10),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "mapNullable",
       position: (148, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "f",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "a",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: EqualTo,
        operands: [
         Variable {
          identifier: "a",
          position: (152, 11),
         },
         Variable {
          identifier: "null",
          position: (152, 16),
         },
        ],
        position: (152, 13),
       },
       then: Variable {
        identifier: "a",
        position: (152, 26),
       },
       else_: FunctionApplication {
        function: Variable {
         identifier: "f",
         position: (152, 33),
        },
        arguments: [
         Variable {
          identifier: "a",
          position: (152, 35),
         },
        ],
       },
       position: (152, 8),
      },
      position: (152, 5),
     },
     position: (150, 5),
    },
   ),
   Inherit(
    Some(
     Variable {
      identifier: "builtins",
      position: (155, 12),
     },
    ),
    [
     Raw {
      content: "pathExists",
      position: (156, 5),
     },
     Raw {
      content: "readFile",
      position: (156, 16),
     },
     Raw {
      content: "isBool",
      position: (156, 25),
     },
     Raw {
      content: "isInt",
      position: (157, 5),
     },
     Raw {
      content: "isFloat",
      position: (157, 11),
     },
     Raw {
      content: "add",
      position: (157, 19),
     },
     Raw {
      content: "sub",
      position: (157, 23),
     },
     Raw {
      content: "lessThan",
      position: (157, 27),
     },
     Raw {
      content: "seq",
      position: (158, 5),
     },
     Raw {
      content: "deepSeq",
      position: (158, 9),
     },
     Raw {
      content: "genericClosure",
      position: (158, 17),
     },
    ],
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "version",
       position: (164, 3),
      },
     ],
    },
    BinaryOperation {
     operator: Addition,
     operands: [
      Variable {
       identifier: "release",
       position: (164, 13),
      },
      Variable {
       identifier: "versionSuffix",
       position: (164, 23),
      },
     ],
     position: (164, 21),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "release",
       position: (167, 3),
      },
     ],
    },
    FunctionApplication {
     function: PropertyAccess {
      expression: Variable {
       identifier: "lib",
       position: (167, 13),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "strings",
         position: (167, 17),
        },
        Raw {
         content: "fileContents",
         position: (167, 25),
        },
       ],
      },
      default: None,
     },
     arguments: [
      Path {
       parts: [
        Raw {
         content: "../.version",
        },
       ],
       position: (167, 38),
      },
     ],
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "oldestSupportedRelease",
       position: (180, 3),
      },
     ],
    },
    Int {
     value: 2111,
     position: (182, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "isInOldestRelease",
       position: (186, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "release",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: BinaryOperation {
      operator: LessThanOrEqualTo,
      operands: [
       Variable {
        identifier: "release",
        position: (191, 7),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "lib",
         position: (191, 18),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "trivial",
           position: (191, 22),
          },
          Raw {
           content: "oldestSupportedRelease",
           position: (191, 30),
          },
         ],
        },
        default: None,
       },
      ],
      position: (191, 15),
     },
     position: (190, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "codeName",
       position: (198, 3),
      },
     ],
    },
    String {
     parts: [
      Raw {
       content: "Quokka",
      },
     ],
     position: (198, 14),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "versionSuffix",
       position: (201, 3),
      },
     ],
    },
    LetIn {
     bindings: [
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "suffixFile",
          position: (202, 9),
         },
        ],
       },
       Path {
        parts: [
         Raw {
          content: "../.version-suffix",
         },
        ],
        position: (202, 22),
       },
      ),
     ],
     target: IfThenElse {
      predicate: FunctionApplication {
       function: Variable {
        identifier: "pathExists",
        position: (203, 11),
       },
       arguments: [
        Variable {
         identifier: "suffixFile",
         position: (203, 22),
        },
       ],
      },
      then: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "lib",
         position: (204, 10),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "strings",
           position: (204, 14),
          },
          Raw {
           content: "fileContents",
           position: (204, 22),
          },
         ],
        },
        default: None,
       },
       arguments: [
        Variable {
         identifier: "suffixFile",
         position: (204, 35),
        },
       ],
      },
      else_: String {
       parts: [
        Raw {
         content: "pre-git",
        },
       ],
       position: (205, 10),
      },
      position: (203, 8),
     },
     position: (202, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "revisionWithDefault",
       position: (212, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "default",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "revisionFile",
           position: (216, 7),
          },
         ],
        },
        String {
         parts: [
          Expression {
           expression: FunctionApplication {
            function: Variable {
             identifier: "toString",
             position: (216, 25),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./..",
               },
              ],
              position: (216, 34),
             },
            ],
           },
          },
          Raw {
           content: "/.git-revision",
          },
         ],
         position: (216, 22),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "gitRepo",
           position: (217, 7),
          },
         ],
        },
        String {
         parts: [
          Expression {
           expression: FunctionApplication {
            function: Variable {
             identifier: "toString",
             position: (217, 25),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./..",
               },
              ],
              position: (217, 34),
             },
            ],
           },
          },
          Raw {
           content: "/.git",
          },
         ],
         position: (217, 22),
        },
       ),
      ],
      target: IfThenElse {
       predicate: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "lib",
          position: (218, 11),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "pathIsGitRepo",
            position: (218, 15),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "gitRepo",
          position: (218, 29),
         },
        ],
       },
       then: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "lib",
          position: (219, 13),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "commitIdFromGitRepo",
            position: (219, 17),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "gitRepo",
          position: (219, 37),
         },
        ],
       },
       else_: IfThenElse {
        predicate: FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (220, 16),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "pathExists",
             position: (220, 20),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Variable {
           identifier: "revisionFile",
           position: (220, 31),
          },
         ],
        },
        then: FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (220, 49),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "fileContents",
             position: (220, 53),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Variable {
           identifier: "revisionFile",
           position: (220, 66),
          },
         ],
        },
        else_: Variable {
         identifier: "default",
         position: (221, 13),
        },
        position: (220, 13),
       },
       position: (218, 8),
      },
      position: (215, 5),
     },
     position: (214, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "nixpkgsVersion",
       position: (223, 3),
      },
     ],
    },
    FunctionApplication {
     function: PropertyAccess {
      expression: Variable {
       identifier: "builtins",
       position: (223, 20),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "trace",
         position: (223, 29),
        },
       ],
      },
      default: None,
     },
     arguments: [
      String {
       parts: [
        Raw {
         content: "`lib.nixpkgsVersion` is deprecated, use `lib.version` instead!",
        },
       ],
       position: (223, 35),
      },
      Variable {
       identifier: "version",
       position: (223, 100),
      },
     ],
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "inNixShell",
       position: (230, 3),
      },
     ],
    },
    BinaryOperation {
     operator: NotEqualTo,
     operands: [
      FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "builtins",
         position: (230, 16),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "getEnv",
           position: (230, 25),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "IN_NIX_SHELL",
          },
         ],
         position: (230, 32),
        },
       ],
      },
      String {
       parts: [],
       position: (230, 50),
      },
     ],
     position: (230, 47),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "min",
       position: (236, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "x",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "y",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: LessThan,
        operands: [
         Variable {
          identifier: "x",
          position: (236, 18),
         },
         Variable {
          identifier: "y",
          position: (236, 22),
         },
        ],
        position: (236, 20),
       },
       then: Variable {
        identifier: "x",
        position: (236, 29),
       },
       else_: Variable {
        identifier: "y",
        position: (236, 36),
       },
       position: (236, 15),
      },
      position: (236, 12),
     },
     position: (236, 9),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "max",
       position: (239, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "x",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "y",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: GreaterThan,
        operands: [
         Variable {
          identifier: "x",
          position: (239, 18),
         },
         Variable {
          identifier: "y",
          position: (239, 22),
         },
        ],
        position: (239, 20),
       },
       then: Variable {
        identifier: "x",
        position: (239, 29),
       },
       else_: Variable {
        identifier: "y",
        position: (239, 36),
       },
       position: (239, 15),
      },
      position: (239, 12),
     },
     position: (239, 9),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "mod",
       position: (249, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "base",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "int",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: Subtraction,
       operands: [
        Variable {
         identifier: "base",
         position: (249, 20),
        },
        BinaryOperation {
         operator: Multiplication,
         operands: [
          Variable {
           identifier: "int",
           position: (249, 28),
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (249, 35),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "div",
               position: (249, 44),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "base",
             position: (249, 48),
            },
            Variable {
             identifier: "int",
             position: (249, 53),
            },
           ],
          },
         ],
         position: (249, 32),
        },
       ],
       position: (249, 25),
      },
      position: (249, 15),
     },
     position: (249, 9),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "compare",
       position: (260, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "a",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "b",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: LessThan,
        operands: [
         Variable {
          identifier: "a",
          position: (261, 8),
         },
         Variable {
          identifier: "b",
          position: (261, 12),
         },
        ],
        position: (261, 10),
       },
       then: UnaryOperation {
        operator: Negate,
        operand: Int {
         value: 1,
         position: (262, 11),
        },
        position: (262, 10),
       },
       else_: IfThenElse {
        predicate: BinaryOperation {
         operator: GreaterThan,
         operands: [
          Variable {
           identifier: "a",
           position: (263, 13),
          },
          Variable {
           identifier: "b",
           position: (263, 17),
          },
         ],
         position: (263, 15),
        },
        then: Int {
         value: 1,
         position: (264, 15),
        },
        else_: Int {
         value: 0,
         position: (265, 15),
        },
        position: (263, 10),
       },
       position: (261, 5),
      },
      position: (260, 16),
     },
     position: (260, 13),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "splitByAndCompare",
       position: (285, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "p",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "yes",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "no",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "a",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Function {
         argument: Some(
          "b",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: IfThenElse {
          predicate: FunctionApplication {
           function: Variable {
            identifier: "p",
            position: (296, 8),
           },
           arguments: [
            Variable {
             identifier: "a",
             position: (296, 10),
            },
           ],
          },
          then: IfThenElse {
           predicate: FunctionApplication {
            function: Variable {
             identifier: "p",
             position: (297, 13),
            },
            arguments: [
             Variable {
              identifier: "b",
              position: (297, 15),
             },
            ],
           },
           then: FunctionApplication {
            function: Variable {
             identifier: "yes",
             position: (297, 22),
            },
            arguments: [
             Variable {
              identifier: "a",
              position: (297, 26),
             },
             Variable {
              identifier: "b",
              position: (297, 28),
             },
            ],
           },
           else_: UnaryOperation {
            operator: Negate,
            operand: Int {
             value: 1,
             position: (297, 36),
            },
            position: (297, 35),
           },
           position: (297, 10),
          },
          else_: IfThenElse {
           predicate: FunctionApplication {
            function: Variable {
             identifier: "p",
             position: (298, 13),
            },
            arguments: [
             Variable {
              identifier: "b",
              position: (298, 15),
             },
            ],
           },
           then: Int {
            value: 1,
            position: (298, 22),
           },
           else_: FunctionApplication {
            function: Variable {
             identifier: "no",
             position: (298, 29),
            },
            arguments: [
             Variable {
              identifier: "a",
              position: (298, 32),
             },
             Variable {
              identifier: "b",
              position: (298, 34),
             },
            ],
           },
           position: (298, 10),
          },
          position: (296, 5),
         },
         position: (295, 5),
        },
        position: (293, 5),
       },
       position: (291, 5),
      },
      position: (289, 5),
     },
     position: (287, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "importJSON",
       position: (305, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "path",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "builtins",
        position: (306, 5),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "fromJSON",
          position: (306, 14),
         },
        ],
       },
       default: None,
      },
      arguments: [
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (306, 24),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "readFile",
            position: (306, 33),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "path",
          position: (306, 42),
         },
        ],
       },
      ],
     },
     position: (305, 16),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "importTOML",
       position: (312, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "path",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "builtins",
        position: (313, 5),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "fromTOML",
          position: (313, 14),
         },
        ],
       },
       default: None,
      },
      arguments: [
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (313, 24),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "readFile",
            position: (313, 33),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "path",
          position: (313, 42),
         },
        ],
       },
      ],
     },
     position: (312, 16),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "warn",
       position: (340, 3),
      },
     ],
    },
    IfThenElse {
     predicate: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (341, 8),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "elem",
          position: (341, 12),
         },
        ],
       },
       default: None,
      },
      arguments: [
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (341, 18),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "getEnv",
            position: (341, 27),
           },
          ],
         },
         default: None,
        },
        arguments: [
         String {
          parts: [
           Raw {
            content: "NIX_ABORT_ON_WARN",
           },
          ],
          position: (341, 34),
         },
        ],
       },
       List {
        elements: [
         String {
          parts: [
           Raw {
            content: "1",
           },
          ],
          position: (341, 56),
         },
         String {
          parts: [
           Raw {
            content: "true",
           },
          ],
          position: (341, 60),
         },
         String {
          parts: [
           Raw {
            content: "yes",
           },
          ],
          position: (341, 67),
         },
        ],
        position: (341, 55),
       },
      ],
     },
     then: Function {
      argument: Some(
       "msg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "builtins",
         position: (342, 15),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "trace",
           position: (342, 24),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "\u{1b}[1;31mwarning: ",
          },
          Expression {
           expression: Variable {
            identifier: "msg",
            position: (342, 49),
           },
          },
          Raw {
           content: "\u{1b}[0m",
          },
         ],
         position: (342, 30),
        },
        FunctionApplication {
         function: Variable {
          identifier: "abort",
          position: (342, 60),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "NIX_ABORT_ON_WARN=true; warnings are treated as unrecoverable errors.",
            },
           ],
           position: (342, 66),
          },
         ],
        },
       ],
      },
      position: (342, 10),
     },
     else_: Function {
      argument: Some(
       "msg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "builtins",
         position: (343, 15),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "trace",
           position: (343, 24),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "\u{1b}[1;31mwarning: ",
          },
          Expression {
           expression: Variable {
            identifier: "msg",
            position: (343, 49),
           },
          },
          Raw {
           content: "\u{1b}[0m",
          },
         ],
         position: (343, 30),
        },
       ],
      },
      position: (343, 10),
     },
     position: (341, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "warnIf",
       position: (350, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "cond",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "msg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: Variable {
        identifier: "cond",
        position: (350, 26),
       },
       then: FunctionApplication {
        function: Variable {
         identifier: "warn",
         position: (350, 36),
        },
        arguments: [
         Variable {
          identifier: "msg",
          position: (350, 41),
         },
        ],
       },
       else_: Function {
        argument: Some(
         "x",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Variable {
         identifier: "x",
         position: (350, 53),
        },
        position: (350, 50),
       },
       position: (350, 23),
      },
      position: (350, 18),
     },
     position: (350, 12),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "warnIfNot",
       position: (357, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "cond",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "msg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: Variable {
        identifier: "cond",
        position: (357, 29),
       },
       then: Function {
        argument: Some(
         "x",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Variable {
         identifier: "x",
         position: (357, 42),
        },
        position: (357, 39),
       },
       else_: FunctionApplication {
        function: Variable {
         identifier: "warn",
         position: (357, 49),
        },
        arguments: [
         Variable {
          identifier: "msg",
          position: (357, 54),
         },
        ],
       },
       position: (357, 26),
      },
      position: (357, 21),
     },
     position: (357, 15),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "throwIfNot",
       position: (379, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "cond",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "msg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: Variable {
        identifier: "cond",
        position: (379, 30),
       },
       then: Function {
        argument: Some(
         "x",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Variable {
         identifier: "x",
         position: (379, 43),
        },
        position: (379, 40),
       },
       else_: FunctionApplication {
        function: Variable {
         identifier: "throw",
         position: (379, 50),
        },
        arguments: [
         Variable {
          identifier: "msg",
          position: (379, 56),
         },
        ],
       },
       position: (379, 27),
      },
      position: (379, 22),
     },
     position: (379, 16),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "throwIf",
       position: (386, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "cond",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "msg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: Variable {
        identifier: "cond",
        position: (386, 27),
       },
       then: FunctionApplication {
        function: Variable {
         identifier: "throw",
         position: (386, 37),
        },
        arguments: [
         Variable {
          identifier: "msg",
          position: (386, 43),
         },
        ],
       },
       else_: Function {
        argument: Some(
         "x",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Variable {
         identifier: "x",
         position: (386, 55),
        },
        position: (386, 52),
       },
       position: (386, 24),
      },
      position: (386, 19),
     },
     position: (386, 13),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "checkListOfEnum",
       position: (398, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "msg",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "valid",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "given",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "unexpected",
             position: (400, 7),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (400, 20),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "subtractLists",
               position: (400, 24),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "valid",
             position: (400, 38),
            },
            Variable {
             identifier: "given",
             position: (400, 44),
            },
           ],
          },
         ),
        ],
        target: FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (402, 7),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "throwIfNot",
             position: (402, 11),
            },
           ],
          },
          default: None,
         },
         arguments: [
          BinaryOperation {
           operator: EqualTo,
           operands: [
            Variable {
             identifier: "unexpected",
             position: (402, 23),
            },
            List {
             elements: [],
             position: (402, 37),
            },
           ],
           position: (402, 34),
          },
          String {
           parts: [
            Expression {
             expression: Variable {
              identifier: "msg",
              position: (403, 12),
             },
            },
            Raw {
             content: ": ",
            },
            Expression {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (403, 20),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "concatStringsSep",
                  position: (403, 29),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: ", ",
                 },
                ],
                position: (403, 46),
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (403, 52),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "map",
                    position: (403, 61),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "builtins",
                   position: (403, 65),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "toString",
                     position: (403, 74),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "unexpected",
                  position: (403, 83),
                 },
                ],
               },
              ],
             },
            },
            Raw {
             content: " unexpected; valid ones: ",
            },
            Expression {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (403, 122),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "concatStringsSep",
                  position: (403, 131),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: ", ",
                 },
                ],
                position: (403, 148),
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (403, 154),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "map",
                    position: (403, 163),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "builtins",
                   position: (403, 167),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "toString",
                     position: (403, 176),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "valid",
                  position: (403, 185),
                 },
                ],
               },
              ],
             },
            },
           ],
           position: (403, 9),
          },
         ],
        },
        position: (399, 5),
       },
       position: (398, 33),
      },
      position: (398, 26),
     },
     position: (398, 21),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "info",
       position: (405, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "msg",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "builtins",
        position: (405, 15),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "trace",
          position: (405, 24),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "INFO: ",
         },
         Expression {
          expression: Variable {
           identifier: "msg",
           position: (405, 39),
          },
         },
        ],
        position: (405, 30),
       },
      ],
     },
     position: (405, 10),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "showWarnings",
       position: (407, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "warnings",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "res",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "lib",
         position: (407, 33),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "foldr",
           position: (407, 37),
          },
         ],
        },
        default: None,
       },
       arguments: [
        Function {
         argument: Some(
          "w",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "x",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: FunctionApplication {
           function: Variable {
            identifier: "warn",
            position: (407, 50),
           },
           arguments: [
            Variable {
             identifier: "w",
             position: (407, 55),
            },
            Variable {
             identifier: "x",
             position: (407, 57),
            },
           ],
          },
          position: (407, 47),
         },
         position: (407, 44),
        },
        Variable {
         identifier: "res",
         position: (407, 60),
        },
        Variable {
         identifier: "warnings",
         position: (407, 64),
        },
       ],
      },
      position: (407, 28),
     },
     position: (407, 18),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "setFunctionArgs",
       position: (421, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "f",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "args",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "__functor",
            position: (423, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "self",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Variable {
           identifier: "f",
           position: (423, 25),
          },
          position: (423, 19),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "__functionArgs",
            position: (424, 7),
           },
          ],
         },
         Variable {
          identifier: "args",
          position: (424, 24),
         },
        ),
       ],
       recursive: false,
       position: (422, 5),
      },
      position: (421, 24),
     },
     position: (421, 21),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "functionArgs",
       position: (433, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "f",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: IfThenElse {
      predicate: HasProperty {
       expression: Variable {
        identifier: "f",
        position: (434, 8),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "__functor",
          position: (434, 12),
         },
        ],
       },
       position: (434, 10),
      },
      then: PropertyAccess {
       expression: Variable {
        identifier: "f",
        position: (435, 10),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "__functionArgs",
          position: (435, 12),
         },
        ],
       },
       default: Some(
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (435, 31),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "functionArgs",
             position: (435, 35),
            },
           ],
          },
          default: None,
         },
         arguments: [
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "f",
             position: (435, 49),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "__functor",
               position: (435, 51),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "f",
             position: (435, 61),
            },
           ],
          },
         ],
        },
       ),
      },
      else_: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "builtins",
         position: (436, 10),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "functionArgs",
           position: (436, 19),
          },
         ],
        },
        default: None,
       },
       arguments: [
        Variable {
         identifier: "f",
         position: (436, 32),
        },
       ],
      },
      position: (434, 5),
     },
     position: (433, 18),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "isFunction",
       position: (441, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "f",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: BinaryOperation {
      operator: LogicalOr,
      operands: [
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (441, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "isFunction",
            position: (441, 28),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "f",
          position: (441, 39),
         },
        ],
       },
       BinaryOperation {
        operator: LogicalAnd,
        operands: [
         HasProperty {
          expression: Variable {
           identifier: "f",
           position: (442, 6),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "__functor",
             position: (442, 10),
            },
           ],
          },
          position: (442, 8),
         },
         FunctionApplication {
          function: Variable {
           identifier: "isFunction",
           position: (442, 23),
          },
          arguments: [
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "f",
              position: (442, 35),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "__functor",
                position: (442, 37),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "f",
              position: (442, 47),
             },
            ],
           },
          ],
         },
        ],
        position: (442, 20),
       },
      ],
      position: (441, 41),
     },
     position: (441, 16),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "toFunction",
       position: (456, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "v",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: IfThenElse {
      predicate: FunctionApplication {
       function: Variable {
        identifier: "isFunction",
        position: (459, 8),
       },
       arguments: [
        Variable {
         identifier: "v",
         position: (459, 19),
        },
       ],
      },
      then: Variable {
       identifier: "v",
       position: (460, 10),
      },
      else_: Function {
       argument: Some(
        "k",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Variable {
        identifier: "v",
        position: (461, 13),
       },
       position: (461, 10),
      },
      position: (459, 5),
     },
     position: (458, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "toHexString",
       position: (472, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "i",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "toHexDigit",
           position: (474, 7),
          },
         ],
        },
        Function {
         argument: Some(
          "d",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: IfThenElse {
          predicate: BinaryOperation {
           operator: LessThan,
           operands: [
            Variable {
             identifier: "d",
             position: (475, 12),
            },
            Int {
             value: 10,
             position: (475, 16),
            },
           ],
           position: (475, 14),
          },
          then: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (476, 14),
           },
           arguments: [
            Variable {
             identifier: "d",
             position: (476, 23),
            },
           ],
          },
          else_: PropertyAccess {
           expression: Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Expression {
                 expression: __StringParts(
                  [
                   Raw {
                    content: "10",
                   },
                  ],
                 ),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "A",
                },
               ],
               position: (479, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Expression {
                 expression: __StringParts(
                  [
                   Raw {
                    content: "11",
                   },
                  ],
                 ),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "B",
                },
               ],
               position: (480, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Expression {
                 expression: __StringParts(
                  [
                   Raw {
                    content: "12",
                   },
                  ],
                 ),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "C",
                },
               ],
               position: (481, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Expression {
                 expression: __StringParts(
                  [
                   Raw {
                    content: "13",
                   },
                  ],
                 ),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "D",
                },
               ],
               position: (482, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Expression {
                 expression: __StringParts(
                  [
                   Raw {
                    content: "14",
                   },
                  ],
                 ),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "E",
                },
               ],
               position: (483, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Expression {
                 expression: __StringParts(
                  [
                   Raw {
                    content: "15",
                   },
                  ],
                 ),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "F",
                },
               ],
               position: (484, 20),
              },
             ),
            ],
            recursive: false,
            position: (478, 11),
           },
           attribute_path: AttributePath {
            attributes: [
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "toString",
                position: (485, 15),
               },
               arguments: [
                Variable {
                 identifier: "d",
                 position: (485, 24),
                },
               ],
              },
             },
            ],
           },
           default: None,
          },
          position: (475, 9),
         },
         position: (474, 20),
        },
       ),
      ],
      target: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "lib",
         position: (487, 7),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "concatMapStrings",
           position: (487, 11),
          },
         ],
        },
        default: None,
       },
       arguments: [
        Variable {
         identifier: "toHexDigit",
         position: (487, 28),
        },
        FunctionApplication {
         function: Variable {
          identifier: "toBaseDigits",
          position: (487, 40),
         },
         arguments: [
          Int {
           value: 16,
           position: (487, 53),
          },
          Variable {
           identifier: "i",
           position: (487, 56),
          },
         ],
        },
       ],
      },
      position: (473, 5),
     },
     position: (472, 17),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "toBaseDigits",
       position: (498, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "base",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Function {
      argument: Some(
       "i",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "go",
            position: (500, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "i",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: LessThan,
            operands: [
             Variable {
              identifier: "i",
              position: (501, 12),
             },
             Variable {
              identifier: "base",
              position: (501, 16),
             },
            ],
            position: (501, 14),
           },
           then: List {
            elements: [
             Variable {
              identifier: "i",
              position: (502, 15),
             },
            ],
            position: (502, 14),
           },
           else_: LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "r",
                 position: (505, 13),
                },
               ],
              },
              BinaryOperation {
               operator: Subtraction,
               operands: [
                Variable {
                 identifier: "i",
                 position: (505, 17),
                },
                BinaryOperation {
                 operator: Multiplication,
                 operands: [
                  BinaryOperation {
                   operator: Division,
                   operands: [
                    Variable {
                     identifier: "i",
                     position: (505, 23),
                    },
                    Variable {
                     identifier: "base",
                     position: (505, 27),
                    },
                   ],
                   position: (505, 25),
                  },
                  Variable {
                   identifier: "base",
                   position: (505, 35),
                  },
                 ],
                 position: (505, 33),
                },
               ],
               position: (505, 19),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "q",
                 position: (506, 13),
                },
               ],
              },
              BinaryOperation {
               operator: Division,
               operands: [
                BinaryOperation {
                 operator: Subtraction,
                 operands: [
                  Variable {
                   identifier: "i",
                   position: (506, 18),
                  },
                  Variable {
                   identifier: "r",
                   position: (506, 22),
                  },
                 ],
                 position: (506, 20),
                },
                Variable {
                 identifier: "base",
                 position: (506, 27),
                },
               ],
               position: (506, 25),
              },
             ),
            ],
            target: BinaryOperation {
             operator: Concatenation,
             operands: [
              List {
               elements: [
                Variable {
                 identifier: "r",
                 position: (508, 14),
                },
               ],
               position: (508, 13),
              },
              FunctionApplication {
               function: Variable {
                identifier: "go",
                position: (508, 20),
               },
               arguments: [
                Variable {
                 identifier: "q",
                 position: (508, 23),
                },
               ],
              },
             ],
             position: (508, 17),
            },
            position: (504, 11),
           },
           position: (501, 9),
          },
          position: (500, 12),
         },
        ),
       ],
       target: Assert {
        expression: BinaryOperation {
         operator: GreaterThanOrEqualTo,
         operands: [
          Variable {
           identifier: "base",
           position: (510, 15),
          },
          Int {
           value: 2,
           position: (510, 23),
          },
         ],
         position: (510, 20),
        },
        target: Assert {
         expression: BinaryOperation {
          operator: GreaterThanOrEqualTo,
          operands: [
           Variable {
            identifier: "i",
            position: (511, 15),
           },
           Int {
            value: 0,
            position: (511, 20),
           },
          ],
          position: (511, 17),
         },
         target: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (512, 7),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "reverseList",
              position: (512, 11),
             },
            ],
           },
           default: None,
          },
          arguments: [
           FunctionApplication {
            function: Variable {
             identifier: "go",
             position: (512, 24),
            },
            arguments: [
             Variable {
              identifier: "i",
              position: (512, 27),
             },
            ],
           },
          ],
         },
         position: (511, 7),
        },
        position: (510, 7),
       },
       position: (499, 5),
      },
      position: (498, 24),
     },
     position: (498, 18),
    },
   ),
  ],
  recursive: true,
  position: (3, 1),
 },
 position: (1, 1),
}