---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
  ],
  ellipsis: false,
 },
 definition: With {
  expression: PropertyAccess {
   expression: Variable {
    identifier: "lib",
    position: (18, 6),
   },
   attribute_path: AttributePath {
    attributes: [
     Raw {
      content: "lists",
      position: (18, 10),
     },
    ],
   },
   default: None,
  },
  target: With {
   expression: PropertyAccess {
    expression: Variable {
     identifier: "lib",
     position: (19, 6),
    },
    attribute_path: AttributePath {
     attributes: [
      Raw {
       content: "types",
       position: (19, 10),
      },
     ],
    },
    default: None,
   },
   target: With {
    expression: PropertyAccess {
     expression: Variable {
      identifier: "lib",
      position: (20, 6),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "attrsets",
        position: (20, 10),
       },
      ],
     },
     default: None,
    },
    target: With {
     expression: PropertyAccess {
      expression: Variable {
       identifier: "lib",
       position: (21, 6),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "strings",
         position: (21, 10),
        },
       ],
      },
      default: None,
     },
     target: With {
      expression: PropertyAccess {
       expression: FunctionApplication {
        function: Variable {
         identifier: "import",
         position: (22, 7),
        },
        arguments: [
         Path {
          parts: [
           Raw {
            content: "./inspect.nix",
            position: (22, 14),
           },
          ],
         },
         Map {
          bindings: [
           Inherit(
            None,
            [
             Raw {
              content: "lib",
              position: (22, 38),
             },
            ],
           ),
          ],
          recursive: false,
          position: (22, 28),
         },
        ],
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "predicates",
          position: (22, 46),
         },
        ],
       },
       default: None,
      },
      target: LetIn {
       bindings: [
        Inherit(
         Some(
          PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (25, 12),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "options",
              position: (25, 16),
             },
            ],
           },
           default: None,
          },
         ),
         [
          Raw {
           content: "mergeOneOption",
           position: (25, 25),
          },
         ],
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "setTypes",
            position: (27, 3),
           },
          ],
         },
         Function {
          argument: Some(
           "type",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: FunctionApplication {
           function: Variable {
            identifier: "mapAttrs",
            position: (28, 5),
           },
           arguments: [
            Function {
             argument: Some(
              "name",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Function {
              argument: Some(
               "value",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Assert {
               expression: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "type",
                  position: (29, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "check",
                    position: (29, 19),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "value",
                  position: (29, 25),
                 },
                ],
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "setType",
                 position: (30, 7),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "type",
                   position: (30, 15),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "name",
                     position: (30, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                 BinaryOperation {
                  operator: Update,
                  operands: [
                   Map {
                    bindings: [
                     Inherit(
                      None,
                      [
                       Raw {
                        content: "name",
                        position: (30, 36),
                       },
                      ],
                     ),
                    ],
                    recursive: false,
                    position: (30, 26),
                   },
                   Variable {
                    identifier: "value",
                    position: (30, 47),
                   },
                  ],
                  position: (30, 44),
                 },
                ],
               },
               position: (29, 7),
              },
              position: (28, 21),
             },
             position: (28, 15),
            },
           ],
          },
          position: (27, 14),
         },
        ),
       ],
       target: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (38, 3),
            },
            Raw {
             content: "openSignificantByte",
             position: (38, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOptionType",
            position: (38, 31),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (39, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "significant-byte",
                  position: (39, 13),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (40, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Endianness",
                  position: (40, 20),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "merge",
                  position: (41, 5),
                 },
                ],
               },
               Variable {
                identifier: "mergeOneOption",
                position: (41, 13),
               },
              ),
             ],
             recursive: false,
             position: (38, 44),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (44, 3),
            },
            Raw {
             content: "significantByte",
             position: (44, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "enum",
            position: (44, 27),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "attrValues",
              position: (44, 33),
             },
             arguments: [
              Variable {
               identifier: "significantBytes",
               position: (44, 44),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "significantBytes",
             position: (46, 3),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "setTypes",
            position: (46, 22),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "types",
              position: (46, 31),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "openSignificantByte",
                position: (46, 37),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "bigEndian",
                  position: (47, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (47, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "littleEndian",
                  position: (48, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (48, 20),
               },
              ),
             ],
             recursive: false,
             position: (46, 57),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (54, 3),
            },
            Raw {
             content: "bitWidth",
             position: (54, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "enum",
            position: (54, 20),
           },
           arguments: [
            List {
             elements: [
              Int {
               value: 8,
               position: (54, 27),
              },
              Int {
               value: 16,
               position: (54, 29),
              },
              Int {
               value: 32,
               position: (54, 32),
              },
              Int {
               value: 64,
               position: (54, 35),
              },
              Int {
               value: 128,
               position: (54, 38),
              },
             ],
             position: (54, 25),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (58, 3),
            },
            Raw {
             content: "openCpuType",
             position: (58, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOptionType",
            position: (58, 23),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (59, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "cpu-type",
                  position: (59, 13),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (60, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "instruction set architecture name and information",
                  position: (60, 20),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "merge",
                  position: (61, 5),
                 },
                ],
               },
               Variable {
                identifier: "mergeOneOption",
                position: (61, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "check",
                  position: (62, 5),
                 },
                ],
               },
               Function {
                argument: Some(
                 "x",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: BinaryOperation {
                 operator: LogicalAnd,
                 operands: [
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (62, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bitWidth",
                       position: (62, 22),
                      },
                      Raw {
                       content: "check",
                       position: (62, 31),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "x",
                      position: (62, 37),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bits",
                        position: (62, 39),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                  IfThenElse {
                   predicate: BinaryOperation {
                    operator: LessThan,
                    operands: [
                     Int {
                      value: 8,
                      position: (63, 14),
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "x",
                       position: (63, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "bits",
                         position: (63, 20),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (63, 16),
                   },
                   then: FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (64, 16),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "significantByte",
                        position: (64, 22),
                       },
                       Raw {
                        content: "check",
                        position: (64, 38),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "x",
                       position: (64, 44),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "significantByte",
                         position: (64, 46),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                   else_: UnaryOperation {
                    operator: Not,
                    operand: HasProperty {
                     expression: Variable {
                      identifier: "x",
                      position: (65, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "significantByte",
                        position: (65, 22),
                       },
                      ],
                     },
                     position: (65, 20),
                    },
                    position: (65, 16),
                   },
                   position: (63, 11),
                  },
                 ],
                 position: (63, 7),
                },
                position: (62, 13),
               },
              ),
             ],
             recursive: false,
             position: (58, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (68, 3),
            },
            Raw {
             content: "cpuType",
             position: (68, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "enum",
            position: (68, 19),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "attrValues",
              position: (68, 25),
             },
             arguments: [
              Variable {
               identifier: "cpuTypes",
               position: (68, 36),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "cpuTypes",
             position: (70, 3),
            },
           ],
          },
          With {
           expression: Variable {
            identifier: "significantBytes",
            position: (70, 19),
           },
           target: FunctionApplication {
            function: Variable {
             identifier: "setTypes",
             position: (70, 37),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (70, 46),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "openCpuType",
                 position: (70, 52),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "arm",
                   position: (71, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (71, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (71, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (71, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (71, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (71, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (71, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (71, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "armv5tel",
                   position: (72, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (72, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (72, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (72, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (72, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (72, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (72, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (72, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "5",
                      position: (72, 88),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (72, 92),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "armv5t",
                      position: (72, 100),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (72, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "armv6m",
                   position: (73, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (73, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (73, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (73, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (73, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (73, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (73, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (73, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "6",
                      position: (73, 88),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (73, 92),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "armv6-m",
                      position: (73, 100),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (73, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "armv6l",
                   position: (74, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (74, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (74, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (74, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (74, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (74, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (74, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (74, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "6",
                      position: (74, 88),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (74, 92),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "armv6",
                      position: (74, 100),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (74, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "armv7a",
                   position: (75, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (75, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (75, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (75, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (75, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (75, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (75, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (75, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "7",
                      position: (75, 88),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (75, 92),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "armv7-a",
                      position: (75, 100),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (75, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "armv7r",
                   position: (76, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (76, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (76, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (76, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (76, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (76, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (76, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (76, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "7",
                      position: (76, 88),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (76, 92),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "armv7-r",
                      position: (76, 100),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (76, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "armv7m",
                   position: (77, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (77, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (77, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (77, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (77, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (77, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (77, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (77, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "7",
                      position: (77, 88),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (77, 92),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "armv7-m",
                      position: (77, 100),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (77, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "armv7l",
                   position: (78, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (78, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (78, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (78, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (78, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (78, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (78, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (78, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "7",
                      position: (78, 88),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (78, 92),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "armv7",
                      position: (78, 100),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (78, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "armv8a",
                   position: (79, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (79, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (79, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (79, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (79, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (79, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (79, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (79, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "8",
                      position: (79, 88),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (79, 92),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "armv8-a",
                      position: (79, 100),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (79, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "armv8r",
                   position: (80, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (80, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (80, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (80, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (80, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (80, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (80, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (80, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "8",
                      position: (80, 88),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (80, 92),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "armv8-a",
                      position: (80, 100),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (80, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "armv8m",
                   position: (81, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (81, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (81, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (81, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (81, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (81, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (81, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (81, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "8",
                      position: (81, 88),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (81, 92),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "armv8-m",
                      position: (81, 100),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (81, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "aarch64",
                   position: (82, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (82, 18),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (82, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (82, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (82, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (82, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (82, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (82, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "8",
                      position: (82, 88),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (82, 92),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "armv8-a",
                      position: (82, 100),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (82, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "aarch64_be",
                   position: (83, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (83, 20),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (83, 27),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (83, 31),
                     },
                    ],
                   },
                   Variable {
                    identifier: "bigEndian",
                    position: (83, 49),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (83, 60),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arm",
                      position: (83, 70),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (83, 76),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "8",
                      position: (83, 87),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (83, 92),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "armv8-a",
                      position: (83, 100),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (83, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "i386",
                   position: (85, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (85, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (85, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (85, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (85, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (85, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "x86",
                      position: (85, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (85, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "i386",
                      position: (85, 85),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (85, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "i486",
                   position: (86, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (86, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (86, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (86, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (86, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (86, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "x86",
                      position: (86, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (86, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "i486",
                      position: (86, 85),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (86, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "i586",
                   position: (87, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (87, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (87, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (87, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (87, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (87, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "x86",
                      position: (87, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (87, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "i586",
                      position: (87, 85),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (87, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "i686",
                   position: (88, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (88, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (88, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (88, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (88, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (88, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "x86",
                      position: (88, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (88, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "i686",
                      position: (88, 85),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (88, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "x86_64",
                   position: (89, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (89, 18),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (89, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (89, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (89, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (89, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "x86",
                      position: (89, 71),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "arch",
                      position: (89, 77),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "x86-64",
                      position: (89, 85),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (89, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mips",
                   position: (91, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (91, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (91, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (91, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "bigEndian",
                    position: (91, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (91, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "mips",
                      position: (91, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (91, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mipsel",
                   position: (92, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (92, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (92, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (92, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (92, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (92, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "mips",
                      position: (92, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (92, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mips64",
                   position: (93, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (93, 18),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (93, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (93, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "bigEndian",
                    position: (93, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (93, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "mips",
                      position: (93, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (93, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mips64el",
                   position: (94, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (94, 18),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (94, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (94, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (94, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (94, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "mips",
                      position: (94, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (94, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "mmix",
                   position: (96, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (96, 18),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (96, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (96, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "bigEndian",
                    position: (96, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (96, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "mmix",
                      position: (96, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (96, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "m68k",
                   position: (98, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (98, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (98, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (98, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "bigEndian",
                    position: (98, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (98, 58),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "m68k",
                      position: (98, 68),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (98, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "powerpc",
                   position: (100, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (100, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (100, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (100, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "bigEndian",
                    position: (100, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (100, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "power",
                      position: (100, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (100, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "powerpc64",
                   position: (101, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (101, 19),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (101, 26),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (101, 30),
                     },
                    ],
                   },
                   Variable {
                    identifier: "bigEndian",
                    position: (101, 48),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (101, 59),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "power",
                      position: (101, 69),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (101, 17),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "powerpc64le",
                   position: (102, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (102, 21),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (102, 28),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (102, 32),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (102, 50),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (102, 64),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "power",
                      position: (102, 74),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (102, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "powerpcle",
                   position: (103, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (103, 19),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (103, 26),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (103, 30),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (103, 48),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (103, 62),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "power",
                      position: (103, 72),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (103, 17),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "riscv32",
                   position: (105, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (105, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (105, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (105, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (105, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (105, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "riscv",
                      position: (105, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (105, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "riscv64",
                   position: (106, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (106, 18),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (106, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (106, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (106, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (106, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "riscv",
                      position: (106, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (106, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "s390",
                   position: (108, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (108, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (108, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (108, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "bigEndian",
                    position: (108, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (108, 58),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "s390",
                      position: (108, 68),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (108, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "s390x",
                   position: (109, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (109, 18),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (109, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (109, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "bigEndian",
                    position: (109, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (109, 58),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "s390",
                      position: (109, 68),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (109, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "sparc",
                   position: (111, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (111, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (111, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (111, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "bigEndian",
                    position: (111, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (111, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "sparc",
                      position: (111, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (111, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "sparc64",
                   position: (112, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (112, 18),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (112, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (112, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "bigEndian",
                    position: (112, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (112, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "sparc",
                      position: (112, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (112, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wasm32",
                   position: (114, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (114, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (114, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (114, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (114, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (114, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "wasm",
                      position: (114, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (114, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wasm64",
                   position: (115, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (115, 18),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (115, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (115, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (115, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (115, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "wasm",
                      position: (115, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (115, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "alpha",
                   position: (117, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (117, 18),
                     },
                    ],
                   },
                   Int {
                    value: 64,
                    position: (117, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (117, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (117, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (117, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "alpha",
                      position: (117, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (117, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "msp430",
                   position: (119, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (119, 18),
                     },
                    ],
                   },
                   Int {
                    value: 16,
                    position: (119, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (119, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (119, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (119, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "msp430",
                      position: (119, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (119, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "avr",
                   position: (120, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (120, 18),
                     },
                    ],
                   },
                   Int {
                    value: 8,
                    position: (120, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (120, 28),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "avr",
                      position: (120, 38),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (120, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "vc4",
                   position: (122, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (122, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (122, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (122, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (122, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (122, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "vc4",
                      position: (122, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (122, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "or1k",
                   position: (124, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (124, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (124, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (124, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "bigEndian",
                    position: (124, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (124, 58),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "or1k",
                      position: (124, 68),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (124, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "js",
                   position: (126, 5),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (126, 18),
                     },
                    ],
                   },
                   Int {
                    value: 32,
                    position: (126, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "significantByte",
                      position: (126, 29),
                     },
                    ],
                   },
                   Variable {
                    identifier: "littleEndian",
                    position: (126, 47),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (126, 61),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "js",
                      position: (126, 71),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (126, 16),
                },
               ),
              ],
              recursive: false,
              position: (70, 64),
             },
            ],
           },
           position: (70, 14),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "gnuNetBSDDefaultExecFormat",
             position: (130, 3),
            },
           ],
          },
          Function {
           argument: Some(
            "cpu",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: IfThenElse {
            predicate: BinaryOperation {
             operator: LogicalOr,
             operands: [
              BinaryOperation {
               operator: LogicalOr,
               operands: [
                BinaryOperation {
                 operator: LogicalOr,
                 operands: [
                  BinaryOperation {
                   operator: LogicalAnd,
                   operands: [
                    BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cpu",
                        position: (131, 9),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "family",
                          position: (131, 13),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [
                        Raw {
                         content: "arm",
                         position: (131, 24),
                        },
                       ],
                      },
                     ],
                     position: (131, 20),
                    },
                    BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cpu",
                        position: (131, 32),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bits",
                          position: (131, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                      Int {
                       value: 32,
                       position: (131, 44),
                      },
                     ],
                     position: (131, 41),
                    },
                   ],
                   position: (131, 29),
                  },
                  BinaryOperation {
                   operator: LogicalAnd,
                   operands: [
                    BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cpu",
                        position: (132, 9),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "family",
                          position: (132, 13),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [
                        Raw {
                         content: "sparc",
                         position: (132, 24),
                        },
                       ],
                      },
                     ],
                     position: (132, 20),
                    },
                    BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cpu",
                        position: (132, 34),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bits",
                          position: (132, 38),
                         },
                        ],
                       },
                       default: None,
                      },
                      Int {
                       value: 32,
                       position: (132, 46),
                      },
                     ],
                     position: (132, 43),
                    },
                   ],
                   position: (132, 31),
                  },
                 ],
                 position: (131, 48),
                },
                BinaryOperation {
                 operator: LogicalAnd,
                 operands: [
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cpu",
                      position: (133, 9),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "family",
                        position: (133, 13),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [
                      Raw {
                       content: "m68k",
                       position: (133, 24),
                      },
                     ],
                    },
                   ],
                   position: (133, 20),
                  },
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cpu",
                      position: (133, 33),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bits",
                        position: (133, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                    Int {
                     value: 32,
                     position: (133, 45),
                    },
                   ],
                   position: (133, 42),
                  },
                 ],
                 position: (133, 30),
                },
               ],
               position: (132, 50),
              },
              BinaryOperation {
               operator: LogicalAnd,
               operands: [
                BinaryOperation {
                 operator: EqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cpu",
                    position: (134, 9),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "family",
                      position: (134, 13),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "x86",
                     position: (134, 24),
                    },
                   ],
                  },
                 ],
                 position: (134, 20),
                },
                BinaryOperation {
                 operator: EqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cpu",
                    position: (134, 32),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bits",
                      position: (134, 36),
                     },
                    ],
                   },
                   default: None,
                  },
                  Int {
                   value: 32,
                   position: (134, 44),
                  },
                 ],
                 position: (134, 41),
                },
               ],
               position: (134, 29),
              },
             ],
             position: (133, 49),
            },
            then: PropertyAccess {
             expression: Variable {
              identifier: "execFormats",
              position: (135, 10),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "aout",
                position: (135, 22),
               },
              ],
             },
             default: None,
            },
            else_: PropertyAccess {
             expression: Variable {
              identifier: "execFormats",
              position: (136, 10),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "elf",
                position: (136, 22),
               },
              ],
             },
             default: None,
            },
            position: (131, 5),
           },
           position: (130, 32),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "isCompatible",
             position: (152, 3),
            },
           ],
          },
          Function {
           argument: Some(
            "a",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "b",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: With {
             expression: Variable {
              identifier: "cpuTypes",
              position: (152, 29),
             },
             target: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (152, 39),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "any",
                  position: (152, 43),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (152, 47),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "id",
                   position: (152, 51),
                  },
                 ],
                },
                default: None,
               },
               List {
                elements: [
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (154, 6),
                     },
                     Variable {
                      identifier: "i386",
                      position: (154, 11),
                     },
                    ],
                    position: (154, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (154, 19),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (154, 32),
                     },
                     Variable {
                      identifier: "i486",
                      position: (154, 34),
                     },
                    ],
                   },
                  ],
                  position: (154, 16),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (155, 6),
                     },
                     Variable {
                      identifier: "i486",
                      position: (155, 11),
                     },
                    ],
                    position: (155, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (155, 19),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (155, 32),
                     },
                     Variable {
                      identifier: "i586",
                      position: (155, 34),
                     },
                    ],
                   },
                  ],
                  position: (155, 16),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (156, 6),
                     },
                     Variable {
                      identifier: "i586",
                      position: (156, 11),
                     },
                    ],
                    position: (156, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (156, 19),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (156, 32),
                     },
                     Variable {
                      identifier: "i686",
                      position: (156, 34),
                     },
                    ],
                   },
                  ],
                  position: (156, 16),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (159, 6),
                     },
                     Variable {
                      identifier: "i686",
                      position: (159, 11),
                     },
                    ],
                    position: (159, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (159, 19),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (159, 32),
                     },
                     Variable {
                      identifier: "x86_64",
                      position: (159, 34),
                     },
                    ],
                   },
                  ],
                  position: (159, 16),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (162, 6),
                     },
                     Variable {
                      identifier: "arm",
                      position: (162, 11),
                     },
                    ],
                    position: (162, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (162, 18),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (162, 31),
                     },
                     Variable {
                      identifier: "armv5tel",
                      position: (162, 33),
                     },
                    ],
                   },
                  ],
                  position: (162, 15),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (165, 6),
                     },
                     Variable {
                      identifier: "armv5tel",
                      position: (165, 11),
                     },
                    ],
                    position: (165, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (165, 23),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (165, 36),
                     },
                     Variable {
                      identifier: "armv6l",
                      position: (165, 38),
                     },
                    ],
                   },
                  ],
                  position: (165, 20),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (168, 6),
                     },
                     Variable {
                      identifier: "armv6l",
                      position: (168, 11),
                     },
                    ],
                    position: (168, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (168, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (168, 34),
                     },
                     Variable {
                      identifier: "armv6m",
                      position: (168, 36),
                     },
                    ],
                   },
                  ],
                  position: (168, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (169, 6),
                     },
                     Variable {
                      identifier: "armv6m",
                      position: (169, 11),
                     },
                    ],
                    position: (169, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (169, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (169, 34),
                     },
                     Variable {
                      identifier: "armv7l",
                      position: (169, 36),
                     },
                    ],
                   },
                  ],
                  position: (169, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (172, 6),
                     },
                     Variable {
                      identifier: "armv7l",
                      position: (172, 11),
                     },
                    ],
                    position: (172, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (172, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (172, 34),
                     },
                     Variable {
                      identifier: "armv7a",
                      position: (172, 36),
                     },
                    ],
                   },
                  ],
                  position: (172, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (173, 6),
                     },
                     Variable {
                      identifier: "armv7l",
                      position: (173, 11),
                     },
                    ],
                    position: (173, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (173, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (173, 34),
                     },
                     Variable {
                      identifier: "armv7r",
                      position: (173, 36),
                     },
                    ],
                   },
                  ],
                  position: (173, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (174, 6),
                     },
                     Variable {
                      identifier: "armv7l",
                      position: (174, 11),
                     },
                    ],
                    position: (174, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (174, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (174, 34),
                     },
                     Variable {
                      identifier: "armv7m",
                      position: (174, 36),
                     },
                    ],
                   },
                  ],
                  position: (174, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (175, 6),
                     },
                     Variable {
                      identifier: "armv7a",
                      position: (175, 11),
                     },
                    ],
                    position: (175, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (175, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (175, 34),
                     },
                     Variable {
                      identifier: "armv8a",
                      position: (175, 36),
                     },
                    ],
                   },
                  ],
                  position: (175, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (176, 6),
                     },
                     Variable {
                      identifier: "armv7r",
                      position: (176, 11),
                     },
                    ],
                    position: (176, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (176, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (176, 34),
                     },
                     Variable {
                      identifier: "armv8a",
                      position: (176, 36),
                     },
                    ],
                   },
                  ],
                  position: (176, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (177, 6),
                     },
                     Variable {
                      identifier: "armv7m",
                      position: (177, 11),
                     },
                    ],
                    position: (177, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (177, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (177, 34),
                     },
                     Variable {
                      identifier: "armv8a",
                      position: (177, 36),
                     },
                    ],
                   },
                  ],
                  position: (177, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (178, 6),
                     },
                     Variable {
                      identifier: "armv7a",
                      position: (178, 11),
                     },
                    ],
                    position: (178, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (178, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (178, 34),
                     },
                     Variable {
                      identifier: "armv8r",
                      position: (178, 36),
                     },
                    ],
                   },
                  ],
                  position: (178, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (179, 6),
                     },
                     Variable {
                      identifier: "armv7r",
                      position: (179, 11),
                     },
                    ],
                    position: (179, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (179, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (179, 34),
                     },
                     Variable {
                      identifier: "armv8r",
                      position: (179, 36),
                     },
                    ],
                   },
                  ],
                  position: (179, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (180, 6),
                     },
                     Variable {
                      identifier: "armv7m",
                      position: (180, 11),
                     },
                    ],
                    position: (180, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (180, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (180, 34),
                     },
                     Variable {
                      identifier: "armv8r",
                      position: (180, 36),
                     },
                    ],
                   },
                  ],
                  position: (180, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (181, 6),
                     },
                     Variable {
                      identifier: "armv7a",
                      position: (181, 11),
                     },
                    ],
                    position: (181, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (181, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (181, 34),
                     },
                     Variable {
                      identifier: "armv8m",
                      position: (181, 36),
                     },
                    ],
                   },
                  ],
                  position: (181, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (182, 6),
                     },
                     Variable {
                      identifier: "armv7r",
                      position: (182, 11),
                     },
                    ],
                    position: (182, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (182, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (182, 34),
                     },
                     Variable {
                      identifier: "armv8m",
                      position: (182, 36),
                     },
                    ],
                   },
                  ],
                  position: (182, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (183, 6),
                     },
                     Variable {
                      identifier: "armv7m",
                      position: (183, 11),
                     },
                    ],
                    position: (183, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (183, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (183, 34),
                     },
                     Variable {
                      identifier: "armv8m",
                      position: (183, 36),
                     },
                    ],
                   },
                  ],
                  position: (183, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (186, 6),
                     },
                     Variable {
                      identifier: "armv8r",
                      position: (186, 11),
                     },
                    ],
                    position: (186, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (186, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (186, 34),
                     },
                     Variable {
                      identifier: "armv8a",
                      position: (186, 36),
                     },
                    ],
                   },
                  ],
                  position: (186, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (187, 6),
                     },
                     Variable {
                      identifier: "armv8m",
                      position: (187, 11),
                     },
                    ],
                    position: (187, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (187, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (187, 34),
                     },
                     Variable {
                      identifier: "armv8a",
                      position: (187, 36),
                     },
                    ],
                   },
                  ],
                  position: (187, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (190, 6),
                     },
                     Variable {
                      identifier: "aarch64",
                      position: (190, 11),
                     },
                    ],
                    position: (190, 8),
                   },
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "a",
                      position: (190, 22),
                     },
                     Variable {
                      identifier: "armv8a",
                      position: (190, 27),
                     },
                    ],
                    position: (190, 24),
                   },
                  ],
                  position: (190, 19),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (191, 6),
                     },
                     Variable {
                      identifier: "armv8a",
                      position: (191, 11),
                     },
                    ],
                    position: (191, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (191, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (191, 34),
                     },
                     Variable {
                      identifier: "aarch64",
                      position: (191, 36),
                     },
                    ],
                   },
                  ],
                  position: (191, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (193, 6),
                     },
                     Variable {
                      identifier: "aarch64",
                      position: (193, 11),
                     },
                    ],
                    position: (193, 8),
                   },
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "a",
                      position: (193, 22),
                     },
                     Variable {
                      identifier: "aarch64_be",
                      position: (193, 27),
                     },
                    ],
                    position: (193, 24),
                   },
                  ],
                  position: (193, 19),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (194, 6),
                     },
                     Variable {
                      identifier: "aarch64_be",
                      position: (194, 11),
                     },
                    ],
                    position: (194, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (194, 25),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (194, 38),
                     },
                     Variable {
                      identifier: "aarch64",
                      position: (194, 40),
                     },
                    ],
                   },
                  ],
                  position: (194, 22),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (197, 6),
                     },
                     Variable {
                      identifier: "powerpc",
                      position: (197, 11),
                     },
                    ],
                    position: (197, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (197, 22),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (197, 35),
                     },
                     Variable {
                      identifier: "powerpc64",
                      position: (197, 37),
                     },
                    ],
                   },
                  ],
                  position: (197, 19),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (198, 6),
                     },
                     Variable {
                      identifier: "powerpcle",
                      position: (198, 11),
                     },
                    ],
                    position: (198, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (198, 24),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (198, 37),
                     },
                     Variable {
                      identifier: "powerpc",
                      position: (198, 39),
                     },
                    ],
                   },
                  ],
                  position: (198, 21),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (199, 6),
                     },
                     Variable {
                      identifier: "powerpc",
                      position: (199, 11),
                     },
                    ],
                    position: (199, 8),
                   },
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "a",
                      position: (199, 22),
                     },
                     Variable {
                      identifier: "powerpcle",
                      position: (199, 27),
                     },
                    ],
                    position: (199, 24),
                   },
                  ],
                  position: (199, 19),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (200, 6),
                     },
                     Variable {
                      identifier: "powerpc64le",
                      position: (200, 11),
                     },
                    ],
                    position: (200, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (200, 26),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (200, 39),
                     },
                     Variable {
                      identifier: "powerpc64",
                      position: (200, 41),
                     },
                    ],
                   },
                  ],
                  position: (200, 23),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (201, 6),
                     },
                     Variable {
                      identifier: "powerpc64",
                      position: (201, 11),
                     },
                    ],
                    position: (201, 8),
                   },
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "a",
                      position: (201, 24),
                     },
                     Variable {
                      identifier: "powerpc64le",
                      position: (201, 29),
                     },
                    ],
                    position: (201, 26),
                   },
                  ],
                  position: (201, 21),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (204, 6),
                     },
                     Variable {
                      identifier: "mips",
                      position: (204, 11),
                     },
                    ],
                    position: (204, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (204, 19),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (204, 32),
                     },
                     Variable {
                      identifier: "mips64",
                      position: (204, 34),
                     },
                    ],
                   },
                  ],
                  position: (204, 16),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (205, 6),
                     },
                     Variable {
                      identifier: "mips",
                      position: (205, 11),
                     },
                    ],
                    position: (205, 8),
                   },
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "a",
                      position: (205, 19),
                     },
                     Variable {
                      identifier: "mipsel",
                      position: (205, 24),
                     },
                    ],
                    position: (205, 21),
                   },
                  ],
                  position: (205, 16),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (206, 6),
                     },
                     Variable {
                      identifier: "mipsel",
                      position: (206, 11),
                     },
                    ],
                    position: (206, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (206, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (206, 34),
                     },
                     Variable {
                      identifier: "mips",
                      position: (206, 36),
                     },
                    ],
                   },
                  ],
                  position: (206, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (207, 6),
                     },
                     Variable {
                      identifier: "mips64",
                      position: (207, 11),
                     },
                    ],
                    position: (207, 8),
                   },
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "a",
                      position: (207, 21),
                     },
                     Variable {
                      identifier: "mips64el",
                      position: (207, 26),
                     },
                    ],
                    position: (207, 23),
                   },
                  ],
                  position: (207, 18),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (208, 6),
                     },
                     Variable {
                      identifier: "mips64el",
                      position: (208, 11),
                     },
                    ],
                    position: (208, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (208, 23),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (208, 36),
                     },
                     Variable {
                      identifier: "mips64",
                      position: (208, 38),
                     },
                    ],
                   },
                  ],
                  position: (208, 20),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (211, 6),
                     },
                     Variable {
                      identifier: "riscv32",
                      position: (211, 11),
                     },
                    ],
                    position: (211, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (211, 22),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (211, 35),
                     },
                     Variable {
                      identifier: "riscv64",
                      position: (211, 37),
                     },
                    ],
                   },
                  ],
                  position: (211, 19),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (214, 6),
                     },
                     Variable {
                      identifier: "sparc",
                      position: (214, 11),
                     },
                    ],
                    position: (214, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (214, 20),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (214, 33),
                     },
                     Variable {
                      identifier: "sparc64",
                      position: (214, 35),
                     },
                    ],
                   },
                  ],
                  position: (214, 17),
                 },
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     Variable {
                      identifier: "b",
                      position: (217, 6),
                     },
                     Variable {
                      identifier: "wasm32",
                      position: (217, 11),
                     },
                    ],
                    position: (217, 8),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "isCompatible",
                     position: (217, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "a",
                      position: (217, 34),
                     },
                     Variable {
                      identifier: "wasm64",
                      position: (217, 36),
                     },
                    ],
                   },
                  ],
                  position: (217, 18),
                 },
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   Variable {
                    identifier: "b",
                    position: (220, 6),
                   },
                   Variable {
                    identifier: "a",
                    position: (220, 11),
                   },
                  ],
                  position: (220, 8),
                 },
                ],
                position: (152, 54),
               },
              ],
             },
             position: (152, 24),
            },
            position: (152, 21),
           },
           position: (152, 18),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (225, 3),
            },
            Raw {
             content: "openVendor",
             position: (225, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOptionType",
            position: (225, 22),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (226, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "vendor",
                  position: (226, 13),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (227, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "vendor for the platform",
                  position: (227, 20),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "merge",
                  position: (228, 5),
                 },
                ],
               },
               Variable {
                identifier: "mergeOneOption",
                position: (228, 13),
               },
              ),
             ],
             recursive: false,
             position: (225, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (231, 3),
            },
            Raw {
             content: "vendor",
             position: (231, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "enum",
            position: (231, 18),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "attrValues",
              position: (231, 24),
             },
             arguments: [
              Variable {
               identifier: "vendors",
               position: (231, 35),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "vendors",
             position: (233, 3),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "setTypes",
            position: (233, 13),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "types",
              position: (233, 22),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "openVendor",
                position: (233, 28),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "apple",
                  position: (234, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (234, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "pc",
                  position: (235, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (235, 10),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "w64",
                  position: (238, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (238, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "none",
                  position: (240, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (240, 12),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "unknown",
                  position: (241, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (241, 15),
               },
              ),
             ],
             recursive: false,
             position: (233, 39),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (246, 3),
            },
            Raw {
             content: "openExecFormat",
             position: (246, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOptionType",
            position: (246, 26),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (247, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "exec-format",
                  position: (247, 13),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (248, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "executable container used by the kernel",
                  position: (248, 20),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "merge",
                  position: (249, 5),
                 },
                ],
               },
               Variable {
                identifier: "mergeOneOption",
                position: (249, 13),
               },
              ),
             ],
             recursive: false,
             position: (246, 39),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (252, 3),
            },
            Raw {
             content: "execFormat",
             position: (252, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "enum",
            position: (252, 22),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "attrValues",
              position: (252, 28),
             },
             arguments: [
              Variable {
               identifier: "execFormats",
               position: (252, 39),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "execFormats",
             position: (254, 3),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "setTypes",
            position: (254, 17),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "types",
              position: (254, 26),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "openExecFormat",
                position: (254, 32),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "aout",
                  position: (255, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (255, 12),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "elf",
                  position: (256, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (256, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "macho",
                  position: (257, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (257, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "pe",
                  position: (258, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (258, 10),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "wasm",
                  position: (259, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (259, 12),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "unknown",
                  position: (261, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (261, 15),
               },
              ),
             ],
             recursive: false,
             position: (254, 47),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (266, 3),
            },
            Raw {
             content: "openKernelFamily",
             position: (266, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOptionType",
            position: (266, 28),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (267, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "exec-format",
                  position: (267, 13),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (268, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "executable container used by the kernel",
                  position: (268, 20),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "merge",
                  position: (269, 5),
                 },
                ],
               },
               Variable {
                identifier: "mergeOneOption",
                position: (269, 13),
               },
              ),
             ],
             recursive: false,
             position: (266, 41),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (272, 3),
            },
            Raw {
             content: "kernelFamily",
             position: (272, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "enum",
            position: (272, 24),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "attrValues",
              position: (272, 30),
             },
             arguments: [
              Variable {
               identifier: "kernelFamilies",
               position: (272, 41),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "kernelFamilies",
             position: (274, 3),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "setTypes",
            position: (274, 20),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "types",
              position: (274, 29),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "openKernelFamily",
                position: (274, 35),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "bsd",
                  position: (275, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (275, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "darwin",
                  position: (276, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (276, 14),
               },
              ),
             ],
             recursive: false,
             position: (274, 52),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (281, 3),
            },
            Raw {
             content: "openKernel",
             position: (281, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOptionType",
            position: (281, 22),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (282, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "kernel",
                  position: (282, 13),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (283, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "kernel name and information",
                  position: (283, 20),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "merge",
                  position: (284, 5),
                 },
                ],
               },
               Variable {
                identifier: "mergeOneOption",
                position: (284, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "check",
                  position: (285, 5),
                 },
                ],
               },
               Function {
                argument: Some(
                 "x",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: BinaryOperation {
                 operator: LogicalAnd,
                 operands: [
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (285, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "execFormat",
                       position: (285, 22),
                      },
                      Raw {
                       content: "check",
                       position: (285, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "x",
                      position: (285, 39),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "execFormat",
                        position: (285, 41),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "all",
                    position: (286, 12),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (286, 16),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "kernelFamily",
                        position: (286, 22),
                       },
                       Raw {
                        content: "check",
                        position: (286, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "attrValues",
                      position: (286, 42),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "x",
                        position: (286, 53),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "families",
                          position: (286, 55),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   ],
                  },
                 ],
                 position: (286, 9),
                },
                position: (285, 13),
               },
              ),
             ],
             recursive: false,
             position: (281, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (289, 3),
            },
            Raw {
             content: "kernel",
             position: (289, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "enum",
            position: (289, 18),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "attrValues",
              position: (289, 24),
             },
             arguments: [
              Variable {
               identifier: "kernels",
               position: (289, 35),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "kernels",
             position: (291, 3),
            },
           ],
          },
          With {
           expression: Variable {
            identifier: "execFormats",
            position: (291, 18),
           },
           target: With {
            expression: Variable {
             identifier: "kernelFamilies",
             position: (291, 36),
            },
            target: BinaryOperation {
             operator: Update,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "setTypes",
                position: (291, 52),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (291, 61),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "openKernel",
                    position: (291, 67),
                   },
                  ],
                 },
                 default: None,
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "macos",
                      position: (294, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (294, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "macho",
                       position: (294, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (294, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        Inherit(
                         None,
                         [
                          Raw {
                           content: "darwin",
                           position: (294, 61),
                          },
                         ],
                        ),
                       ],
                       recursive: false,
                       position: (294, 51),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "name",
                         position: (294, 72),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "darwin",
                         position: (294, 80),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (294, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ios",
                      position: (295, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (295, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "macho",
                       position: (295, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (295, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        Inherit(
                         None,
                         [
                          Raw {
                           content: "darwin",
                           position: (295, 61),
                          },
                         ],
                        ),
                       ],
                       recursive: false,
                       position: (295, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (295, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "freebsd",
                      position: (296, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (296, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "elf",
                       position: (296, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (296, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        Inherit(
                         None,
                         [
                          Raw {
                           content: "bsd",
                           position: (296, 61),
                          },
                         ],
                        ),
                       ],
                       recursive: false,
                       position: (296, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (296, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "linux",
                      position: (297, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (297, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "elf",
                       position: (297, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (297, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [],
                       recursive: false,
                       position: (297, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (297, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "netbsd",
                      position: (298, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (298, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "elf",
                       position: (298, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (298, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        Inherit(
                         None,
                         [
                          Raw {
                           content: "bsd",
                           position: (298, 61),
                          },
                         ],
                        ),
                       ],
                       recursive: false,
                       position: (298, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (298, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "none",
                      position: (299, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (299, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "unknown",
                       position: (299, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (299, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [],
                       recursive: false,
                       position: (299, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (299, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "openbsd",
                      position: (300, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (300, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "elf",
                       position: (300, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (300, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        Inherit(
                         None,
                         [
                          Raw {
                           content: "bsd",
                           position: (300, 61),
                          },
                         ],
                        ),
                       ],
                       recursive: false,
                       position: (300, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (300, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "solaris",
                      position: (301, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (301, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "elf",
                       position: (301, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (301, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [],
                       recursive: false,
                       position: (301, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (301, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "wasi",
                      position: (302, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (302, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "wasm",
                       position: (302, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (302, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [],
                       recursive: false,
                       position: (302, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (302, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "redox",
                      position: (303, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (303, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "elf",
                       position: (303, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (303, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [],
                       recursive: false,
                       position: (303, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (303, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "windows",
                      position: (304, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (304, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "pe",
                       position: (304, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (304, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [],
                       recursive: false,
                       position: (304, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (304, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ghcjs",
                      position: (305, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (305, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "unknown",
                       position: (305, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (305, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [],
                       recursive: false,
                       position: (305, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (305, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "genode",
                      position: (306, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (306, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "elf",
                       position: (306, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (306, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [],
                       recursive: false,
                       position: (306, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (306, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "mmixware",
                      position: (307, 5),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (307, 18),
                        },
                       ],
                      },
                      Variable {
                       identifier: "unknown",
                       position: (307, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "families",
                         position: (307, 40),
                        },
                       ],
                      },
                      Map {
                       bindings: [],
                       recursive: false,
                       position: (307, 51),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (307, 16),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (291, 78),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "darwin",
                    position: (310, 5),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "kernels",
                   position: (310, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "macos",
                     position: (310, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "watchos",
                    position: (311, 5),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "kernels",
                   position: (311, 15),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "ios",
                     position: (311, 23),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "tvos",
                    position: (312, 5),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "kernels",
                   position: (312, 12),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "ios",
                     position: (312, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "win32",
                    position: (313, 5),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "kernels",
                   position: (313, 13),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "windows",
                     position: (313, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (308, 8),
              },
             ],
             position: (308, 5),
            },
            position: (291, 31),
           },
           position: (291, 13),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (318, 3),
            },
            Raw {
             content: "openAbi",
             position: (318, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOptionType",
            position: (318, 19),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (319, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "abi",
                  position: (319, 13),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (320, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "binary interface for compiled code and syscalls",
                  position: (320, 20),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "merge",
                  position: (321, 5),
                 },
                ],
               },
               Variable {
                identifier: "mergeOneOption",
                position: (321, 13),
               },
              ),
             ],
             recursive: false,
             position: (318, 32),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (324, 3),
            },
            Raw {
             content: "abi",
             position: (324, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "enum",
            position: (324, 15),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "attrValues",
              position: (324, 21),
             },
             arguments: [
              Variable {
               identifier: "abis",
               position: (324, 32),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "abis",
             position: (326, 3),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "setTypes",
            position: (326, 10),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "types",
              position: (326, 19),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "openAbi",
                position: (326, 25),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "cygnus",
                  position: (327, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (327, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "msvc",
                  position: (328, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (328, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "eabi",
                  position: (333, 5),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "float",
                     position: (333, 22),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "soft",
                     position: (333, 31),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (333, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "eabihf",
                  position: (334, 5),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "float",
                     position: (334, 22),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "hard",
                     position: (334, 31),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (334, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "elf",
                  position: (337, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (337, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "androideabi",
                  position: (339, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (339, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "android",
                  position: (340, 5),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "assertions",
                     position: (341, 7),
                    },
                   ],
                  },
                  List {
                   elements: [
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "assertion",
                          position: (342, 11),
                         },
                        ],
                       },
                       Function {
                        argument: Some(
                         "platform",
                        ),
                        arguments: FunctionArguments {
                         arguments: [],
                         ellipsis: false,
                        },
                        definition: UnaryOperation {
                         operator: Not,
                         operand: PropertyAccess {
                          expression: Variable {
                           identifier: "platform",
                           position: (342, 34),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "isAarch32",
                             position: (342, 43),
                            },
                           ],
                          },
                          default: None,
                         },
                         position: (342, 33),
                        },
                        position: (342, 23),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "message",
                          position: (343, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "The \"android\" ABI is not for 32-bit ARM. Use \"androideabi\" instead.\n",
                          position: (344, 1),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (342, 9),
                    },
                   ],
                   position: (341, 20),
                  },
                 ),
                ],
                recursive: false,
                position: (340, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "gnueabi",
                  position: (350, 5),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "float",
                     position: (350, 22),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "soft",
                     position: (350, 31),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (350, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "gnueabihf",
                  position: (351, 5),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "float",
                     position: (351, 22),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "hard",
                     position: (351, 31),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (351, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "gnu",
                  position: (352, 5),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "assertions",
                     position: (353, 7),
                    },
                   ],
                  },
                  List {
                   elements: [
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "assertion",
                          position: (354, 11),
                         },
                        ],
                       },
                       Function {
                        argument: Some(
                         "platform",
                        ),
                        arguments: FunctionArguments {
                         arguments: [],
                         ellipsis: false,
                        },
                        definition: UnaryOperation {
                         operator: Not,
                         operand: PropertyAccess {
                          expression: Variable {
                           identifier: "platform",
                           position: (354, 34),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "isAarch32",
                             position: (354, 43),
                            },
                           ],
                          },
                          default: None,
                         },
                         position: (354, 33),
                        },
                        position: (354, 23),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "message",
                          position: (355, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "The \"gnu\" ABI is ambiguous on 32-bit ARM. Use \"gnueabi\" or \"gnueabihf\" instead.\n",
                          position: (356, 1),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (354, 9),
                    },
                   ],
                   position: (353, 20),
                  },
                 ),
                ],
                recursive: false,
                position: (352, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "gnuabi64",
                  position: (361, 5),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "abi",
                     position: (361, 22),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "64",
                     position: (361, 29),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (361, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "musleabi",
                  position: (363, 5),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "float",
                     position: (363, 22),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "soft",
                     position: (363, 31),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (363, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "musleabihf",
                  position: (364, 5),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "float",
                     position: (364, 22),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "hard",
                     position: (364, 31),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (364, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "musl",
                  position: (365, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (365, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "uclibceabihf",
                  position: (367, 5),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "float",
                     position: (367, 22),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "soft",
                     position: (367, 31),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (367, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "uclibceabi",
                  position: (368, 5),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "float",
                     position: (368, 22),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "hard",
                     position: (368, 31),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (368, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "uclibc",
                  position: (369, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (369, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "unknown",
                  position: (371, 5),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (371, 15),
               },
              ),
             ],
             recursive: false,
             position: (326, 33),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (376, 3),
            },
            Raw {
             content: "parsedPlatform",
             position: (376, 9),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOptionType",
            position: (376, 26),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (377, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "system",
                  position: (377, 13),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (378, 5),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "fully parsed representation of llvm- or nix-style platform tuple",
                  position: (378, 20),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "merge",
                  position: (379, 5),
                 },
                ],
               },
               Variable {
                identifier: "mergeOneOption",
                position: (379, 13),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "check",
                  position: (380, 5),
                 },
                ],
               },
               Function {
                argument: None,
                arguments: FunctionArguments {
                 arguments: [
                  FunctionArgument {
                   identifier: "abi",
                   default: None,
                  },
                  FunctionArgument {
                   identifier: "kernel",
                   default: None,
                  },
                  FunctionArgument {
                   identifier: "vendor",
                   default: None,
                  },
                  FunctionArgument {
                   identifier: "cpu",
                   default: None,
                  },
                 ],
                 ellipsis: false,
                },
                definition: BinaryOperation {
                 operator: LogicalAnd,
                 operands: [
                  BinaryOperation {
                   operator: LogicalAnd,
                   operands: [
                    BinaryOperation {
                     operator: LogicalAnd,
                     operands: [
                      FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "types",
                         position: (381, 12),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "cpuType",
                           position: (381, 18),
                          },
                          Raw {
                           content: "check",
                           position: (381, 26),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        Variable {
                         identifier: "cpu",
                         position: (381, 32),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "types",
                         position: (382, 12),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "vendor",
                           position: (382, 18),
                          },
                          Raw {
                           content: "check",
                           position: (382, 25),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        Variable {
                         identifier: "vendor",
                         position: (382, 31),
                        },
                       ],
                      },
                     ],
                     position: (382, 9),
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (383, 12),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "kernel",
                         position: (383, 18),
                        },
                        Raw {
                         content: "check",
                         position: (383, 25),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "kernel",
                       position: (383, 31),
                      },
                     ],
                    },
                   ],
                   position: (383, 9),
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (384, 12),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "abi",
                       position: (384, 18),
                      },
                      Raw {
                       content: "check",
                       position: (384, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "abi",
                     position: (384, 28),
                    },
                   ],
                  },
                 ],
                 position: (384, 9),
                },
                position: (380, 13),
               },
              ),
             ],
             recursive: false,
             position: (376, 39),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "isSystem",
             position: (387, 3),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "isType",
            position: (387, 14),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "system",
               position: (387, 22),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "mkSystem",
             position: (389, 3),
            },
           ],
          },
          Function {
           argument: Some(
            "components",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Assert {
            expression: FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (390, 12),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "parsedPlatform",
                 position: (390, 18),
                },
                Raw {
                 content: "check",
                 position: (390, 33),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Variable {
               identifier: "components",
               position: (390, 39),
              },
             ],
            },
            target: FunctionApplication {
             function: Variable {
              identifier: "setType",
              position: (391, 5),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "system",
                 position: (391, 14),
                },
               ],
              },
              Variable {
               identifier: "components",
               position: (391, 22),
              },
             ],
            },
            position: (390, 5),
           },
           position: (389, 14),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "mkSkeletonFromList",
             position: (393, 3),
            },
           ],
          },
          Function {
           argument: Some(
            "l",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: PropertyAccess {
            expression: Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Expression {
                  expression: String {
                   parts: [
                    Raw {
                     content: "1",
                     position: (394, 6),
                    },
                   ],
                  },
                 },
                ],
               },
               IfThenElse {
                predicate: BinaryOperation {
                 operator: EqualTo,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "elemAt",
                    position: (394, 14),
                   },
                   arguments: [
                    Variable {
                     identifier: "l",
                     position: (394, 21),
                    },
                    Int {
                     value: 0,
                     position: (394, 23),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "avr",
                     position: (394, 29),
                    },
                   ],
                  },
                 ],
                 position: (394, 25),
                },
                then: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "cpu",
                      position: (395, 14),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "elemAt",
                     position: (395, 20),
                    },
                    arguments: [
                     Variable {
                      identifier: "l",
                      position: (395, 27),
                     },
                     Int {
                      value: 0,
                      position: (395, 29),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "kernel",
                      position: (395, 32),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "none",
                      position: (395, 42),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "abi",
                      position: (395, 49),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "unknown",
                      position: (395, 56),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (395, 12),
                },
                else_: FunctionApplication {
                 function: Variable {
                  identifier: "throw",
                  position: (396, 12),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "Target specification with 1 components is ambiguous",
                     position: (396, 19),
                    },
                   ],
                  },
                 ],
                },
                position: (394, 11),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Expression {
                  expression: String {
                   parts: [
                    Raw {
                     content: "2",
                     position: (397, 6),
                    },
                   ],
                  },
                 },
                ],
               },
               IfThenElse {
                predicate: BinaryOperation {
                 operator: EqualTo,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "elemAt",
                    position: (398, 10),
                   },
                   arguments: [
                    Variable {
                     identifier: "l",
                     position: (398, 17),
                    },
                    Int {
                     value: 1,
                     position: (398, 19),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "cygwin",
                     position: (398, 25),
                    },
                   ],
                  },
                 ],
                 position: (398, 21),
                },
                then: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "cpu",
                      position: (399, 16),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "elemAt",
                     position: (399, 22),
                    },
                    arguments: [
                     Variable {
                      identifier: "l",
                      position: (399, 29),
                     },
                     Int {
                      value: 0,
                      position: (399, 31),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "kernel",
                      position: (399, 55),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "windows",
                      position: (399, 65),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "abi",
                      position: (399, 76),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "cygnus",
                      position: (399, 83),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (399, 14),
                },
                else_: IfThenElse {
                 predicate: BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "elemAt",
                     position: (404, 15),
                    },
                    arguments: [
                     Variable {
                      identifier: "l",
                      position: (404, 22),
                     },
                     Int {
                      value: 1,
                      position: (404, 24),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "windows",
                      position: (404, 30),
                     },
                    ],
                   },
                  ],
                  position: (404, 26),
                 },
                 then: Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "cpu",
                       position: (405, 16),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "elemAt",
                      position: (405, 22),
                     },
                     arguments: [
                      Variable {
                       identifier: "l",
                       position: (405, 29),
                      },
                      Int {
                       value: 0,
                       position: (405, 31),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "kernel",
                       position: (405, 55),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "windows",
                       position: (405, 65),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "abi",
                       position: (405, 76),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "msvc",
                       position: (405, 83),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (405, 14),
                 },
                 else_: IfThenElse {
                  predicate: BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "elemAt",
                      position: (406, 16),
                     },
                     arguments: [
                      Variable {
                       identifier: "l",
                       position: (406, 23),
                      },
                      Int {
                       value: 1,
                       position: (406, 25),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "elf",
                       position: (406, 32),
                      },
                     ],
                    },
                   ],
                   position: (406, 28),
                  },
                  then: Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "cpu",
                        position: (407, 16),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "elemAt",
                       position: (407, 22),
                      },
                      arguments: [
                       Variable {
                        identifier: "l",
                        position: (407, 29),
                       },
                       Int {
                        value: 0,
                        position: (407, 31),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "vendor",
                        position: (407, 34),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "unknown",
                        position: (407, 44),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "kernel",
                        position: (407, 55),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "none",
                        position: (407, 65),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "abi",
                        position: (407, 76),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "elemAt",
                       position: (407, 82),
                      },
                      arguments: [
                       Variable {
                        identifier: "l",
                        position: (407, 89),
                       },
                       Int {
                        value: 1,
                        position: (407, 91),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (407, 14),
                  },
                  else_: Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "cpu",
                        position: (408, 16),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "elemAt",
                       position: (408, 22),
                      },
                      arguments: [
                       Variable {
                        identifier: "l",
                        position: (408, 29),
                       },
                       Int {
                        value: 0,
                        position: (408, 31),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "kernel",
                        position: (408, 55),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "elemAt",
                       position: (408, 64),
                      },
                      arguments: [
                       Variable {
                        identifier: "l",
                        position: (408, 71),
                       },
                       Int {
                        value: 1,
                        position: (408, 73),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (408, 14),
                  },
                  position: (406, 12),
                 },
                 position: (404, 12),
                },
                position: (398, 7),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Expression {
                  expression: String {
                   parts: [
                    Raw {
                     content: "3",
                     position: (409, 6),
                    },
                   ],
                  },
                 },
                ],
               },
               IfThenElse {
                predicate: BinaryOperation {
                 operator: EqualTo,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "elemAt",
                    position: (410, 10),
                   },
                   arguments: [
                    Variable {
                     identifier: "l",
                     position: (410, 17),
                    },
                    Int {
                     value: 1,
                     position: (410, 19),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "apple",
                     position: (410, 25),
                    },
                   ],
                  },
                 ],
                 position: (410, 21),
                },
                then: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "cpu",
                      position: (411, 16),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "elemAt",
                     position: (411, 22),
                    },
                    arguments: [
                     Variable {
                      identifier: "l",
                      position: (411, 29),
                     },
                     Int {
                      value: 0,
                      position: (411, 31),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "vendor",
                      position: (411, 34),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "apple",
                      position: (411, 44),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "kernel",
                      position: (411, 55),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "elemAt",
                     position: (411, 64),
                    },
                    arguments: [
                     Variable {
                      identifier: "l",
                      position: (411, 71),
                     },
                     Int {
                      value: 2,
                      position: (411, 73),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (411, 14),
                },
                else_: IfThenElse {
                 predicate: BinaryOperation {
                  operator: LogicalOr,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "elemAt",
                       position: (412, 16),
                      },
                      arguments: [
                       Variable {
                        identifier: "l",
                        position: (412, 23),
                       },
                       Int {
                        value: 1,
                        position: (412, 25),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "linux",
                        position: (412, 31),
                       },
                      ],
                     },
                    ],
                    position: (412, 27),
                   },
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "elemAt",
                       position: (412, 43),
                      },
                      arguments: [
                       Variable {
                        identifier: "l",
                        position: (412, 50),
                       },
                       Int {
                        value: 2,
                        position: (412, 52),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "gnu",
                        position: (412, 58),
                       },
                      ],
                     },
                    ],
                    position: (412, 54),
                   },
                  ],
                  position: (412, 39),
                 },
                 then: Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "cpu",
                       position: (413, 16),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "elemAt",
                      position: (413, 22),
                     },
                     arguments: [
                      Variable {
                       identifier: "l",
                       position: (413, 29),
                      },
                      Int {
                       value: 0,
                       position: (413, 31),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "kernel",
                       position: (413, 55),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "elemAt",
                      position: (413, 64),
                     },
                     arguments: [
                      Variable {
                       identifier: "l",
                       position: (413, 71),
                      },
                      Int {
                       value: 1,
                       position: (413, 73),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "abi",
                       position: (413, 76),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "elemAt",
                      position: (413, 82),
                     },
                     arguments: [
                      Variable {
                       identifier: "l",
                       position: (413, 89),
                      },
                      Int {
                       value: 2,
                       position: (413, 91),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (413, 14),
                 },
                 else_: IfThenElse {
                  predicate: BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "elemAt",
                      position: (414, 16),
                     },
                     arguments: [
                      Variable {
                       identifier: "l",
                       position: (414, 23),
                      },
                      Int {
                       value: 2,
                       position: (414, 25),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "mingw32",
                       position: (414, 31),
                      },
                     ],
                    },
                   ],
                   position: (414, 27),
                  },
                  then: Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "cpu",
                        position: (415, 16),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "elemAt",
                       position: (415, 22),
                      },
                      arguments: [
                       Variable {
                        identifier: "l",
                        position: (415, 29),
                       },
                       Int {
                        value: 0,
                        position: (415, 31),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "vendor",
                        position: (415, 34),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "elemAt",
                       position: (415, 43),
                      },
                      arguments: [
                       Variable {
                        identifier: "l",
                        position: (415, 50),
                       },
                       Int {
                        value: 1,
                        position: (415, 52),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "kernel",
                        position: (415, 55),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "windows",
                        position: (415, 65),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (415, 14),
                  },
                  else_: IfThenElse {
                   predicate: BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "elemAt",
                       position: (416, 16),
                      },
                      arguments: [
                       Variable {
                        identifier: "l",
                        position: (416, 23),
                       },
                       Int {
                        value: 2,
                        position: (416, 25),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "wasi",
                        position: (416, 31),
                       },
                      ],
                     },
                    ],
                    position: (416, 27),
                   },
                   then: Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "cpu",
                         position: (417, 16),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "elemAt",
                        position: (417, 22),
                       },
                       arguments: [
                        Variable {
                         identifier: "l",
                         position: (417, 29),
                        },
                        Int {
                         value: 0,
                         position: (417, 31),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "vendor",
                         position: (417, 34),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "elemAt",
                        position: (417, 43),
                       },
                       arguments: [
                        Variable {
                         identifier: "l",
                         position: (417, 50),
                        },
                        Int {
                         value: 1,
                         position: (417, 52),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "kernel",
                         position: (417, 55),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "wasi",
                         position: (417, 65),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (417, 14),
                   },
                   else_: IfThenElse {
                    predicate: BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "elemAt",
                        position: (418, 16),
                       },
                       arguments: [
                        Variable {
                         identifier: "l",
                         position: (418, 23),
                        },
                        Int {
                         value: 2,
                         position: (418, 25),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "redox",
                         position: (418, 31),
                        },
                       ],
                      },
                     ],
                     position: (418, 27),
                    },
                    then: Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "cpu",
                          position: (419, 16),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "elemAt",
                         position: (419, 22),
                        },
                        arguments: [
                         Variable {
                          identifier: "l",
                          position: (419, 29),
                         },
                         Int {
                          value: 0,
                          position: (419, 31),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "vendor",
                          position: (419, 34),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "elemAt",
                         position: (419, 43),
                        },
                        arguments: [
                         Variable {
                          identifier: "l",
                          position: (419, 50),
                         },
                         Int {
                          value: 1,
                          position: (419, 52),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "kernel",
                          position: (419, 55),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "redox",
                          position: (419, 65),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (419, 14),
                    },
                    else_: IfThenElse {
                     predicate: BinaryOperation {
                      operator: EqualTo,
                      operands: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "elemAt",
                         position: (420, 16),
                        },
                        arguments: [
                         Variable {
                          identifier: "l",
                          position: (420, 23),
                         },
                         Int {
                          value: 2,
                          position: (420, 25),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "mmixware",
                          position: (420, 31),
                         },
                        ],
                       },
                      ],
                      position: (420, 27),
                     },
                     then: Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "cpu",
                           position: (421, 16),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "elemAt",
                          position: (421, 22),
                         },
                         arguments: [
                          Variable {
                           identifier: "l",
                           position: (421, 29),
                          },
                          Int {
                           value: 0,
                           position: (421, 31),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "vendor",
                           position: (421, 34),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "elemAt",
                          position: (421, 43),
                         },
                         arguments: [
                          Variable {
                           identifier: "l",
                           position: (421, 50),
                          },
                          Int {
                           value: 1,
                           position: (421, 52),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "kernel",
                           position: (421, 55),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "mmixware",
                           position: (421, 65),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (421, 14),
                     },
                     else_: IfThenElse {
                      predicate: FunctionApplication {
                       function: Variable {
                        identifier: "hasPrefix",
                        position: (422, 15),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "netbsd",
                           position: (422, 26),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "elemAt",
                          position: (422, 35),
                         },
                         arguments: [
                          Variable {
                           identifier: "l",
                           position: (422, 42),
                          },
                          Int {
                           value: 2,
                           position: (422, 44),
                          },
                         ],
                        },
                       ],
                      },
                      then: Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "cpu",
                            position: (423, 16),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "elemAt",
                           position: (423, 22),
                          },
                          arguments: [
                           Variable {
                            identifier: "l",
                            position: (423, 29),
                           },
                           Int {
                            value: 0,
                            position: (423, 31),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "vendor",
                            position: (423, 34),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "elemAt",
                           position: (423, 43),
                          },
                          arguments: [
                           Variable {
                            identifier: "l",
                            position: (423, 50),
                           },
                           Int {
                            value: 1,
                            position: (423, 52),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "kernel",
                            position: (423, 58),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "elemAt",
                           position: (423, 67),
                          },
                          arguments: [
                           Variable {
                            identifier: "l",
                            position: (423, 74),
                           },
                           Int {
                            value: 2,
                            position: (423, 76),
                           },
                          ],
                         },
                        ),
                       ],
                       recursive: false,
                       position: (423, 14),
                      },
                      else_: IfThenElse {
                       predicate: FunctionApplication {
                        function: Variable {
                         identifier: "elem",
                         position: (424, 16),
                        },
                        arguments: [
                         FunctionApplication {
                          function: Variable {
                           identifier: "elemAt",
                           position: (424, 22),
                          },
                          arguments: [
                           Variable {
                            identifier: "l",
                            position: (424, 29),
                           },
                           Int {
                            value: 2,
                            position: (424, 31),
                           },
                          ],
                         },
                         List {
                          elements: [
                           String {
                            parts: [
                             Raw {
                              content: "eabi",
                              position: (424, 36),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "eabihf",
                              position: (424, 43),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "elf",
                              position: (424, 52),
                             },
                            ],
                           },
                          ],
                          position: (424, 34),
                         },
                        ],
                       },
                       then: Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "cpu",
                             position: (425, 16),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "elemAt",
                            position: (425, 22),
                           },
                           arguments: [
                            Variable {
                             identifier: "l",
                             position: (425, 29),
                            },
                            Int {
                             value: 0,
                             position: (425, 31),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "vendor",
                             position: (425, 34),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "unknown",
                             position: (425, 44),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "kernel",
                             position: (425, 54),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "elemAt",
                            position: (425, 63),
                           },
                           arguments: [
                            Variable {
                             identifier: "l",
                             position: (425, 70),
                            },
                            Int {
                             value: 1,
                             position: (425, 72),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "abi",
                             position: (425, 75),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "elemAt",
                            position: (425, 81),
                           },
                           arguments: [
                            Variable {
                             identifier: "l",
                             position: (425, 88),
                            },
                            Int {
                             value: 2,
                             position: (425, 90),
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (425, 14),
                       },
                       else_: IfThenElse {
                        predicate: BinaryOperation {
                         operator: EqualTo,
                         operands: [
                          FunctionApplication {
                           function: Variable {
                            identifier: "elemAt",
                            position: (426, 16),
                           },
                           arguments: [
                            Variable {
                             identifier: "l",
                             position: (426, 23),
                            },
                            Int {
                             value: 2,
                             position: (426, 25),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "ghcjs",
                             position: (426, 31),
                            },
                           ],
                          },
                         ],
                         position: (426, 27),
                        },
                        then: Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "cpu",
                              position: (427, 16),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "elemAt",
                             position: (427, 22),
                            },
                            arguments: [
                             Variable {
                              identifier: "l",
                              position: (427, 29),
                             },
                             Int {
                              value: 0,
                              position: (427, 31),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "vendor",
                              position: (427, 34),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "unknown",
                              position: (427, 44),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "kernel",
                              position: (427, 54),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "elemAt",
                             position: (427, 63),
                            },
                            arguments: [
                             Variable {
                              identifier: "l",
                              position: (427, 70),
                             },
                             Int {
                              value: 2,
                              position: (427, 72),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (427, 14),
                        },
                        else_: IfThenElse {
                         predicate: FunctionApplication {
                          function: Variable {
                           identifier: "hasPrefix",
                           position: (428, 15),
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: "genode",
                              position: (428, 26),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "elemAt",
                             position: (428, 35),
                            },
                            arguments: [
                             Variable {
                              identifier: "l",
                              position: (428, 42),
                             },
                             Int {
                              value: 2,
                              position: (428, 44),
                             },
                            ],
                           },
                          ],
                         },
                         then: Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "cpu",
                               position: (429, 16),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "elemAt",
                              position: (429, 22),
                             },
                             arguments: [
                              Variable {
                               identifier: "l",
                               position: (429, 29),
                              },
                              Int {
                               value: 0,
                               position: (429, 31),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "vendor",
                               position: (429, 34),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "elemAt",
                              position: (429, 43),
                             },
                             arguments: [
                              Variable {
                               identifier: "l",
                               position: (429, 50),
                              },
                              Int {
                               value: 1,
                               position: (429, 52),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "kernel",
                               position: (429, 55),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "elemAt",
                              position: (429, 64),
                             },
                             arguments: [
                              Variable {
                               identifier: "l",
                               position: (429, 71),
                              },
                              Int {
                               value: 2,
                               position: (429, 73),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (429, 14),
                         },
                         else_: FunctionApplication {
                          function: Variable {
                           identifier: "throw",
                           position: (430, 12),
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: "Target specification with 3 components is ambiguous",
                              position: (430, 19),
                             },
                            ],
                           },
                          ],
                         },
                         position: (428, 12),
                        },
                        position: (426, 12),
                       },
                       position: (424, 12),
                      },
                      position: (422, 12),
                     },
                     position: (420, 12),
                    },
                    position: (418, 12),
                   },
                   position: (416, 12),
                  },
                  position: (414, 12),
                 },
                 position: (412, 12),
                },
                position: (410, 7),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Expression {
                  expression: String {
                   parts: [
                    Raw {
                     content: "4",
                     position: (431, 6),
                    },
                   ],
                  },
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "cpu",
                     position: (431, 16),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "elemAt",
                    position: (431, 22),
                   },
                   arguments: [
                    Variable {
                     identifier: "l",
                     position: (431, 29),
                    },
                    Int {
                     value: 0,
                     position: (431, 31),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "vendor",
                     position: (431, 34),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "elemAt",
                    position: (431, 43),
                   },
                   arguments: [
                    Variable {
                     identifier: "l",
                     position: (431, 50),
                    },
                    Int {
                     value: 1,
                     position: (431, 52),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "kernel",
                     position: (431, 55),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "elemAt",
                    position: (431, 64),
                   },
                   arguments: [
                    Variable {
                     identifier: "l",
                     position: (431, 71),
                    },
                    Int {
                     value: 2,
                     position: (431, 73),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "abi",
                     position: (431, 76),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "elemAt",
                    position: (431, 82),
                   },
                   arguments: [
                    Variable {
                     identifier: "l",
                     position: (431, 89),
                    },
                    Int {
                     value: 3,
                     position: (431, 91),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (431, 14),
               },
              ),
             ],
             recursive: false,
             position: (393, 27),
            },
            attribute_path: AttributePath {
             attributes: [
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (432, 7),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "length",
                   position: (432, 17),
                  },
                  arguments: [
                   Variable {
                    identifier: "l",
                    position: (432, 24),
                   },
                  ],
                 },
                ],
               },
              },
             ],
            },
            default: Some(
             FunctionApplication {
              function: Variable {
               identifier: "throw",
               position: (433, 9),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "system string has invalid number of hyphen-separated components",
                  position: (433, 16),
                 },
                ],
               },
              ],
             },
            ),
           },
           position: (393, 24),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "mkSystemFromSkeleton",
             position: (436, 3),
            },
           ],
          },
          Function {
           argument: Some(
            "args",
           ),
           arguments: FunctionArguments {
            arguments: [
             FunctionArgument {
              identifier: "abi",
              default: Some(
               Assert {
                expression: Variable {
                 identifier: "false",
                 position: (442, 44),
                },
                target: Variable {
                 identifier: "null",
                 position: (442, 51),
                },
                position: (442, 37),
               },
              ),
             },
             FunctionArgument {
              identifier: "kernel",
              default: None,
             },
             FunctionArgument {
              identifier: "vendor",
              default: Some(
               Assert {
                expression: Variable {
                 identifier: "false",
                 position: (439, 44),
                },
                target: Variable {
                 identifier: "null",
                 position: (439, 51),
                },
                position: (439, 37),
               },
              ),
             },
             FunctionArgument {
              identifier: "cpu",
              default: None,
             },
            ],
            ellipsis: false,
           },
           definition: LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "getCpu",
                 position: (444, 5),
                },
               ],
              },
              Function {
               argument: Some(
                "name",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: PropertyAccess {
                expression: Variable {
                 identifier: "cpuTypes",
                 position: (444, 23),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Expression {
                   expression: Variable {
                    identifier: "name",
                    position: (444, 34),
                   },
                  },
                 ],
                },
                default: Some(
                 FunctionApplication {
                  function: Variable {
                   identifier: "throw",
                   position: (444, 44),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "Unknown CPU type: ",
                      position: (444, 51),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (444, 71),
                      },
                     },
                    ],
                   },
                  ],
                 },
                ),
               },
               position: (444, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "getVendor",
                 position: (445, 5),
                },
               ],
              },
              Function {
               argument: Some(
                "name",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: PropertyAccess {
                expression: Variable {
                 identifier: "vendors",
                 position: (445, 24),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Expression {
                   expression: Variable {
                    identifier: "name",
                    position: (445, 34),
                   },
                  },
                 ],
                },
                default: Some(
                 FunctionApplication {
                  function: Variable {
                   identifier: "throw",
                   position: (445, 44),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "Unknown vendor: ",
                      position: (445, 51),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (445, 69),
                      },
                     },
                    ],
                   },
                  ],
                 },
                ),
               },
               position: (445, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "getKernel",
                 position: (446, 5),
                },
               ],
              },
              Function {
               argument: Some(
                "name",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: PropertyAccess {
                expression: Variable {
                 identifier: "kernels",
                 position: (446, 24),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Expression {
                   expression: Variable {
                    identifier: "name",
                    position: (446, 34),
                   },
                  },
                 ],
                },
                default: Some(
                 FunctionApplication {
                  function: Variable {
                   identifier: "throw",
                   position: (446, 44),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "Unknown kernel: ",
                      position: (446, 51),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (446, 69),
                      },
                     },
                    ],
                   },
                  ],
                 },
                ),
               },
               position: (446, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "getAbi",
                 position: (447, 5),
                },
               ],
              },
              Function {
               argument: Some(
                "name",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: PropertyAccess {
                expression: Variable {
                 identifier: "abis",
                 position: (447, 27),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Expression {
                   expression: Variable {
                    identifier: "name",
                    position: (447, 34),
                   },
                  },
                 ],
                },
                default: Some(
                 FunctionApplication {
                  function: Variable {
                   identifier: "throw",
                   position: (447, 44),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "Unknown ABI: ",
                      position: (447, 51),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (447, 66),
                      },
                     },
                    ],
                   },
                  ],
                 },
                ),
               },
               position: (447, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "parsed",
                 position: (449, 5),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "cpu",
                    position: (450, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "getCpu",
                   position: (450, 13),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "args",
                     position: (450, 20),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "cpu",
                       position: (450, 25),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "vendor",
                    position: (451, 7),
                   },
                  ],
                 },
                 IfThenElse {
                  predicate: HasProperty {
                   expression: Variable {
                    identifier: "args",
                    position: (452, 17),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "vendor",
                      position: (452, 24),
                     },
                    ],
                   },
                   position: (452, 22),
                  },
                  then: FunctionApplication {
                   function: Variable {
                    identifier: "getVendor",
                    position: (452, 39),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "args",
                      position: (452, 49),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "vendor",
                        position: (452, 54),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                  else_: IfThenElse {
                   predicate: FunctionApplication {
                    function: Variable {
                     identifier: "isDarwin",
                     position: (453, 17),
                    },
                    arguments: [
                     Variable {
                      identifier: "parsed",
                      position: (453, 27),
                     },
                    ],
                   },
                   then: PropertyAccess {
                    expression: Variable {
                     identifier: "vendors",
                     position: (453, 39),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "apple",
                       position: (453, 47),
                      },
                     ],
                    },
                    default: None,
                   },
                   else_: IfThenElse {
                    predicate: FunctionApplication {
                     function: Variable {
                      identifier: "isWindows",
                      position: (454, 17),
                     },
                     arguments: [
                      Variable {
                       identifier: "parsed",
                       position: (454, 27),
                      },
                     ],
                    },
                    then: PropertyAccess {
                     expression: Variable {
                      identifier: "vendors",
                      position: (454, 39),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "pc",
                        position: (454, 47),
                       },
                      ],
                     },
                     default: None,
                    },
                    else_: PropertyAccess {
                     expression: Variable {
                      identifier: "vendors",
                      position: (455, 34),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "unknown",
                        position: (455, 42),
                       },
                      ],
                     },
                     default: None,
                    },
                    position: (454, 14),
                   },
                   position: (453, 14),
                  },
                  position: (452, 14),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "kernel",
                    position: (456, 7),
                   },
                  ],
                 },
                 IfThenElse {
                  predicate: FunctionApplication {
                   function: Variable {
                    identifier: "hasPrefix",
                    position: (456, 19),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "darwin",
                       position: (456, 30),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "args",
                      position: (456, 38),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "kernel",
                        position: (456, 43),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                  then: FunctionApplication {
                   function: Variable {
                    identifier: "getKernel",
                    position: (456, 60),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "darwin",
                       position: (456, 71),
                      },
                     ],
                    },
                   ],
                  },
                  else_: IfThenElse {
                   predicate: FunctionApplication {
                    function: Variable {
                     identifier: "hasPrefix",
                     position: (457, 24),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "netbsd",
                        position: (457, 35),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "args",
                       position: (457, 43),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "kernel",
                         position: (457, 48),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                   then: FunctionApplication {
                    function: Variable {
                     identifier: "getKernel",
                     position: (457, 60),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "netbsd",
                        position: (457, 71),
                       },
                      ],
                     },
                    ],
                   },
                   else_: FunctionApplication {
                    function: Variable {
                     identifier: "getKernel",
                     position: (458, 55),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "args",
                       position: (458, 65),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "kernel",
                         position: (458, 70),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                   position: (457, 21),
                  },
                  position: (456, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "abi",
                    position: (459, 7),
                   },
                  ],
                 },
                 IfThenElse {
                  predicate: HasProperty {
                   expression: Variable {
                    identifier: "args",
                    position: (460, 17),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "abi",
                      position: (460, 24),
                     },
                    ],
                   },
                   position: (460, 22),
                  },
                  then: FunctionApplication {
                   function: Variable {
                    identifier: "getAbi",
                    position: (460, 39),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "args",
                      position: (460, 46),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "abi",
                        position: (460, 51),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                  else_: IfThenElse {
                   predicate: BinaryOperation {
                    operator: LogicalOr,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "isLinux",
                       position: (461, 17),
                      },
                      arguments: [
                       Variable {
                        identifier: "parsed",
                        position: (461, 25),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "isWindows",
                       position: (461, 35),
                      },
                      arguments: [
                       Variable {
                        identifier: "parsed",
                        position: (461, 45),
                       },
                      ],
                     },
                    ],
                    position: (461, 32),
                   },
                   then: IfThenElse {
                    predicate: FunctionApplication {
                     function: Variable {
                      identifier: "isAarch32",
                      position: (462, 14),
                     },
                     arguments: [
                      Variable {
                       identifier: "parsed",
                       position: (462, 24),
                      },
                     ],
                    },
                    then: IfThenElse {
                     predicate: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "lib",
                        position: (463, 16),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "versionAtLeast",
                          position: (463, 20),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "parsed",
                         position: (463, 36),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "cpu",
                           position: (463, 43),
                          },
                          Raw {
                           content: "version",
                           position: (463, 47),
                          },
                         ],
                        },
                        default: Some(
                         String {
                          parts: [
                           Raw {
                            content: "0",
                            position: (463, 59),
                           },
                          ],
                         },
                        ),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "6",
                          position: (463, 64),
                         },
                        ],
                       },
                      ],
                     },
                     then: PropertyAccess {
                      expression: Variable {
                       identifier: "abis",
                       position: (464, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "gnueabihf",
                         position: (464, 23),
                        },
                       ],
                      },
                      default: None,
                     },
                     else_: PropertyAccess {
                      expression: Variable {
                       identifier: "abis",
                       position: (465, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "gnueabi",
                         position: (465, 23),
                        },
                       ],
                      },
                      default: None,
                     },
                     position: (463, 13),
                    },
                    else_: PropertyAccess {
                     expression: Variable {
                      identifier: "abis",
                      position: (466, 16),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "gnu",
                        position: (466, 21),
                       },
                      ],
                     },
                     default: None,
                    },
                    position: (462, 11),
                   },
                   else_: PropertyAccess {
                    expression: Variable {
                     identifier: "abis",
                     position: (467, 34),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "unknown",
                       position: (467, 39),
                      },
                     ],
                    },
                    default: None,
                   },
                   position: (461, 14),
                  },
                  position: (460, 14),
                 },
                ),
               ],
               recursive: false,
               position: (449, 14),
              },
             ),
            ],
            target: FunctionApplication {
             function: Variable {
              identifier: "mkSystem",
              position: (470, 6),
             },
             arguments: [
              Variable {
               identifier: "parsed",
               position: (470, 15),
              },
             ],
            },
            position: (443, 36),
           },
           position: (436, 26),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "mkSystemFromString",
             position: (472, 3),
            },
           ],
          },
          Function {
           argument: Some(
            "s",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "mkSystemFromSkeleton",
             position: (472, 27),
            },
            arguments: [
             FunctionApplication {
              function: Variable {
               identifier: "mkSkeletonFromList",
               position: (472, 49),
              },
              arguments: [
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "lib",
                  position: (472, 69),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "splitString",
                    position: (472, 73),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "-",
                    position: (472, 86),
                   },
                  ],
                 },
                 Variable {
                  identifier: "s",
                  position: (472, 89),
                 },
                ],
               },
              ],
             },
            ],
           },
           position: (472, 24),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "doubleFromSystem",
             position: (474, 3),
            },
           ],
          },
          Function {
           argument: None,
           arguments: FunctionArguments {
            arguments: [
             FunctionArgument {
              identifier: "abi",
              default: None,
             },
             FunctionArgument {
              identifier: "kernel",
              default: None,
             },
             FunctionArgument {
              identifier: "cpu",
              default: None,
             },
            ],
            ellipsis: true,
           },
           definition: IfThenElse {
            predicate: BinaryOperation {
             operator: EqualTo,
             operands: [
              Variable {
               identifier: "abi",
               position: (475, 13),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "abis",
                position: (475, 20),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "cygnus",
                  position: (475, 25),
                 },
                ],
               },
               default: None,
              },
             ],
             position: (475, 17),
            },
            then: String {
             parts: [
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cpu",
                 position: (475, 46),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "name",
                   position: (475, 50),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "-cygwin",
               position: (475, 55),
              },
             ],
            },
            else_: IfThenElse {
             predicate: HasProperty {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "kernel",
                position: (476, 13),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "families",
                  position: (476, 20),
                 },
                ],
               },
               default: None,
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "darwin",
                 position: (476, 31),
                },
               ],
              },
              position: (476, 29),
             },
             then: String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cpu",
                  position: (476, 46),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "name",
                    position: (476, 50),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "-darwin",
                position: (476, 55),
               },
              ],
             },
             else_: String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cpu",
                  position: (477, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "name",
                    position: (477, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "-",
                position: (477, 22),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "kernel",
                  position: (477, 25),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "name",
                    position: (477, 32),
                   },
                  ],
                 },
                 default: None,
                },
               },
              ],
             },
             position: (476, 10),
            },
            position: (475, 10),
           },
           position: (474, 22),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "tripleFromSystem",
             position: (479, 3),
            },
           ],
          },
          Function {
           argument: Some(
            "sys",
           ),
           arguments: FunctionArguments {
            arguments: [
             FunctionArgument {
              identifier: "abi",
              default: None,
             },
             FunctionArgument {
              identifier: "kernel",
              default: None,
             },
             FunctionArgument {
              identifier: "vendor",
              default: None,
             },
             FunctionArgument {
              identifier: "cpu",
              default: None,
             },
            ],
            ellipsis: true,
           },
           definition: Assert {
            expression: FunctionApplication {
             function: Variable {
              identifier: "isSystem",
              position: (479, 70),
             },
             arguments: [
              Variable {
               identifier: "sys",
               position: (479, 79),
              },
             ],
            },
            target: LetIn {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "optExecFormat",
                  position: (480, 5),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "lib",
                  position: (481, 7),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "optionalString",
                    position: (481, 11),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "kernel",
                       position: (481, 27),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "name",
                         position: (481, 34),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [
                       Raw {
                        content: "netbsd",
                        position: (481, 43),
                       },
                      ],
                     },
                    ],
                    position: (481, 39),
                   },
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "gnuNetBSDDefaultExecFormat",
                       position: (482, 27),
                      },
                      arguments: [
                       Variable {
                        identifier: "cpu",
                        position: (482, 54),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "kernel",
                       position: (482, 61),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "execFormat",
                         position: (482, 68),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (482, 58),
                   },
                  ],
                  position: (481, 51),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "kernel",
                   position: (483, 9),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "execFormat",
                     position: (483, 16),
                    },
                    Raw {
                     content: "name",
                     position: (483, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "optAbi",
                  position: (484, 5),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "lib",
                  position: (484, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "optionalString",
                    position: (484, 18),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 BinaryOperation {
                  operator: NotEqualTo,
                  operands: [
                   Variable {
                    identifier: "abi",
                    position: (484, 34),
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "abis",
                     position: (484, 41),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "unknown",
                       position: (484, 46),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                  position: (484, 38),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "-",
                    position: (484, 56),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "abi",
                      position: (484, 59),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "name",
                        position: (484, 63),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             target: String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cpu",
                  position: (485, 9),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "name",
                    position: (485, 13),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "-",
                position: (485, 18),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "vendor",
                  position: (485, 21),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "name",
                    position: (485, 28),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "-",
                position: (485, 33),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "kernel",
                  position: (485, 36),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "name",
                    position: (485, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Expression {
                expression: Variable {
                 identifier: "optExecFormat",
                 position: (485, 50),
                },
               },
               Expression {
                expression: Variable {
                 identifier: "optAbi",
                 position: (485, 66),
                },
               },
              ],
             },
             position: (479, 84),
            },
            position: (479, 63),
           },
           position: (479, 22),
          },
         ),
        ],
        recursive: true,
        position: (34, 1),
       },
       position: (24, 1),
      },
      position: (22, 1),
     },
     position: (21, 1),
    },
    position: (20, 1),
   },
   position: (19, 1),
  },
  position: (18, 1),
 },
 position: (17, 1),
}