---
LetIn {
 bindings: [
  KeyValue(
   AttributePath {
    attributes: [
     Raw {
      content: "lib",
      position: (9, 3),
     },
    ],
   },
   FunctionApplication {
    function: Variable {
     identifier: "import",
     position: (9, 9),
    },
    arguments: [
     Path {
      parts: [
       Raw {
        content: "../default.nix",
        position: (9, 16),
       },
      ],
     },
    ],
   },
  ),
  KeyValue(
   AttributePath {
    attributes: [
     Raw {
      content: "mseteq",
      position: (10, 3),
     },
    ],
   },
   Function {
    argument: Some(
     "x",
    ),
    arguments: FunctionArguments {
     arguments: [],
     ellipsis: false,
    },
    definition: Function {
     argument: Some(
      "y",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "expr",
           position: (11, 5),
          },
         ],
        },
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (11, 16),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "sort",
             position: (11, 20),
            },
           ],
          },
          default: None,
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (11, 25),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "lessThan",
              position: (11, 29),
             },
            ],
           },
           default: None,
          },
          Variable {
           identifier: "x",
           position: (11, 38),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "expected",
           position: (12, 5),
          },
         ],
        },
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (12, 16),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "sort",
             position: (12, 20),
            },
           ],
          },
          default: None,
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (12, 25),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "lessThan",
              position: (12, 29),
             },
            ],
           },
           default: None,
          },
          Variable {
           identifier: "y",
           position: (12, 38),
          },
         ],
        },
       ),
      ],
      recursive: false,
      position: (10, 18),
     },
     position: (10, 15),
    },
    position: (10, 12),
   },
  ),
 ],
 target: With {
  expression: PropertyAccess {
   expression: Variable {
    identifier: "lib",
    position: (15, 6),
   },
   attribute_path: AttributePath {
    attributes: [
     Raw {
      content: "systems",
      position: (15, 10),
     },
     Raw {
      content: "doubles",
      position: (15, 18),
     },
    ],
   },
   default: None,
  },
  target: FunctionApplication {
   function: PropertyAccess {
    expression: Variable {
     identifier: "lib",
     position: (15, 27),
    },
    attribute_path: AttributePath {
     attributes: [
      Raw {
       content: "runTests",
       position: (15, 31),
      },
     ],
    },
    default: None,
   },
   arguments: [
    Map {
     bindings: [
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testall",
          position: (16, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (16, 13),
        },
        arguments: [
         Variable {
          identifier: "all",
          position: (16, 20),
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           Variable {
            identifier: "linux",
            position: (16, 25),
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             Variable {
              identifier: "darwin",
              position: (16, 34),
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               Variable {
                identifier: "freebsd",
                position: (16, 44),
               },
               BinaryOperation {
                operator: Concatenation,
                operands: [
                 Variable {
                  identifier: "openbsd",
                  position: (16, 55),
                 },
                 BinaryOperation {
                  operator: Concatenation,
                  operands: [
                   Variable {
                    identifier: "netbsd",
                    position: (16, 66),
                   },
                   BinaryOperation {
                    operator: Concatenation,
                    operands: [
                     Variable {
                      identifier: "illumos",
                      position: (16, 76),
                     },
                     BinaryOperation {
                      operator: Concatenation,
                      operands: [
                       Variable {
                        identifier: "wasi",
                        position: (16, 87),
                       },
                       BinaryOperation {
                        operator: Concatenation,
                        operands: [
                         Variable {
                          identifier: "windows",
                          position: (16, 95),
                         },
                         BinaryOperation {
                          operator: Concatenation,
                          operands: [
                           Variable {
                            identifier: "embedded",
                            position: (16, 106),
                           },
                           BinaryOperation {
                            operator: Concatenation,
                            operands: [
                             Variable {
                              identifier: "mmix",
                              position: (16, 118),
                             },
                             BinaryOperation {
                              operator: Concatenation,
                              operands: [
                               Variable {
                                identifier: "js",
                                position: (16, 126),
                               },
                               BinaryOperation {
                                operator: Concatenation,
                                operands: [
                                 Variable {
                                  identifier: "genode",
                                  position: (16, 132),
                                 },
                                 Variable {
                                  identifier: "redox",
                                  position: (16, 142),
                                 },
                                ],
                                position: (16, 139),
                               },
                              ],
                              position: (16, 129),
                             },
                            ],
                            position: (16, 123),
                           },
                          ],
                          position: (16, 115),
                         },
                        ],
                        position: (16, 103),
                       },
                      ],
                      position: (16, 92),
                     },
                    ],
                    position: (16, 84),
                   },
                  ],
                  position: (16, 73),
                 },
                ],
                position: (16, 63),
               },
              ],
              position: (16, 52),
             },
            ],
            position: (16, 41),
           },
          ],
          position: (16, 31),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testarm",
          position: (18, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (18, 13),
        },
        arguments: [
         Variable {
          identifier: "arm",
          position: (18, 20),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "armv5tel-linux",
              position: (18, 27),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv6l-linux",
              position: (18, 44),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv6l-netbsd",
              position: (18, 59),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv6l-none",
              position: (18, 75),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv7a-linux",
              position: (18, 89),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv7a-netbsd",
              position: (18, 104),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv7l-linux",
              position: (18, 120),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv7l-netbsd",
              position: (18, 135),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "arm-none",
              position: (18, 151),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv7a-darwin",
              position: (18, 162),
             },
            ],
           },
          ],
          position: (18, 24),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testi686",
          position: (19, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (19, 14),
        },
        arguments: [
         Variable {
          identifier: "i686",
          position: (19, 21),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "i686-linux",
              position: (19, 29),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-freebsd",
              position: (19, 42),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-genode",
              position: (19, 57),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-netbsd",
              position: (19, 71),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-openbsd",
              position: (19, 85),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-cygwin",
              position: (19, 100),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-windows",
              position: (19, 114),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-none",
              position: (19, 129),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-darwin",
              position: (19, 141),
             },
            ],
           },
          ],
          position: (19, 26),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testmips",
          position: (20, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (20, 14),
        },
        arguments: [
         Variable {
          identifier: "mips",
          position: (20, 21),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "mipsel-linux",
              position: (20, 29),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "mipsel-netbsd",
              position: (20, 44),
             },
            ],
           },
          ],
          position: (20, 26),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testmmix",
          position: (21, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (21, 14),
        },
        arguments: [
         Variable {
          identifier: "mmix",
          position: (21, 21),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "mmix-mmixware",
              position: (21, 29),
             },
            ],
           },
          ],
          position: (21, 26),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testx86_64",
          position: (22, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (22, 16),
        },
        arguments: [
         Variable {
          identifier: "x86_64",
          position: (22, 23),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "x86_64-linux",
              position: (22, 33),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-darwin",
              position: (22, 48),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-freebsd",
              position: (22, 64),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-genode",
              position: (22, 81),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-redox",
              position: (22, 97),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-openbsd",
              position: (22, 112),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-netbsd",
              position: (22, 129),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-cygwin",
              position: (22, 145),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-solaris",
              position: (22, 161),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-windows",
              position: (22, 178),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-none",
              position: (22, 195),
             },
            ],
           },
          ],
          position: (22, 30),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testcygwin",
          position: (24, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (24, 16),
        },
        arguments: [
         Variable {
          identifier: "cygwin",
          position: (24, 23),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "i686-cygwin",
              position: (24, 33),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-cygwin",
              position: (24, 47),
             },
            ],
           },
          ],
          position: (24, 30),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testdarwin",
          position: (25, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (25, 16),
        },
        arguments: [
         Variable {
          identifier: "darwin",
          position: (25, 23),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "x86_64-darwin",
              position: (25, 33),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-darwin",
              position: (25, 49),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "aarch64-darwin",
              position: (25, 63),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv7a-darwin",
              position: (25, 80),
             },
            ],
           },
          ],
          position: (25, 30),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testfreebsd",
          position: (26, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (26, 17),
        },
        arguments: [
         Variable {
          identifier: "freebsd",
          position: (26, 24),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "i686-freebsd",
              position: (26, 35),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-freebsd",
              position: (26, 50),
             },
            ],
           },
          ],
          position: (26, 32),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testgenode",
          position: (27, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (27, 16),
        },
        arguments: [
         Variable {
          identifier: "genode",
          position: (27, 23),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "aarch64-genode",
              position: (27, 33),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-genode",
              position: (27, 50),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-genode",
              position: (27, 64),
             },
            ],
           },
          ],
          position: (27, 30),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testredox",
          position: (28, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (28, 15),
        },
        arguments: [
         Variable {
          identifier: "redox",
          position: (28, 22),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "x86_64-redox",
              position: (28, 31),
             },
            ],
           },
          ],
          position: (28, 28),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testgnu",
          position: (29, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (29, 13),
        },
        arguments: [
         Variable {
          identifier: "gnu",
          position: (29, 20),
         },
         Variable {
          identifier: "linux",
          position: (29, 25),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testillumos",
          position: (30, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (30, 17),
        },
        arguments: [
         Variable {
          identifier: "illumos",
          position: (30, 24),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "x86_64-solaris",
              position: (30, 35),
             },
            ],
           },
          ],
          position: (30, 32),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testlinux",
          position: (31, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (31, 15),
        },
        arguments: [
         Variable {
          identifier: "linux",
          position: (31, 22),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "aarch64-linux",
              position: (31, 31),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv5tel-linux",
              position: (31, 47),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv6l-linux",
              position: (31, 64),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv7a-linux",
              position: (31, 79),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv7l-linux",
              position: (31, 94),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-linux",
              position: (31, 109),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "mipsel-linux",
              position: (31, 122),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "riscv32-linux",
              position: (31, 137),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "riscv64-linux",
              position: (31, 153),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-linux",
              position: (31, 169),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "powerpc64-linux",
              position: (31, 184),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "powerpc64le-linux",
              position: (31, 202),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "m68k-linux",
              position: (31, 222),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "s390-linux",
              position: (31, 235),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "s390x-linux",
              position: (31, 248),
             },
            ],
           },
          ],
          position: (31, 28),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testnetbsd",
          position: (32, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (32, 16),
        },
        arguments: [
         Variable {
          identifier: "netbsd",
          position: (32, 23),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "aarch64-netbsd",
              position: (32, 33),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv6l-netbsd",
              position: (32, 50),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv7a-netbsd",
              position: (32, 66),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "armv7l-netbsd",
              position: (32, 82),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-netbsd",
              position: (32, 98),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "m68k-netbsd",
              position: (32, 112),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "mipsel-netbsd",
              position: (32, 126),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "powerpc-netbsd",
              position: (32, 142),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "riscv32-netbsd",
              position: (32, 159),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "riscv64-netbsd",
              position: (32, 176),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-netbsd",
              position: (32, 193),
             },
            ],
           },
          ],
          position: (32, 30),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testopenbsd",
          position: (33, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (33, 17),
        },
        arguments: [
         Variable {
          identifier: "openbsd",
          position: (33, 24),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "i686-openbsd",
              position: (33, 35),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-openbsd",
              position: (33, 50),
             },
            ],
           },
          ],
          position: (33, 32),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testwindows",
          position: (34, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (34, 17),
        },
        arguments: [
         Variable {
          identifier: "windows",
          position: (34, 24),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "i686-cygwin",
              position: (34, 35),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-cygwin",
              position: (34, 49),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "i686-windows",
              position: (34, 65),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "x86_64-windows",
              position: (34, 80),
             },
            ],
           },
          ],
          position: (34, 32),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "testunix",
          position: (35, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (35, 14),
        },
        arguments: [
         Variable {
          identifier: "unix",
          position: (35, 21),
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           Variable {
            identifier: "linux",
            position: (35, 27),
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             Variable {
              identifier: "darwin",
              position: (35, 36),
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               Variable {
                identifier: "freebsd",
                position: (35, 46),
               },
               BinaryOperation {
                operator: Concatenation,
                operands: [
                 Variable {
                  identifier: "openbsd",
                  position: (35, 57),
                 },
                 BinaryOperation {
                  operator: Concatenation,
                  operands: [
                   Variable {
                    identifier: "netbsd",
                    position: (35, 68),
                   },
                   BinaryOperation {
                    operator: Concatenation,
                    operands: [
                     Variable {
                      identifier: "illumos",
                      position: (35, 78),
                     },
                     BinaryOperation {
                      operator: Concatenation,
                      operands: [
                       Variable {
                        identifier: "cygwin",
                        position: (35, 89),
                       },
                       Variable {
                        identifier: "redox",
                        position: (35, 99),
                       },
                      ],
                      position: (35, 96),
                     },
                    ],
                    position: (35, 86),
                   },
                  ],
                  position: (35, 75),
                 },
                ],
                position: (35, 65),
               },
              ],
              position: (35, 54),
             },
            ],
            position: (35, 43),
           },
          ],
          position: (35, 33),
         },
        ],
       },
      ),
     ],
     recursive: false,
     position: (15, 40),
    },
   ],
  },
  position: (15, 1),
 },
 position: (8, 1),
}