---
LetIn {
 bindings: [
  Binding {
   from: AttributePath {
    parts: [
     Raw {
      content: "lib",
      position: (9, 3),
     },
    ],
   },
   to: FunctionApplication {
    function: Variable {
     identifier: "import",
     position: (9, 9),
    },
    arguments: [
     Path {
      parts: [
       Raw {
        content: "../default.nix",
        position: (9, 16),
       },
      ],
      position: (9, 16),
     },
    ],
   },
  },
  Binding {
   from: AttributePath {
    parts: [
     Raw {
      content: "mseteq",
      position: (10, 3),
     },
    ],
   },
   to: Function {
    argument: Simple {
     identifier: "x",
    },
    definition: Function {
     argument: Simple {
      identifier: "y",
     },
     definition: Map {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "expr",
           position: (11, 5),
          },
         ],
        },
        to: FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (11, 16),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "sort",
             position: (11, 20),
            },
           ],
          },
          default: None,
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (11, 25),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "lessThan",
              position: (11, 29),
             },
            ],
           },
           default: None,
          },
          Variable {
           identifier: "x",
           position: (11, 38),
          },
         ],
        },
       },
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "expected",
           position: (12, 5),
          },
         ],
        },
        to: FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (12, 16),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "sort",
             position: (12, 20),
            },
           ],
          },
          default: None,
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (12, 25),
           },
           attribute_path: AttributePath {
            parts: [
             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 {
    parts: [
     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 {
     parts: [
      Raw {
       content: "runTests",
       position: (15, 31),
      },
     ],
    },
    default: None,
   },
   arguments: [
    Map {
     bindings: [
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testall",
          position: (16, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (16, 13),
        },
        arguments: [
         Variable {
          identifier: "all",
          position: (16, 20),
         },
         Parentheses {
          expression: 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),
          },
          position: (16, 24),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testarm",
          position: (18, 3),
         },
        ],
       },
       to: 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),
             },
            ],
            position: (18, 26),
           },
           String {
            parts: [
             Raw {
              content: "armv6l-linux",
              position: (18, 44),
             },
            ],
            position: (18, 43),
           },
           String {
            parts: [
             Raw {
              content: "armv6l-netbsd",
              position: (18, 59),
             },
            ],
            position: (18, 58),
           },
           String {
            parts: [
             Raw {
              content: "armv6l-none",
              position: (18, 75),
             },
            ],
            position: (18, 74),
           },
           String {
            parts: [
             Raw {
              content: "armv7a-linux",
              position: (18, 89),
             },
            ],
            position: (18, 88),
           },
           String {
            parts: [
             Raw {
              content: "armv7a-netbsd",
              position: (18, 104),
             },
            ],
            position: (18, 103),
           },
           String {
            parts: [
             Raw {
              content: "armv7l-linux",
              position: (18, 120),
             },
            ],
            position: (18, 119),
           },
           String {
            parts: [
             Raw {
              content: "armv7l-netbsd",
              position: (18, 135),
             },
            ],
            position: (18, 134),
           },
           String {
            parts: [
             Raw {
              content: "arm-none",
              position: (18, 151),
             },
            ],
            position: (18, 150),
           },
           String {
            parts: [
             Raw {
              content: "armv7a-darwin",
              position: (18, 162),
             },
            ],
            position: (18, 161),
           },
          ],
          position: (18, 24),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testi686",
          position: (19, 3),
         },
        ],
       },
       to: 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),
             },
            ],
            position: (19, 28),
           },
           String {
            parts: [
             Raw {
              content: "i686-freebsd",
              position: (19, 42),
             },
            ],
            position: (19, 41),
           },
           String {
            parts: [
             Raw {
              content: "i686-genode",
              position: (19, 57),
             },
            ],
            position: (19, 56),
           },
           String {
            parts: [
             Raw {
              content: "i686-netbsd",
              position: (19, 71),
             },
            ],
            position: (19, 70),
           },
           String {
            parts: [
             Raw {
              content: "i686-openbsd",
              position: (19, 85),
             },
            ],
            position: (19, 84),
           },
           String {
            parts: [
             Raw {
              content: "i686-cygwin",
              position: (19, 100),
             },
            ],
            position: (19, 99),
           },
           String {
            parts: [
             Raw {
              content: "i686-windows",
              position: (19, 114),
             },
            ],
            position: (19, 113),
           },
           String {
            parts: [
             Raw {
              content: "i686-none",
              position: (19, 129),
             },
            ],
            position: (19, 128),
           },
           String {
            parts: [
             Raw {
              content: "i686-darwin",
              position: (19, 141),
             },
            ],
            position: (19, 140),
           },
          ],
          position: (19, 26),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testmips",
          position: (20, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (20, 14),
        },
        arguments: [
         Variable {
          identifier: "mips",
          position: (20, 21),
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "mips64el-linux",
              position: (20, 29),
             },
            ],
            position: (20, 28),
           },
           String {
            parts: [
             Raw {
              content: "mipsel-linux",
              position: (20, 46),
             },
            ],
            position: (20, 45),
           },
           String {
            parts: [
             Raw {
              content: "mipsel-netbsd",
              position: (20, 61),
             },
            ],
            position: (20, 60),
           },
          ],
          position: (20, 26),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testmmix",
          position: (21, 3),
         },
        ],
       },
       to: 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, 28),
           },
          ],
          position: (21, 26),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testx86_64",
          position: (22, 3),
         },
        ],
       },
       to: 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),
             },
            ],
            position: (22, 32),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-darwin",
              position: (22, 48),
             },
            ],
            position: (22, 47),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-freebsd",
              position: (22, 64),
             },
            ],
            position: (22, 63),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-genode",
              position: (22, 81),
             },
            ],
            position: (22, 80),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-redox",
              position: (22, 97),
             },
            ],
            position: (22, 96),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-openbsd",
              position: (22, 112),
             },
            ],
            position: (22, 111),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-netbsd",
              position: (22, 129),
             },
            ],
            position: (22, 128),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-cygwin",
              position: (22, 145),
             },
            ],
            position: (22, 144),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-solaris",
              position: (22, 161),
             },
            ],
            position: (22, 160),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-windows",
              position: (22, 178),
             },
            ],
            position: (22, 177),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-none",
              position: (22, 195),
             },
            ],
            position: (22, 194),
           },
          ],
          position: (22, 30),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testcygwin",
          position: (24, 3),
         },
        ],
       },
       to: 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),
             },
            ],
            position: (24, 32),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-cygwin",
              position: (24, 47),
             },
            ],
            position: (24, 46),
           },
          ],
          position: (24, 30),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testdarwin",
          position: (25, 3),
         },
        ],
       },
       to: 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),
             },
            ],
            position: (25, 32),
           },
           String {
            parts: [
             Raw {
              content: "i686-darwin",
              position: (25, 49),
             },
            ],
            position: (25, 48),
           },
           String {
            parts: [
             Raw {
              content: "aarch64-darwin",
              position: (25, 63),
             },
            ],
            position: (25, 62),
           },
           String {
            parts: [
             Raw {
              content: "armv7a-darwin",
              position: (25, 80),
             },
            ],
            position: (25, 79),
           },
          ],
          position: (25, 30),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testfreebsd",
          position: (26, 3),
         },
        ],
       },
       to: 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),
             },
            ],
            position: (26, 34),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-freebsd",
              position: (26, 50),
             },
            ],
            position: (26, 49),
           },
          ],
          position: (26, 32),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testgenode",
          position: (27, 3),
         },
        ],
       },
       to: 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),
             },
            ],
            position: (27, 32),
           },
           String {
            parts: [
             Raw {
              content: "i686-genode",
              position: (27, 50),
             },
            ],
            position: (27, 49),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-genode",
              position: (27, 64),
             },
            ],
            position: (27, 63),
           },
          ],
          position: (27, 30),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testredox",
          position: (28, 3),
         },
        ],
       },
       to: 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, 30),
           },
          ],
          position: (28, 28),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testgnu",
          position: (29, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (29, 13),
        },
        arguments: [
         Variable {
          identifier: "gnu",
          position: (29, 20),
         },
         Parentheses {
          expression: Variable {
           identifier: "linux",
           position: (29, 25),
          },
          position: (29, 24),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testillumos",
          position: (30, 3),
         },
        ],
       },
       to: 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, 34),
           },
          ],
          position: (30, 32),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testlinux",
          position: (31, 3),
         },
        ],
       },
       to: 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),
             },
            ],
            position: (31, 30),
           },
           String {
            parts: [
             Raw {
              content: "armv5tel-linux",
              position: (31, 47),
             },
            ],
            position: (31, 46),
           },
           String {
            parts: [
             Raw {
              content: "armv6l-linux",
              position: (31, 64),
             },
            ],
            position: (31, 63),
           },
           String {
            parts: [
             Raw {
              content: "armv7a-linux",
              position: (31, 79),
             },
            ],
            position: (31, 78),
           },
           String {
            parts: [
             Raw {
              content: "armv7l-linux",
              position: (31, 94),
             },
            ],
            position: (31, 93),
           },
           String {
            parts: [
             Raw {
              content: "i686-linux",
              position: (31, 109),
             },
            ],
            position: (31, 108),
           },
           String {
            parts: [
             Raw {
              content: "mips64el-linux",
              position: (31, 122),
             },
            ],
            position: (31, 121),
           },
           String {
            parts: [
             Raw {
              content: "mipsel-linux",
              position: (31, 139),
             },
            ],
            position: (31, 138),
           },
           String {
            parts: [
             Raw {
              content: "riscv32-linux",
              position: (31, 154),
             },
            ],
            position: (31, 153),
           },
           String {
            parts: [
             Raw {
              content: "riscv64-linux",
              position: (31, 170),
             },
            ],
            position: (31, 169),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-linux",
              position: (31, 186),
             },
            ],
            position: (31, 185),
           },
           String {
            parts: [
             Raw {
              content: "powerpc64-linux",
              position: (31, 201),
             },
            ],
            position: (31, 200),
           },
           String {
            parts: [
             Raw {
              content: "powerpc64le-linux",
              position: (31, 219),
             },
            ],
            position: (31, 218),
           },
           String {
            parts: [
             Raw {
              content: "m68k-linux",
              position: (31, 239),
             },
            ],
            position: (31, 238),
           },
           String {
            parts: [
             Raw {
              content: "s390-linux",
              position: (31, 252),
             },
            ],
            position: (31, 251),
           },
           String {
            parts: [
             Raw {
              content: "s390x-linux",
              position: (31, 265),
             },
            ],
            position: (31, 264),
           },
          ],
          position: (31, 28),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testnetbsd",
          position: (32, 3),
         },
        ],
       },
       to: 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),
             },
            ],
            position: (32, 32),
           },
           String {
            parts: [
             Raw {
              content: "armv6l-netbsd",
              position: (32, 50),
             },
            ],
            position: (32, 49),
           },
           String {
            parts: [
             Raw {
              content: "armv7a-netbsd",
              position: (32, 66),
             },
            ],
            position: (32, 65),
           },
           String {
            parts: [
             Raw {
              content: "armv7l-netbsd",
              position: (32, 82),
             },
            ],
            position: (32, 81),
           },
           String {
            parts: [
             Raw {
              content: "i686-netbsd",
              position: (32, 98),
             },
            ],
            position: (32, 97),
           },
           String {
            parts: [
             Raw {
              content: "m68k-netbsd",
              position: (32, 112),
             },
            ],
            position: (32, 111),
           },
           String {
            parts: [
             Raw {
              content: "mipsel-netbsd",
              position: (32, 126),
             },
            ],
            position: (32, 125),
           },
           String {
            parts: [
             Raw {
              content: "powerpc-netbsd",
              position: (32, 142),
             },
            ],
            position: (32, 141),
           },
           String {
            parts: [
             Raw {
              content: "riscv32-netbsd",
              position: (32, 159),
             },
            ],
            position: (32, 158),
           },
           String {
            parts: [
             Raw {
              content: "riscv64-netbsd",
              position: (32, 176),
             },
            ],
            position: (32, 175),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-netbsd",
              position: (32, 193),
             },
            ],
            position: (32, 192),
           },
          ],
          position: (32, 30),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testopenbsd",
          position: (33, 3),
         },
        ],
       },
       to: 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),
             },
            ],
            position: (33, 34),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-openbsd",
              position: (33, 50),
             },
            ],
            position: (33, 49),
           },
          ],
          position: (33, 32),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testwindows",
          position: (34, 3),
         },
        ],
       },
       to: 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),
             },
            ],
            position: (34, 34),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-cygwin",
              position: (34, 49),
             },
            ],
            position: (34, 48),
           },
           String {
            parts: [
             Raw {
              content: "i686-windows",
              position: (34, 65),
             },
            ],
            position: (34, 64),
           },
           String {
            parts: [
             Raw {
              content: "x86_64-windows",
              position: (34, 80),
             },
            ],
            position: (34, 79),
           },
          ],
          position: (34, 32),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "testunix",
          position: (35, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "mseteq",
         position: (35, 14),
        },
        arguments: [
         Variable {
          identifier: "unix",
          position: (35, 21),
         },
         Parentheses {
          expression: 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),
          },
          position: (35, 26),
         },
        ],
       },
      },
     ],
     recursive: false,
     position: (15, 40),
    },
   ],
  },
  position: (15, 1),
 },
 position: (8, 1),
}