---
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, 32),
        },
       ],
      },
      else_: String {
       parts: [
        Raw {
         content: "false",
         position: (114, 44),
        },
       ],
      },
      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: "codeName",
       position: (174, 3),
      },
     ],
    },
    String {
     parts: [
      Raw {
       content: "Quokka",
       position: (174, 15),
      },
     ],
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "versionSuffix",
       position: (177, 3),
      },
     ],
    },
    LetIn {
     bindings: [
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "suffixFile",
          position: (178, 9),
         },
        ],
       },
       Path {
        parts: [
         Raw {
          content: "../.version-suffix",
          position: (178, 22),
         },
        ],
       },
      ),
     ],
     target: IfThenElse {
      predicate: FunctionApplication {
       function: Variable {
        identifier: "pathExists",
        position: (179, 11),
       },
       arguments: [
        Variable {
         identifier: "suffixFile",
         position: (179, 22),
        },
       ],
      },
      then: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "lib",
         position: (180, 10),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "strings",
           position: (180, 14),
          },
          Raw {
           content: "fileContents",
           position: (180, 22),
          },
         ],
        },
        default: None,
       },
       arguments: [
        Variable {
         identifier: "suffixFile",
         position: (180, 35),
        },
       ],
      },
      else_: String {
       parts: [
        Raw {
         content: "pre-git",
         position: (181, 11),
        },
       ],
      },
      position: (179, 8),
     },
     position: (178, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "revisionWithDefault",
       position: (188, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "default",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "revisionFile",
           position: (192, 7),
          },
         ],
        },
        String {
         parts: [
          Expression {
           expression: FunctionApplication {
            function: Variable {
             identifier: "toString",
             position: (192, 25),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./..",
                position: (192, 34),
               },
              ],
             },
            ],
           },
          },
          Raw {
           content: "/.git-revision",
           position: (192, 39),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "gitRepo",
           position: (193, 7),
          },
         ],
        },
        String {
         parts: [
          Expression {
           expression: FunctionApplication {
            function: Variable {
             identifier: "toString",
             position: (193, 25),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./..",
                position: (193, 34),
               },
              ],
             },
            ],
           },
          },
          Raw {
           content: "/.git",
           position: (193, 39),
          },
         ],
        },
       ),
      ],
      target: IfThenElse {
       predicate: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "lib",
          position: (194, 11),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "pathIsGitRepo",
            position: (194, 15),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "gitRepo",
          position: (194, 29),
         },
        ],
       },
       then: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "lib",
          position: (195, 13),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "commitIdFromGitRepo",
            position: (195, 17),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "gitRepo",
          position: (195, 37),
         },
        ],
       },
       else_: IfThenElse {
        predicate: FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (196, 16),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "pathExists",
             position: (196, 20),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Variable {
           identifier: "revisionFile",
           position: (196, 31),
          },
         ],
        },
        then: FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (196, 49),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "fileContents",
             position: (196, 53),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Variable {
           identifier: "revisionFile",
           position: (196, 66),
          },
         ],
        },
        else_: Variable {
         identifier: "default",
         position: (197, 13),
        },
        position: (196, 13),
       },
       position: (194, 8),
      },
      position: (191, 5),
     },
     position: (190, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "nixpkgsVersion",
       position: (199, 3),
      },
     ],
    },
    FunctionApplication {
     function: PropertyAccess {
      expression: Variable {
       identifier: "builtins",
       position: (199, 20),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "trace",
         position: (199, 29),
        },
       ],
      },
      default: None,
     },
     arguments: [
      String {
       parts: [
        Raw {
         content: "`lib.nixpkgsVersion` is deprecated, use `lib.version` instead!",
         position: (199, 36),
        },
       ],
      },
      Variable {
       identifier: "version",
       position: (199, 100),
      },
     ],
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "inNixShell",
       position: (206, 3),
      },
     ],
    },
    BinaryOperation {
     operator: NotEqualTo,
     operands: [
      FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "builtins",
         position: (206, 16),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "getEnv",
           position: (206, 25),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "IN_NIX_SHELL",
           position: (206, 33),
          },
         ],
        },
       ],
      },
      String {
       parts: [],
      },
     ],
     position: (206, 47),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "min",
       position: (212, 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: (212, 18),
         },
         Variable {
          identifier: "y",
          position: (212, 22),
         },
        ],
        position: (212, 20),
       },
       then: Variable {
        identifier: "x",
        position: (212, 29),
       },
       else_: Variable {
        identifier: "y",
        position: (212, 36),
       },
       position: (212, 15),
      },
      position: (212, 12),
     },
     position: (212, 9),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "max",
       position: (215, 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: (215, 18),
         },
         Variable {
          identifier: "y",
          position: (215, 22),
         },
        ],
        position: (215, 20),
       },
       then: Variable {
        identifier: "x",
        position: (215, 29),
       },
       else_: Variable {
        identifier: "y",
        position: (215, 36),
       },
       position: (215, 15),
      },
      position: (215, 12),
     },
     position: (215, 9),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "mod",
       position: (225, 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: (225, 20),
        },
        BinaryOperation {
         operator: Multiplication,
         operands: [
          Variable {
           identifier: "int",
           position: (225, 28),
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (225, 35),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "div",
               position: (225, 44),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "base",
             position: (225, 48),
            },
            Variable {
             identifier: "int",
             position: (225, 53),
            },
           ],
          },
         ],
         position: (225, 32),
        },
       ],
       position: (225, 25),
      },
      position: (225, 15),
     },
     position: (225, 9),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "compare",
       position: (236, 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: (237, 8),
         },
         Variable {
          identifier: "b",
          position: (237, 12),
         },
        ],
        position: (237, 10),
       },
       then: UnaryOperation {
        operator: Negate,
        operand: Int {
         value: 1,
         position: (238, 11),
        },
        position: (238, 10),
       },
       else_: IfThenElse {
        predicate: BinaryOperation {
         operator: GreaterThan,
         operands: [
          Variable {
           identifier: "a",
           position: (239, 13),
          },
          Variable {
           identifier: "b",
           position: (239, 17),
          },
         ],
         position: (239, 15),
        },
        then: Int {
         value: 1,
         position: (240, 15),
        },
        else_: Int {
         value: 0,
         position: (241, 15),
        },
        position: (239, 10),
       },
       position: (237, 5),
      },
      position: (236, 16),
     },
     position: (236, 13),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "splitByAndCompare",
       position: (261, 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: (272, 8),
           },
           arguments: [
            Variable {
             identifier: "a",
             position: (272, 10),
            },
           ],
          },
          then: IfThenElse {
           predicate: FunctionApplication {
            function: Variable {
             identifier: "p",
             position: (273, 13),
            },
            arguments: [
             Variable {
              identifier: "b",
              position: (273, 15),
             },
            ],
           },
           then: FunctionApplication {
            function: Variable {
             identifier: "yes",
             position: (273, 22),
            },
            arguments: [
             Variable {
              identifier: "a",
              position: (273, 26),
             },
             Variable {
              identifier: "b",
              position: (273, 28),
             },
            ],
           },
           else_: UnaryOperation {
            operator: Negate,
            operand: Int {
             value: 1,
             position: (273, 36),
            },
            position: (273, 35),
           },
           position: (273, 10),
          },
          else_: IfThenElse {
           predicate: FunctionApplication {
            function: Variable {
             identifier: "p",
             position: (274, 13),
            },
            arguments: [
             Variable {
              identifier: "b",
              position: (274, 15),
             },
            ],
           },
           then: Int {
            value: 1,
            position: (274, 22),
           },
           else_: FunctionApplication {
            function: Variable {
             identifier: "no",
             position: (274, 29),
            },
            arguments: [
             Variable {
              identifier: "a",
              position: (274, 32),
             },
             Variable {
              identifier: "b",
              position: (274, 34),
             },
            ],
           },
           position: (274, 10),
          },
          position: (272, 5),
         },
         position: (271, 5),
        },
        position: (269, 5),
       },
       position: (267, 5),
      },
      position: (265, 5),
     },
     position: (263, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "importJSON",
       position: (281, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "path",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "builtins",
        position: (282, 5),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "fromJSON",
          position: (282, 14),
         },
        ],
       },
       default: None,
      },
      arguments: [
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (282, 24),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "readFile",
            position: (282, 33),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "path",
          position: (282, 42),
         },
        ],
       },
      ],
     },
     position: (281, 16),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "importTOML",
       position: (288, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "path",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "builtins",
        position: (289, 5),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "fromTOML",
          position: (289, 14),
         },
        ],
       },
       default: None,
      },
      arguments: [
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (289, 24),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "readFile",
            position: (289, 33),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "path",
          position: (289, 42),
         },
        ],
       },
      ],
     },
     position: (288, 16),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "warn",
       position: (316, 3),
      },
     ],
    },
    IfThenElse {
     predicate: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (317, 8),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "elem",
          position: (317, 12),
         },
        ],
       },
       default: None,
      },
      arguments: [
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (317, 18),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "getEnv",
            position: (317, 27),
           },
          ],
         },
         default: None,
        },
        arguments: [
         String {
          parts: [
           Raw {
            content: "NIX_ABORT_ON_WARN",
            position: (317, 35),
           },
          ],
         },
        ],
       },
       List {
        elements: [
         String {
          parts: [
           Raw {
            content: "1",
            position: (317, 57),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "true",
            position: (317, 61),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "yes",
            position: (317, 68),
           },
          ],
         },
        ],
        position: (317, 55),
       },
      ],
     },
     then: Function {
      argument: Some(
       "msg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "builtins",
         position: (318, 15),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "trace",
           position: (318, 24),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "\u{1b}[1;31mwarning: ",
           position: (318, 31),
          },
          Expression {
           expression: Variable {
            identifier: "msg",
            position: (318, 49),
           },
          },
          Raw {
           content: "\u{1b}[0m",
           position: (318, 53),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "abort",
          position: (318, 60),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "NIX_ABORT_ON_WARN=true; warnings are treated as unrecoverable errors.",
             position: (318, 67),
            },
           ],
          },
         ],
        },
       ],
      },
      position: (318, 10),
     },
     else_: Function {
      argument: Some(
       "msg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "builtins",
         position: (319, 15),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "trace",
           position: (319, 24),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "\u{1b}[1;31mwarning: ",
           position: (319, 31),
          },
          Expression {
           expression: Variable {
            identifier: "msg",
            position: (319, 49),
           },
          },
          Raw {
           content: "\u{1b}[0m",
           position: (319, 53),
          },
         ],
        },
       ],
      },
      position: (319, 10),
     },
     position: (317, 5),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "warnIf",
       position: (326, 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: (326, 26),
       },
       then: FunctionApplication {
        function: Variable {
         identifier: "warn",
         position: (326, 36),
        },
        arguments: [
         Variable {
          identifier: "msg",
          position: (326, 41),
         },
        ],
       },
       else_: Variable {
        identifier: "id",
        position: (326, 50),
       },
       position: (326, 23),
      },
      position: (326, 18),
     },
     position: (326, 12),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "throwIfNot",
       position: (348, 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: (348, 30),
       },
       then: Function {
        argument: Some(
         "x",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Variable {
         identifier: "x",
         position: (348, 43),
        },
        position: (348, 40),
       },
       else_: FunctionApplication {
        function: Variable {
         identifier: "throw",
         position: (348, 50),
        },
        arguments: [
         Variable {
          identifier: "msg",
          position: (348, 56),
         },
        ],
       },
       position: (348, 27),
      },
      position: (348, 22),
     },
     position: (348, 16),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "checkListOfEnum",
       position: (360, 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: (362, 7),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (362, 20),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "subtractLists",
               position: (362, 24),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "valid",
             position: (362, 38),
            },
            Variable {
             identifier: "given",
             position: (362, 44),
            },
           ],
          },
         ),
        ],
        target: FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (364, 7),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "throwIfNot",
             position: (364, 11),
            },
           ],
          },
          default: None,
         },
         arguments: [
          BinaryOperation {
           operator: EqualTo,
           operands: [
            Variable {
             identifier: "unexpected",
             position: (364, 23),
            },
            List {
             elements: [],
             position: (364, 37),
            },
           ],
           position: (364, 34),
          },
          String {
           parts: [
            Expression {
             expression: Variable {
              identifier: "msg",
              position: (365, 12),
             },
            },
            Raw {
             content: ": ",
             position: (365, 16),
            },
            Expression {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (365, 20),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "concatStringsSep",
                  position: (365, 29),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: ", ",
                  position: (365, 47),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (365, 52),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "map",
                    position: (365, 61),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "builtins",
                   position: (365, 65),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "toString",
                     position: (365, 74),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "unexpected",
                  position: (365, 83),
                 },
                ],
               },
              ],
             },
            },
            Raw {
             content: " unexpected; valid ones: ",
             position: (365, 95),
            },
            Expression {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (365, 122),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "concatStringsSep",
                  position: (365, 131),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: ", ",
                  position: (365, 149),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (365, 154),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "map",
                    position: (365, 163),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "builtins",
                   position: (365, 167),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "toString",
                     position: (365, 176),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "valid",
                  position: (365, 185),
                 },
                ],
               },
              ],
             },
            },
           ],
          },
         ],
        },
        position: (361, 5),
       },
       position: (360, 33),
      },
      position: (360, 26),
     },
     position: (360, 21),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "info",
       position: (367, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "msg",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "builtins",
        position: (367, 15),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "trace",
          position: (367, 24),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "INFO: ",
          position: (367, 31),
         },
         Expression {
          expression: Variable {
           identifier: "msg",
           position: (367, 39),
          },
         },
        ],
       },
      ],
     },
     position: (367, 10),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "showWarnings",
       position: (369, 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: (369, 33),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "foldr",
           position: (369, 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: (369, 50),
           },
           arguments: [
            Variable {
             identifier: "w",
             position: (369, 55),
            },
            Variable {
             identifier: "x",
             position: (369, 57),
            },
           ],
          },
          position: (369, 47),
         },
         position: (369, 44),
        },
        Variable {
         identifier: "res",
         position: (369, 60),
        },
        Variable {
         identifier: "warnings",
         position: (369, 64),
        },
       ],
      },
      position: (369, 28),
     },
     position: (369, 18),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "setFunctionArgs",
       position: (383, 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: (385, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "self",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Variable {
           identifier: "f",
           position: (385, 25),
          },
          position: (385, 19),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "__functionArgs",
            position: (386, 7),
           },
          ],
         },
         Variable {
          identifier: "args",
          position: (386, 24),
         },
        ),
       ],
       recursive: false,
       position: (384, 5),
      },
      position: (383, 24),
     },
     position: (383, 21),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "functionArgs",
       position: (395, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "f",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: IfThenElse {
      predicate: HasProperty {
       expression: Variable {
        identifier: "f",
        position: (396, 8),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "__functor",
          position: (396, 12),
         },
        ],
       },
       position: (396, 10),
      },
      then: PropertyAccess {
       expression: Variable {
        identifier: "f",
        position: (397, 10),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "__functionArgs",
          position: (397, 12),
         },
        ],
       },
       default: Some(
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (397, 31),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "functionArgs",
             position: (397, 35),
            },
           ],
          },
          default: None,
         },
         arguments: [
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "f",
             position: (397, 49),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "__functor",
               position: (397, 51),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "f",
             position: (397, 61),
            },
           ],
          },
         ],
        },
       ),
      },
      else_: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "builtins",
         position: (398, 10),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "functionArgs",
           position: (398, 19),
          },
         ],
        },
        default: None,
       },
       arguments: [
        Variable {
         identifier: "f",
         position: (398, 32),
        },
       ],
      },
      position: (396, 5),
     },
     position: (395, 18),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "isFunction",
       position: (403, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "f",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: BinaryOperation {
      operator: LogicalOr,
      operands: [
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (403, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "isFunction",
            position: (403, 28),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "f",
          position: (403, 39),
         },
        ],
       },
       BinaryOperation {
        operator: LogicalAnd,
        operands: [
         HasProperty {
          expression: Variable {
           identifier: "f",
           position: (404, 6),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "__functor",
             position: (404, 10),
            },
           ],
          },
          position: (404, 8),
         },
         FunctionApplication {
          function: Variable {
           identifier: "isFunction",
           position: (404, 23),
          },
          arguments: [
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "f",
              position: (404, 35),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "__functor",
                position: (404, 37),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "f",
              position: (404, 47),
             },
            ],
           },
          ],
         },
        ],
        position: (404, 20),
       },
      ],
      position: (403, 41),
     },
     position: (403, 16),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "toHexString",
       position: (415, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "i",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "toHexDigit",
           position: (417, 7),
          },
         ],
        },
        Function {
         argument: Some(
          "d",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: IfThenElse {
          predicate: BinaryOperation {
           operator: LessThan,
           operands: [
            Variable {
             identifier: "d",
             position: (418, 12),
            },
            Int {
             value: 10,
             position: (418, 16),
            },
           ],
           position: (418, 14),
          },
          then: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (419, 14),
           },
           arguments: [
            Variable {
             identifier: "d",
             position: (419, 23),
            },
           ],
          },
          else_: PropertyAccess {
           expression: Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Expression {
                 expression: String {
                  parts: [
                   Raw {
                    content: "10",
                    position: (422, 14),
                   },
                  ],
                 },
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "A",
                 position: (422, 21),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Expression {
                 expression: String {
                  parts: [
                   Raw {
                    content: "11",
                    position: (423, 14),
                   },
                  ],
                 },
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "B",
                 position: (423, 21),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Expression {
                 expression: String {
                  parts: [
                   Raw {
                    content: "12",
                    position: (424, 14),
                   },
                  ],
                 },
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "C",
                 position: (424, 21),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Expression {
                 expression: String {
                  parts: [
                   Raw {
                    content: "13",
                    position: (425, 14),
                   },
                  ],
                 },
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "D",
                 position: (425, 21),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Expression {
                 expression: String {
                  parts: [
                   Raw {
                    content: "14",
                    position: (426, 14),
                   },
                  ],
                 },
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "E",
                 position: (426, 21),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Expression {
                 expression: String {
                  parts: [
                   Raw {
                    content: "15",
                    position: (427, 14),
                   },
                  ],
                 },
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "F",
                 position: (427, 21),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (421, 11),
           },
           attribute_path: AttributePath {
            attributes: [
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "toString",
                position: (428, 15),
               },
               arguments: [
                Variable {
                 identifier: "d",
                 position: (428, 24),
                },
               ],
              },
             },
            ],
           },
           default: None,
          },
          position: (418, 9),
         },
         position: (417, 20),
        },
       ),
      ],
      target: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "lib",
         position: (430, 7),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "concatMapStrings",
           position: (430, 11),
          },
         ],
        },
        default: None,
       },
       arguments: [
        Variable {
         identifier: "toHexDigit",
         position: (430, 28),
        },
        FunctionApplication {
         function: Variable {
          identifier: "toBaseDigits",
          position: (430, 40),
         },
         arguments: [
          Int {
           value: 16,
           position: (430, 53),
          },
          Variable {
           identifier: "i",
           position: (430, 56),
          },
         ],
        },
       ],
      },
      position: (416, 5),
     },
     position: (415, 17),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "toBaseDigits",
       position: (441, 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: (443, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "i",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: LessThan,
            operands: [
             Variable {
              identifier: "i",
              position: (444, 12),
             },
             Variable {
              identifier: "base",
              position: (444, 16),
             },
            ],
            position: (444, 14),
           },
           then: List {
            elements: [
             Variable {
              identifier: "i",
              position: (445, 15),
             },
            ],
            position: (445, 14),
           },
           else_: LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "r",
                 position: (448, 13),
                },
               ],
              },
              BinaryOperation {
               operator: Subtraction,
               operands: [
                Variable {
                 identifier: "i",
                 position: (448, 17),
                },
                BinaryOperation {
                 operator: Multiplication,
                 operands: [
                  BinaryOperation {
                   operator: Division,
                   operands: [
                    Variable {
                     identifier: "i",
                     position: (448, 23),
                    },
                    Variable {
                     identifier: "base",
                     position: (448, 27),
                    },
                   ],
                   position: (448, 25),
                  },
                  Variable {
                   identifier: "base",
                   position: (448, 35),
                  },
                 ],
                 position: (448, 33),
                },
               ],
               position: (448, 19),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "q",
                 position: (449, 13),
                },
               ],
              },
              BinaryOperation {
               operator: Division,
               operands: [
                BinaryOperation {
                 operator: Subtraction,
                 operands: [
                  Variable {
                   identifier: "i",
                   position: (449, 18),
                  },
                  Variable {
                   identifier: "r",
                   position: (449, 22),
                  },
                 ],
                 position: (449, 20),
                },
                Variable {
                 identifier: "base",
                 position: (449, 27),
                },
               ],
               position: (449, 25),
              },
             ),
            ],
            target: BinaryOperation {
             operator: Concatenation,
             operands: [
              List {
               elements: [
                Variable {
                 identifier: "r",
                 position: (451, 14),
                },
               ],
               position: (451, 13),
              },
              FunctionApplication {
               function: Variable {
                identifier: "go",
                position: (451, 20),
               },
               arguments: [
                Variable {
                 identifier: "q",
                 position: (451, 23),
                },
               ],
              },
             ],
             position: (451, 17),
            },
            position: (447, 11),
           },
           position: (444, 9),
          },
          position: (443, 12),
         },
        ),
       ],
       target: Assert {
        expression: BinaryOperation {
         operator: GreaterThanOrEqualTo,
         operands: [
          Variable {
           identifier: "base",
           position: (453, 15),
          },
          Int {
           value: 2,
           position: (453, 23),
          },
         ],
         position: (453, 20),
        },
        target: Assert {
         expression: BinaryOperation {
          operator: GreaterThanOrEqualTo,
          operands: [
           Variable {
            identifier: "i",
            position: (454, 15),
           },
           Int {
            value: 0,
            position: (454, 20),
           },
          ],
          position: (454, 17),
         },
         target: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (455, 7),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "reverseList",
              position: (455, 11),
             },
            ],
           },
           default: None,
          },
          arguments: [
           FunctionApplication {
            function: Variable {
             identifier: "go",
             position: (455, 24),
            },
            arguments: [
             Variable {
              identifier: "i",
              position: (455, 27),
             },
            ],
           },
          ],
         },
         position: (454, 7),
        },
        position: (453, 7),
       },
       position: (442, 5),
      },
      position: (441, 24),
     },
     position: (441, 18),
    },
   ),
  ],
  recursive: true,
  position: (3, 1),
 },
 position: (1, 1),
}