---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
  ],
  ellipsis: false,
 },
 definition: With {
  expression: FunctionApplication {
   function: Variable {
    identifier: "import",
    position: (2, 6),
   },
   arguments: [
    Path {
     parts: [
      Raw {
       content: "./parse.nix",
       position: (2, 13),
      },
     ],
    },
    Map {
     bindings: [
      Inherit(
       None,
       [
        Raw {
         content: "lib",
         position: (2, 35),
        },
       ],
      ),
     ],
     recursive: false,
     position: (2, 25),
    },
   ],
  },
  target: With {
   expression: PropertyAccess {
    expression: Variable {
     identifier: "lib",
     position: (3, 6),
    },
    attribute_path: AttributePath {
     attributes: [
      Raw {
       content: "attrsets",
       position: (3, 10),
      },
     ],
    },
    default: None,
   },
   target: With {
    expression: PropertyAccess {
     expression: Variable {
      identifier: "lib",
      position: (4, 6),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "lists",
        position: (4, 10),
       },
      ],
     },
     default: None,
    },
    target: LetIn {
     bindings: [
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "abis_",
          position: (6, 5),
         },
        ],
       },
       Variable {
        identifier: "abis",
        position: (6, 13),
       },
      ),
     ],
     target: LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "abis",
           position: (7, 5),
          },
         ],
        },
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (7, 12),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "mapAttrs",
             position: (7, 16),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Function {
           argument: Some(
            "_",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "abi",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (7, 34),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "removeAttrs",
                 position: (7, 43),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Variable {
               identifier: "abi",
               position: (7, 55),
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "assertions",
                   position: (7, 62),
                  },
                 ],
                },
               ],
               position: (7, 59),
              },
             ],
            },
            position: (7, 29),
           },
           position: (7, 26),
          },
          Variable {
           identifier: "abis_",
           position: (7, 77),
          },
         ],
        },
       ),
      ],
      target: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "patterns",
            position: (10, 3),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isi686",
               position: (11, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (11, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cpuTypes",
                 position: (11, 30),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "i686",
                   position: (11, 39),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (11, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isx86_32",
               position: (12, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (12, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (12, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "x86",
                     position: (12, 42),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "bits",
                     position: (12, 48),
                    },
                   ],
                  },
                  Int {
                   value: 32,
                   position: (12, 55),
                  },
                 ),
                ],
                recursive: false,
                position: (12, 30),
               },
              ),
             ],
             recursive: false,
             position: (12, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isx86_64",
               position: (13, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (13, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (13, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "x86",
                     position: (13, 42),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "bits",
                     position: (13, 48),
                    },
                   ],
                  },
                  Int {
                   value: 64,
                   position: (13, 55),
                  },
                 ),
                ],
                recursive: false,
                position: (13, 30),
               },
              ),
             ],
             recursive: false,
             position: (13, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isPowerPC",
               position: (14, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (14, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cpuTypes",
                 position: (14, 30),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "powerpc",
                   position: (14, 39),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (14, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isPower",
               position: (15, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (15, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (15, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "power",
                     position: (15, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (15, 30),
               },
              ),
             ],
             recursive: false,
             position: (15, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isx86",
               position: (16, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (16, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (16, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "x86",
                     position: (16, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (16, 30),
               },
              ),
             ],
             recursive: false,
             position: (16, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isAarch32",
               position: (17, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (17, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (17, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "arm",
                     position: (17, 42),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "bits",
                     position: (17, 48),
                    },
                   ],
                  },
                  Int {
                   value: 32,
                   position: (17, 55),
                  },
                 ),
                ],
                recursive: false,
                position: (17, 30),
               },
              ),
             ],
             recursive: false,
             position: (17, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isAarch64",
               position: (18, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (18, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (18, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "arm",
                     position: (18, 42),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "bits",
                     position: (18, 48),
                    },
                   ],
                  },
                  Int {
                   value: 64,
                   position: (18, 55),
                  },
                 ),
                ],
                recursive: false,
                position: (18, 30),
               },
              ),
             ],
             recursive: false,
             position: (18, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isMips",
               position: (19, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (19, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (19, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "mips",
                     position: (19, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (19, 30),
               },
              ),
             ],
             recursive: false,
             position: (19, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isMmix",
               position: (20, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (20, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (20, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "mmix",
                     position: (20, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (20, 30),
               },
              ),
             ],
             recursive: false,
             position: (20, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isRiscV",
               position: (21, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (21, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (21, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "riscv",
                     position: (21, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (21, 30),
               },
              ),
             ],
             recursive: false,
             position: (21, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isSparc",
               position: (22, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (22, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (22, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "sparc",
                     position: (22, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (22, 30),
               },
              ),
             ],
             recursive: false,
             position: (22, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isWasm",
               position: (23, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (23, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (23, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "wasm",
                     position: (23, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (23, 30),
               },
              ),
             ],
             recursive: false,
             position: (23, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isMsp430",
               position: (24, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (24, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (24, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "msp430",
                     position: (24, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (24, 30),
               },
              ),
             ],
             recursive: false,
             position: (24, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isVc4",
               position: (25, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (25, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (25, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "vc4",
                     position: (25, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (25, 30),
               },
              ),
             ],
             recursive: false,
             position: (25, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isAvr",
               position: (26, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (26, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (26, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "avr",
                     position: (26, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (26, 30),
               },
              ),
             ],
             recursive: false,
             position: (26, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isAlpha",
               position: (27, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (27, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (27, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "alpha",
                     position: (27, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (27, 30),
               },
              ),
             ],
             recursive: false,
             position: (27, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isOr1k",
               position: (28, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (28, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (28, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "or1k",
                     position: (28, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (28, 30),
               },
              ),
             ],
             recursive: false,
             position: (28, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isM68k",
               position: (29, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (29, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (29, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "m68k",
                     position: (29, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (29, 30),
               },
              ),
             ],
             recursive: false,
             position: (29, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isS390",
               position: (30, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (30, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "family",
                     position: (30, 32),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "s390",
                     position: (30, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (30, 30),
               },
              ),
             ],
             recursive: false,
             position: (30, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isJavaScript",
               position: (31, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (31, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cpuTypes",
                 position: (31, 30),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "js",
                   position: (31, 39),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (31, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "is32bit",
               position: (33, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (33, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "bits",
                     position: (33, 32),
                    },
                   ],
                  },
                  Int {
                   value: 32,
                   position: (33, 39),
                  },
                 ),
                ],
                recursive: false,
                position: (33, 30),
               },
              ),
             ],
             recursive: false,
             position: (33, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "is64bit",
               position: (34, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (34, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "bits",
                     position: (34, 32),
                    },
                   ],
                  },
                  Int {
                   value: 64,
                   position: (34, 39),
                  },
                 ),
                ],
                recursive: false,
                position: (34, 30),
               },
              ),
             ],
             recursive: false,
             position: (34, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isBigEndian",
               position: (35, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (35, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "significantByte",
                     position: (35, 32),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "significantBytes",
                    position: (35, 50),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bigEndian",
                      position: (35, 67),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                ],
                recursive: false,
                position: (35, 30),
               },
              ),
             ],
             recursive: false,
             position: (35, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isLittleEndian",
               position: (36, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cpu",
                  position: (36, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "significantByte",
                     position: (36, 32),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "significantBytes",
                    position: (36, 50),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "littleEndian",
                      position: (36, 67),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                ],
                recursive: false,
                position: (36, 30),
               },
              ),
             ],
             recursive: false,
             position: (36, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isBSD",
               position: (38, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (38, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "families",
                     position: (38, 35),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    Inherit(
                     Some(
                      Variable {
                       identifier: "kernelFamilies",
                       position: (38, 57),
                      },
                     ),
                     [
                      Raw {
                       content: "bsd",
                       position: (38, 73),
                      },
                     ],
                    ),
                   ],
                   recursive: false,
                   position: (38, 46),
                  },
                 ),
                ],
                recursive: false,
                position: (38, 33),
               },
              ),
             ],
             recursive: false,
             position: (38, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isDarwin",
               position: (39, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (39, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "families",
                     position: (39, 35),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    Inherit(
                     Some(
                      Variable {
                       identifier: "kernelFamilies",
                       position: (39, 57),
                      },
                     ),
                     [
                      Raw {
                       content: "darwin",
                       position: (39, 73),
                      },
                     ],
                    ),
                   ],
                   recursive: false,
                   position: (39, 46),
                  },
                 ),
                ],
                recursive: false,
                position: (39, 33),
               },
              ),
             ],
             recursive: false,
             position: (39, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isUnix",
               position: (40, 5),
              },
             ],
            },
            List {
             elements: [
              Variable {
               identifier: "isBSD",
               position: (40, 24),
              },
              Variable {
               identifier: "isDarwin",
               position: (40, 30),
              },
              Variable {
               identifier: "isLinux",
               position: (40, 39),
              },
              Variable {
               identifier: "isSunOS",
               position: (40, 47),
              },
              Variable {
               identifier: "isCygwin",
               position: (40, 55),
              },
              Variable {
               identifier: "isRedox",
               position: (40, 64),
              },
             ],
             position: (40, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isMacOS",
               position: (42, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (42, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (42, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "macos",
                   position: (42, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (42, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isiOS",
               position: (43, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (43, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (43, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "ios",
                   position: (43, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (43, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isLinux",
               position: (44, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (44, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (44, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "linux",
                   position: (44, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (44, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isSunOS",
               position: (45, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (45, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (45, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "solaris",
                   position: (45, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (45, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isFreeBSD",
               position: (46, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (46, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (46, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "freebsd",
                   position: (46, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (46, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isNetBSD",
               position: (47, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (47, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (47, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "netbsd",
                   position: (47, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (47, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isOpenBSD",
               position: (48, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (48, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (48, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "openbsd",
                   position: (48, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (48, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isWindows",
               position: (49, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (49, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (49, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "windows",
                   position: (49, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (49, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isCygwin",
               position: (50, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (50, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (50, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "windows",
                   position: (50, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "abi",
                  position: (50, 50),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "abis",
                 position: (50, 56),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "cygnus",
                   position: (50, 61),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (50, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isMinGW",
               position: (51, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (51, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (51, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "windows",
                   position: (51, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "abi",
                  position: (51, 50),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "abis",
                 position: (51, 56),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "gnu",
                   position: (51, 61),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (51, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isWasi",
               position: (52, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (52, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (52, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "wasi",
                   position: (52, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (52, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isRedox",
               position: (53, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (53, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (53, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "redox",
                   position: (53, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (53, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isGhcjs",
               position: (54, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (54, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (54, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "ghcjs",
                   position: (54, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (54, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isGenode",
               position: (55, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (55, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (55, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "genode",
                   position: (55, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (55, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isNone",
               position: (56, 5),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "kernel",
                  position: (56, 24),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (56, 33),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "none",
                   position: (56, 41),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (56, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isAndroid",
               position: (58, 5),
              },
             ],
            },
            List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "abi",
                    position: (58, 26),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "abis",
                   position: (58, 32),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "android",
                     position: (58, 37),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (58, 24),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "abi",
                    position: (58, 50),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "abis",
                   position: (58, 56),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "androideabi",
                     position: (58, 61),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (58, 48),
              },
             ],
             position: (58, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isGnu",
               position: (59, 5),
              },
             ],
            },
            With {
             expression: Variable {
              identifier: "abis",
              position: (59, 27),
             },
             target: FunctionApplication {
              function: Variable {
               identifier: "map",
               position: (59, 33),
              },
              arguments: [
               Function {
                argument: Some(
                 "a",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "abi",
                      position: (59, 43),
                     },
                    ],
                   },
                   Variable {
                    identifier: "a",
                    position: (59, 49),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (59, 41),
                },
                position: (59, 38),
               },
               List {
                elements: [
                 Variable {
                  identifier: "gnuabi64",
                  position: (59, 57),
                 },
                 Variable {
                  identifier: "gnu",
                  position: (59, 66),
                 },
                 Variable {
                  identifier: "gnueabi",
                  position: (59, 70),
                 },
                 Variable {
                  identifier: "gnueabihf",
                  position: (59, 78),
                 },
                ],
                position: (59, 55),
               },
              ],
             },
             position: (59, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isMusl",
               position: (60, 5),
              },
             ],
            },
            With {
             expression: Variable {
              identifier: "abis",
              position: (60, 27),
             },
             target: FunctionApplication {
              function: Variable {
               identifier: "map",
               position: (60, 33),
              },
              arguments: [
               Function {
                argument: Some(
                 "a",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "abi",
                      position: (60, 43),
                     },
                    ],
                   },
                   Variable {
                    identifier: "a",
                    position: (60, 49),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (60, 41),
                },
                position: (60, 38),
               },
               List {
                elements: [
                 Variable {
                  identifier: "musl",
                  position: (60, 57),
                 },
                 Variable {
                  identifier: "musleabi",
                  position: (60, 62),
                 },
                 Variable {
                  identifier: "musleabihf",
                  position: (60, 71),
                 },
                ],
                position: (60, 55),
               },
              ],
             },
             position: (60, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isUClibc",
               position: (61, 5),
              },
             ],
            },
            With {
             expression: Variable {
              identifier: "abis",
              position: (61, 27),
             },
             target: FunctionApplication {
              function: Variable {
               identifier: "map",
               position: (61, 33),
              },
              arguments: [
               Function {
                argument: Some(
                 "a",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "abi",
                      position: (61, 43),
                     },
                    ],
                   },
                   Variable {
                    identifier: "a",
                    position: (61, 49),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (61, 41),
                },
                position: (61, 38),
               },
               List {
                elements: [
                 Variable {
                  identifier: "uclibc",
                  position: (61, 57),
                 },
                 Variable {
                  identifier: "uclibceabi",
                  position: (61, 64),
                 },
                 Variable {
                  identifier: "uclibceabihf",
                  position: (61, 75),
                 },
                ],
                position: (61, 55),
               },
              ],
             },
             position: (61, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isEfi",
               position: (63, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "map",
              position: (63, 22),
             },
             arguments: [
              Function {
               argument: Some(
                "family",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "cpu",
                     position: (63, 37),
                    },
                    Raw {
                     content: "family",
                     position: (63, 41),
                    },
                   ],
                  },
                  Variable {
                   identifier: "family",
                   position: (63, 50),
                  },
                 ),
                ],
                recursive: false,
                position: (63, 35),
               },
               position: (63, 27),
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "x86",
                   position: (64, 27),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "arm",
                   position: (64, 33),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "aarch64",
                   position: (64, 39),
                  },
                 ],
                },
               ],
               position: (64, 24),
              },
             ],
            },
           ),
          ],
          recursive: true,
          position: (10, 14),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "matchAnyAttrs",
            position: (67, 3),
           },
          ],
         },
         Function {
          argument: Some(
           "patterns",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (68, 8),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "isList",
                position: (68, 17),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "patterns",
              position: (68, 24),
             },
            ],
           },
           then: Function {
            argument: Some(
             "attrs",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: FunctionApplication {
             function: Variable {
              identifier: "any",
              position: (68, 45),
             },
             arguments: [
              Function {
               argument: Some(
                "pattern",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: FunctionApplication {
                function: Variable {
                 identifier: "matchAttrs",
                 position: (68, 59),
                },
                arguments: [
                 Variable {
                  identifier: "pattern",
                  position: (68, 70),
                 },
                 Variable {
                  identifier: "attrs",
                  position: (68, 78),
                 },
                ],
               },
               position: (68, 50),
              },
              Variable {
               identifier: "patterns",
               position: (68, 85),
              },
             ],
            },
            position: (68, 38),
           },
           else_: FunctionApplication {
            function: Variable {
             identifier: "matchAttrs",
             position: (69, 10),
            },
            arguments: [
             Variable {
              identifier: "patterns",
              position: (69, 21),
             },
            ],
           },
           position: (68, 5),
          },
          position: (67, 19),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "predicates",
            position: (71, 3),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mapAttrs",
           position: (71, 16),
          },
          arguments: [
           Function {
            argument: Some(
             "_",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Variable {
             identifier: "matchAnyAttrs",
             position: (71, 29),
            },
            position: (71, 26),
           },
           Variable {
            identifier: "patterns",
            position: (71, 44),
           },
          ],
         },
        ),
       ],
       recursive: true,
       position: (9, 1),
      },
      position: (7, 1),
     },
     position: (6, 1),
    },
    position: (4, 1),
   },
   position: (3, 1),
  },
  position: (2, 1),
 },
 position: (1, 1),
}