---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (7, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "menuBuilderGrub2",
        position: (18, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "defaults",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "options",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "lib",
          position: (19, 22),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "concatStrings",
            position: (19, 26),
           },
          ],
         },
         default: None,
        },
        arguments: [
         FunctionApplication {
          function: Variable {
           identifier: "map",
           position: (21, 7),
          },
          arguments: [
           Function {
            argument: Some(
             "option",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: String {
             parts: [
              Raw {
               content: "menuentry ",
               position: (23, 1),
              },
              Raw {
               content: "'",
               position: (23, 19),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "defaults",
                 position: (23, 22),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "name",
                   position: (23, 31),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: " ",
               position: (23, 36),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "option",
                 position: (25, 9),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "name",
                   position: (25, 16),
                  },
                 ],
                },
                default: Some(
                 IfThenElse {
                  predicate: HasProperty {
                   expression: Variable {
                    identifier: "option",
                    position: (25, 28),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "params",
                      position: (25, 37),
                     },
                    ],
                   },
                   position: (25, 35),
                  },
                  then: String {
                   parts: [
                    Raw {
                     content: "(",
                     position: (25, 50),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "option",
                       position: (25, 53),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "params",
                         position: (25, 60),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: ")",
                     position: (25, 67),
                    },
                   ],
                  },
                  else_: String {
                   parts: [],
                  },
                  position: (25, 25),
                 },
                ),
               },
              },
              Raw {
               content: "' ",
               position: (26, 10),
              },
              Expression {
               expression: IfThenElse {
                predicate: HasProperty {
                 expression: Variable {
                  identifier: "option",
                  position: (26, 17),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "class",
                    position: (26, 26),
                   },
                  ],
                 },
                 position: (26, 24),
                },
                then: String {
                 parts: [
                  Raw {
                   content: " --class ",
                   position: (26, 38),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "option",
                     position: (26, 49),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "class",
                       position: (26, 56),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                 ],
                },
                else_: String {
                 parts: [],
                },
                position: (26, 14),
               },
              },
              Raw {
               content: " {\n  linux ",
               position: (26, 72),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "defaults",
                 position: (27, 19),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "image",
                   position: (27, 28),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: " \\",
               position: (27, 34),
              },
              Raw {
               content: "$",
               position: (27, 36),
              },
              Raw {
               content: "{isoboot} ",
               position: (27, 39),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "defaults",
                 position: (27, 51),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "params",
                   position: (27, 60),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: " ",
               position: (27, 67),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "option",
                 position: (28, 13),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "params",
                   position: (28, 20),
                  },
                 ],
                },
                default: Some(
                 String {
                  parts: [],
                 },
                ),
               },
              },
              Raw {
               content: "\n  initrd ",
               position: (29, 12),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "defaults",
                 position: (30, 20),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "initrd",
                   position: (30, 29),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\n}\n",
               position: (30, 36),
              },
             ],
            },
            position: (22, 8),
           },
           Variable {
            identifier: "options",
            position: (33, 7),
           },
          ],
         },
        ],
       },
       position: (19, 13),
      },
      position: (19, 3),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "buildMenuGrub2",
        position: (40, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "config",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "buildMenuAdditionalParamsGrub2",
        position: (41, 5),
       },
       arguments: [
        Variable {
         identifier: "config",
         position: (41, 36),
        },
        String {
         parts: [],
        },
       ],
      },
      position: (40, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "buildMenuAdditionalParamsGrub2",
        position: (48, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "config",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "additional",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "finalCfg",
             position: (50, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "name",
                position: (51, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "NixOS ",
                position: (51, 15),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (51, 23),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "system",
                    position: (51, 30),
                   },
                   Raw {
                    content: "nixos",
                    position: (51, 37),
                   },
                   Raw {
                    content: "label",
                    position: (51, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (51, 51),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "isoImage",
                    position: (51, 58),
                   },
                   Raw {
                    content: "appendToMenuLabel",
                    position: (51, 67),
                   },
                  ],
                 },
                 default: None,
                },
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "params",
                position: (52, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "init=",
                position: (52, 17),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (52, 24),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "system",
                    position: (52, 31),
                   },
                   Raw {
                    content: "build",
                    position: (52, 38),
                   },
                   Raw {
                    content: "toplevel",
                    position: (52, 44),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/init ",
                position: (52, 53),
               },
               Expression {
                expression: Variable {
                 identifier: "additional",
                 position: (52, 61),
                },
               },
               Raw {
                content: " ",
                position: (52, 72),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "toString",
                  position: (52, 75),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (52, 84),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "boot",
                      position: (52, 91),
                     },
                     Raw {
                      content: "kernelParams",
                      position: (52, 96),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "image",
                position: (53, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "/boot/",
                position: (53, 16),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (53, 24),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "system",
                    position: (53, 31),
                   },
                   Raw {
                    content: "boot",
                    position: (53, 38),
                   },
                   Raw {
                    content: "loader",
                    position: (53, 43),
                   },
                   Raw {
                    content: "kernelFile",
                    position: (53, 50),
                   },
                  ],
                 },
                 default: None,
                },
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "initrd",
                position: (54, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "/boot/initrd",
                position: (54, 17),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (50, 16),
          },
         ),
        ],
        target: FunctionApplication {
         function: Variable {
          identifier: "menuBuilderGrub2",
          position: (57, 5),
         },
         arguments: [
          Variable {
           identifier: "finalCfg",
           position: (58, 5),
          },
          List {
           elements: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "class",
                  position: (60, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "installer",
                  position: (60, 18),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (60, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "class",
                  position: (61, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "nomodeset",
                  position: (61, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "params",
                  position: (61, 30),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "nomodeset",
                  position: (61, 40),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (61, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "class",
                  position: (62, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "copytoram",
                  position: (62, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "params",
                  position: (62, 30),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "copytoram",
                  position: (62, 40),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (62, 7),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "class",
                  position: (63, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "debug",
                  position: (63, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "params",
                  position: (63, 30),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "debug",
                  position: (63, 40),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (63, 7),
            },
           ],
           position: (59, 5),
          },
         ],
        },
        position: (49, 3),
       },
       position: (48, 44),
      },
      position: (48, 36),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "syslinuxTimeout",
        position: (69, 3),
       },
      ],
     },
     IfThenElse {
      predicate: BinaryOperation {
       operator: EqualTo,
       operands: [
        PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (69, 24),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (69, 31),
           },
           Raw {
            content: "loader",
            position: (69, 36),
           },
           Raw {
            content: "timeout",
            position: (69, 43),
           },
          ],
         },
         default: None,
        },
        Variable {
         identifier: "null",
         position: (69, 54),
        },
       ],
       position: (69, 51),
      },
      then: Int {
       value: 0,
       position: (70, 7),
      },
      else_: FunctionApplication {
       function: Variable {
        identifier: "max",
        position: (72, 7),
       },
       arguments: [
        BinaryOperation {
         operator: Multiplication,
         operands: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (72, 12),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "boot",
              position: (72, 19),
             },
             Raw {
              content: "loader",
              position: (72, 24),
             },
             Raw {
              content: "timeout",
              position: (72, 31),
             },
            ],
           },
           default: None,
          },
          Int {
           value: 10,
           position: (72, 41),
          },
         ],
         position: (72, 39),
        },
        Int {
         value: 1,
         position: (72, 45),
        },
       ],
      },
      position: (69, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "max",
        position: (75, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "x",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "y",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: IfThenElse {
        predicate: BinaryOperation {
         operator: GreaterThan,
         operands: [
          Variable {
           identifier: "x",
           position: (75, 18),
          },
          Variable {
           identifier: "y",
           position: (75, 22),
          },
         ],
         position: (75, 20),
        },
        then: Variable {
         identifier: "x",
         position: (75, 29),
        },
        else_: Variable {
         identifier: "y",
         position: (75, 36),
        },
        position: (75, 15),
       },
       position: (75, 12),
      },
      position: (75, 9),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "baseIsolinuxCfg",
        position: (90, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "SERIAL 0 115200\nTIMEOUT ",
        position: (91, 1),
       },
       Expression {
        expression: FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "builtins",
           position: (92, 15),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "toString",
             position: (92, 24),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Variable {
           identifier: "syslinuxTimeout",
           position: (92, 33),
          },
         ],
        },
       },
       Raw {
        content: "\nUI vesamenu.c32\nMENU TITLE NixOS\nMENU BACKGROUND /isolinux/background.png\nMENU RESOLUTION 800 600\nMENU CLEAR\nMENU ROWS 6\nMENU CMDLINEROW -4\nMENU TIMEOUTROW -3\nMENU TABMSGROW  -2\nMENU HELPMSGROW -1\nMENU HELPMSGENDROW -1\nMENU MARGIN 0\n\n#                                FG:AARRGGBB  BG:AARRGGBB   shadow\nMENU COLOR BORDER       30;44      #00000000    #00000000   none\nMENU COLOR SCREEN       37;40      #FF000000    #00E2E8FF   none\nMENU COLOR TABMSG       31;40      #80000000    #00000000   none\nMENU COLOR TIMEOUT      1;37;40    #FF000000    #00000000   none\nMENU COLOR TIMEOUT_MSG  37;40      #FF000000    #00000000   none\nMENU COLOR CMDMARK      1;36;40    #FF000000    #00000000   none\nMENU COLOR CMDLINE      37;40      #FF000000    #00000000   none\nMENU COLOR TITLE        1;36;44    #00000000    #00000000   none\nMENU COLOR UNSEL        37;44      #FF000000    #00000000   none\nMENU COLOR SEL          7;37;40    #FFFFFFFF    #FF5277C3   std\n\nDEFAULT boot\n\nLABEL boot\nMENU LABEL NixOS ",
        position: (92, 49),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (121, 24),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (121, 31),
           },
           Raw {
            content: "nixos",
            position: (121, 38),
           },
           Raw {
            content: "label",
            position: (121, 44),
           },
          ],
         },
         default: None,
        },
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (121, 52),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (121, 59),
           },
           Raw {
            content: "appendToMenuLabel",
            position: (121, 68),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\nLINUX /boot/",
        position: (121, 86),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (122, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (122, 26),
           },
           Raw {
            content: "boot",
            position: (122, 33),
           },
           Raw {
            content: "loader",
            position: (122, 38),
           },
           Raw {
            content: "kernelFile",
            position: (122, 45),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\nAPPEND init=",
        position: (122, 56),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (123, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (123, 26),
           },
           Raw {
            content: "build",
            position: (123, 33),
           },
           Raw {
            content: "toplevel",
            position: (123, 39),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/init ",
        position: (123, 48),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "toString",
          position: (123, 56),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (123, 65),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "boot",
              position: (123, 72),
             },
             Raw {
              content: "kernelParams",
              position: (123, 77),
             },
            ],
           },
           default: None,
          },
         ],
        },
       },
       Raw {
        content: "\nINITRD /boot/",
        position: (123, 90),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (124, 20),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (124, 27),
           },
           Raw {
            content: "boot",
            position: (124, 34),
           },
           Raw {
            content: "loader",
            position: (124, 39),
           },
           Raw {
            content: "initrdFile",
            position: (124, 46),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\n\n# A variant to boot with 'nomodeset'\nLABEL boot-nomodeset\nMENU LABEL NixOS ",
        position: (124, 57),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (128, 24),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (128, 31),
           },
           Raw {
            content: "nixos",
            position: (128, 38),
           },
           Raw {
            content: "label",
            position: (128, 44),
           },
          ],
         },
         default: None,
        },
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (128, 52),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (128, 59),
           },
           Raw {
            content: "appendToMenuLabel",
            position: (128, 68),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: " (nomodeset)\nLINUX /boot/",
        position: (128, 86),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (129, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (129, 26),
           },
           Raw {
            content: "boot",
            position: (129, 33),
           },
           Raw {
            content: "loader",
            position: (129, 38),
           },
           Raw {
            content: "kernelFile",
            position: (129, 45),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\nAPPEND init=",
        position: (129, 56),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (130, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (130, 26),
           },
           Raw {
            content: "build",
            position: (130, 33),
           },
           Raw {
            content: "toplevel",
            position: (130, 39),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/init ",
        position: (130, 48),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "toString",
          position: (130, 56),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (130, 65),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "boot",
              position: (130, 72),
             },
             Raw {
              content: "kernelParams",
              position: (130, 77),
             },
            ],
           },
           default: None,
          },
         ],
        },
       },
       Raw {
        content: " nomodeset\nINITRD /boot/",
        position: (130, 90),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (131, 20),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (131, 27),
           },
           Raw {
            content: "boot",
            position: (131, 34),
           },
           Raw {
            content: "loader",
            position: (131, 39),
           },
           Raw {
            content: "initrdFile",
            position: (131, 46),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\n\n# A variant to boot with 'copytoram'\nLABEL boot-copytoram\nMENU LABEL NixOS ",
        position: (131, 57),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (135, 24),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (135, 31),
           },
           Raw {
            content: "nixos",
            position: (135, 38),
           },
           Raw {
            content: "label",
            position: (135, 44),
           },
          ],
         },
         default: None,
        },
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (135, 52),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (135, 59),
           },
           Raw {
            content: "appendToMenuLabel",
            position: (135, 68),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: " (copytoram)\nLINUX /boot/",
        position: (135, 86),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (136, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (136, 26),
           },
           Raw {
            content: "boot",
            position: (136, 33),
           },
           Raw {
            content: "loader",
            position: (136, 38),
           },
           Raw {
            content: "kernelFile",
            position: (136, 45),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\nAPPEND init=",
        position: (136, 56),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (137, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (137, 26),
           },
           Raw {
            content: "build",
            position: (137, 33),
           },
           Raw {
            content: "toplevel",
            position: (137, 39),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/init ",
        position: (137, 48),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "toString",
          position: (137, 56),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (137, 65),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "boot",
              position: (137, 72),
             },
             Raw {
              content: "kernelParams",
              position: (137, 77),
             },
            ],
           },
           default: None,
          },
         ],
        },
       },
       Raw {
        content: " copytoram\nINITRD /boot/",
        position: (137, 90),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (138, 20),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (138, 27),
           },
           Raw {
            content: "boot",
            position: (138, 34),
           },
           Raw {
            content: "loader",
            position: (138, 39),
           },
           Raw {
            content: "initrdFile",
            position: (138, 46),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\n\n# A variant to boot with verbose logging to the console\nLABEL boot-debug\nMENU LABEL NixOS ",
        position: (138, 57),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (142, 24),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (142, 31),
           },
           Raw {
            content: "nixos",
            position: (142, 38),
           },
           Raw {
            content: "label",
            position: (142, 44),
           },
          ],
         },
         default: None,
        },
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (142, 52),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (142, 59),
           },
           Raw {
            content: "appendToMenuLabel",
            position: (142, 68),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: " (debug)\nLINUX /boot/",
        position: (142, 86),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (143, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (143, 26),
           },
           Raw {
            content: "boot",
            position: (143, 33),
           },
           Raw {
            content: "loader",
            position: (143, 38),
           },
           Raw {
            content: "kernelFile",
            position: (143, 45),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\nAPPEND init=",
        position: (143, 56),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (144, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (144, 26),
           },
           Raw {
            content: "build",
            position: (144, 33),
           },
           Raw {
            content: "toplevel",
            position: (144, 39),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/init ",
        position: (144, 48),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "toString",
          position: (144, 56),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (144, 65),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "boot",
              position: (144, 72),
             },
             Raw {
              content: "kernelParams",
              position: (144, 77),
             },
            ],
           },
           default: None,
          },
         ],
        },
       },
       Raw {
        content: " loglevel=7\nINITRD /boot/",
        position: (144, 90),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (145, 20),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (145, 27),
           },
           Raw {
            content: "boot",
            position: (145, 34),
           },
           Raw {
            content: "loader",
            position: (145, 39),
           },
           Raw {
            content: "initrdFile",
            position: (145, 46),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\n\n# A variant to boot with a serial console enabled\nLABEL boot-serial\nMENU LABEL NixOS ",
        position: (145, 57),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (149, 24),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (149, 31),
           },
           Raw {
            content: "nixos",
            position: (149, 38),
           },
           Raw {
            content: "label",
            position: (149, 44),
           },
          ],
         },
         default: None,
        },
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (149, 52),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (149, 59),
           },
           Raw {
            content: "appendToMenuLabel",
            position: (149, 68),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: " (serial console=ttyS0,115200n8)\nLINUX /boot/",
        position: (149, 86),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (150, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (150, 26),
           },
           Raw {
            content: "boot",
            position: (150, 33),
           },
           Raw {
            content: "loader",
            position: (150, 38),
           },
           Raw {
            content: "kernelFile",
            position: (150, 45),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\nAPPEND init=",
        position: (150, 56),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (151, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (151, 26),
           },
           Raw {
            content: "build",
            position: (151, 33),
           },
           Raw {
            content: "toplevel",
            position: (151, 39),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/init ",
        position: (151, 48),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "toString",
          position: (151, 56),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (151, 65),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "boot",
              position: (151, 72),
             },
             Raw {
              content: "kernelParams",
              position: (151, 77),
             },
            ],
           },
           default: None,
          },
         ],
        },
       },
       Raw {
        content: " console=ttyS0,115200n8\nINITRD /boot/",
        position: (151, 90),
       },
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (152, 20),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (152, 27),
           },
           Raw {
            content: "boot",
            position: (152, 34),
           },
           Raw {
            content: "loader",
            position: (152, 39),
           },
           Raw {
            content: "initrdFile",
            position: (152, 46),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "\n",
        position: (152, 57),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "isolinuxMemtest86Entry",
        position: (155, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "LABEL memtest\nMENU LABEL Memtest86+\nLINUX /boot/memtest.bin\nAPPEND ",
        position: (156, 1),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "toString",
          position: (159, 14),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (159, 23),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "boot",
              position: (159, 30),
             },
             Raw {
              content: "loader",
              position: (159, 35),
             },
             Raw {
              content: "grub",
              position: (159, 42),
             },
             Raw {
              content: "memtest86",
              position: (159, 47),
             },
             Raw {
              content: "params",
              position: (159, 57),
             },
            ],
           },
           default: None,
          },
         ],
        },
       },
       Raw {
        content: "\n",
        position: (159, 64),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "isolinuxCfg",
        position: (162, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "concatStringsSep",
       position: (162, 17),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "\n",
          position: (162, 35),
         },
        ],
       },
       BinaryOperation {
        operator: Concatenation,
        operands: [
         List {
          elements: [
           Variable {
            identifier: "baseIsolinuxCfg",
            position: (163, 8),
           },
          ],
          position: (163, 6),
         },
         FunctionApplication {
          function: Variable {
           identifier: "optional",
           position: (163, 29),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (163, 38),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "boot",
               position: (163, 45),
              },
              Raw {
               content: "loader",
               position: (163, 50),
              },
              Raw {
               content: "grub",
               position: (163, 57),
              },
              Raw {
               content: "memtest86",
               position: (163, 62),
              },
              Raw {
               content: "enable",
               position: (163, 72),
              },
             ],
            },
            default: None,
           },
           Variable {
            identifier: "isolinuxMemtest86Entry",
            position: (163, 79),
           },
          ],
         },
        ],
        position: (163, 26),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "refindBinary",
        position: (165, 3),
       },
      ],
     },
     IfThenElse {
      predicate: BinaryOperation {
       operator: LogicalOr,
       operands: [
        BinaryOperation {
         operator: EqualTo,
         operands: [
          Variable {
           identifier: "targetArch",
           position: (165, 21),
          },
          String {
           parts: [
            Raw {
             content: "x64",
             position: (165, 36),
            },
           ],
          },
         ],
         position: (165, 32),
        },
        BinaryOperation {
         operator: EqualTo,
         operands: [
          Variable {
           identifier: "targetArch",
           position: (165, 44),
          },
          String {
           parts: [
            Raw {
             content: "aa64",
             position: (165, 59),
            },
           ],
          },
         ],
         position: (165, 55),
        },
       ],
       position: (165, 41),
      },
      then: String {
       parts: [
        Raw {
         content: "refind_",
         position: (165, 71),
        },
        Expression {
         expression: Variable {
          identifier: "targetArch",
          position: (165, 80),
         },
        },
        Raw {
         content: ".efi",
         position: (165, 91),
        },
       ],
      },
      else_: Variable {
       identifier: "null",
       position: (165, 102),
      },
      position: (165, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "refind",
        position: (168, 3),
       },
      ],
     },
     IfThenElse {
      predicate: BinaryOperation {
       operator: NotEqualTo,
       operands: [
        Variable {
         identifier: "refindBinary",
         position: (169, 8),
        },
        Variable {
         identifier: "null",
         position: (169, 24),
        },
       ],
       position: (169, 21),
      },
      then: String {
       parts: [
        Raw {
         content: "# Adds rEFInd to the ISO.\ncp -v ",
         position: (171, 1),
        },
        Expression {
         expression: PropertyAccess {
          expression: Variable {
           identifier: "pkgs",
           position: (172, 15),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "refind",
             position: (172, 20),
            },
           ],
          },
          default: None,
         },
        },
        Raw {
         content: "/share/refind/",
         position: (172, 27),
        },
        Expression {
         expression: Variable {
          identifier: "refindBinary",
          position: (172, 43),
         },
        },
        Raw {
         content: " $out/EFI/boot/\n",
         position: (172, 56),
        },
       ],
      },
      else_: String {
       parts: [
        Raw {
         content: "# No refind for ",
         position: (175, 8),
        },
        Expression {
         expression: Variable {
          identifier: "targetArch",
          position: (175, 26),
         },
        },
       ],
      },
      position: (169, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "grubPkgs",
        position: (178, 3),
       },
      ],
     },
     IfThenElse {
      predicate: PropertyAccess {
       expression: Variable {
        identifier: "config",
        position: (178, 17),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "boot",
          position: (178, 24),
         },
         Raw {
          content: "loader",
          position: (178, 29),
         },
         Raw {
          content: "grub",
          position: (178, 36),
         },
         Raw {
          content: "forcei686",
          position: (178, 41),
         },
        ],
       },
       default: None,
      },
      then: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (178, 56),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "pkgsi686Linux",
          position: (178, 61),
         },
        ],
       },
       default: None,
      },
      else_: Variable {
       identifier: "pkgs",
       position: (178, 80),
      },
      position: (178, 14),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "grubMenuCfg",
        position: (180, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "#\n# Menu configuration\n#\n\n# Search using a \"marker file\"\nsearch --set=root --file /EFI/nixos-installer-image\n\ninsmod gfxterm\ninsmod png\nset gfxpayload=keep\nset gfxmode=",
        position: (181, 1),
       },
       Expression {
        expression: FunctionApplication {
         function: Variable {
          identifier: "concatStringsSep",
          position: (191, 19),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: ",",
             position: (191, 37),
            },
           ],
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "1920x1080",
               position: (197, 8),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "1366x768",
               position: (198, 8),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "1280x720",
               position: (199, 8),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "1024x768",
               position: (200, 8),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "800x600",
               position: (201, 8),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "auto",
               position: (202, 8),
              },
             ],
            },
           ],
           position: (191, 40),
          },
         ],
        },
       },
       Raw {
        content: "\n\n# Fonts can be loaded?\n# (This font is assumed to always be provided as a fallback by NixOS)\nif loadfont (\\$root)/EFI/boot/unicode.pf2; then\n  set with_fonts=true\nfi\nif [ \"\\$textmode\" != \"true\" -a \"\\$with_fonts\" == \"true\" ]; then\n  # Use graphical term, it can be either with background image or a theme.\n  # input is \"console\", while output is \"gfxterm\".\n  # This enables \"serial\" input and output only when possible.\n  # Otherwise the failure mode is to not even enable gfxterm.\n  if test \"\\$with_serial\" == \"yes\"; then\n    terminal_output gfxterm serial\n    terminal_input  console serial\n  else\n    terminal_output gfxterm\n    terminal_input  console\n  fi\nelse\n  # Sets colors for the non-graphical term.\n  set menu_color_normal=cyan/blue\n  set menu_color_highlight=white/blue\nfi\n\n",
        position: (203, 7),
       },
       Expression {
        expression: IfThenElse {
         predicate: BinaryOperation {
          operator: NotEqualTo,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (229, 8),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "isoImage",
               position: (229, 15),
              },
              Raw {
               content: "grubTheme",
               position: (229, 24),
              },
             ],
            },
            default: None,
           },
           Variable {
            identifier: "null",
            position: (229, 37),
           },
          ],
          position: (229, 34),
         },
         then: String {
          parts: [
           Raw {
            content: "# Sets theme.\nset theme=(\\$root)/EFI/boot/grub-theme/theme.txt\n# Load theme fonts\n$(find ",
            position: (230, 1),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (233, 16),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "isoImage",
                position: (233, 23),
               },
               Raw {
                content: "grubTheme",
                position: (233, 32),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: " -iname '*.pf2' -printf \"loadfont (\\$root)/EFI/boot/grub-theme/%P\\n\")\n",
            position: (233, 42),
           },
          ],
         },
         else_: String {
          parts: [
           Raw {
            content: "if background_image (\\$root)/EFI/boot/efi-background.png; then\n  # Black background means transparent background when there\n  # is a background image set... This seems undocumented :(\n  set color_normal=black/black\n  set color_highlight=white/blue\nelse\n  # Falls back again to proper colors.\n  set menu_color_normal=cyan/blue\n  set menu_color_highlight=white/blue\nfi\n",
            position: (235, 1),
           },
          ],
         },
         position: (229, 5),
        },
       },
       Raw {
        content: "\n",
        position: (245, 8),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "efiDir",
        position: (252, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (252, 12),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "runCommand",
          position: (252, 17),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "efi-directory",
          position: (252, 29),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "nativeBuildInputs",
             position: (253, 5),
            },
           ],
          },
          List {
           elements: [
            PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (253, 27),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "buildPackages",
                position: (253, 32),
               },
               Raw {
                content: "grub2_efi",
                position: (253, 46),
               },
              ],
             },
             default: None,
            },
           ],
           position: (253, 25),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "strictDeps",
             position: (254, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (254, 18),
          },
         ),
        ],
        recursive: false,
        position: (252, 44),
       },
       String {
        parts: [
         Raw {
          content: "mkdir -p $out/EFI/boot/\n\n# Add a marker so GRUB can find the filesystem.\ntouch $out/EFI/nixos-installer-image\n\n# ALWAYS required modules.\nMODULES=\"fat iso9660 part_gpt part_msdos \\\n         normal boot linux configfile loopback chain halt \\\n         efifwsetup efi_gop \\\n         ls search search_label search_fs_uuid search_fs_file \\\n         gfxmenu gfxterm gfxterm_background gfxterm_menu test all_video loadenv \\\n         exfat ext2 ntfs btrfs hfsplus udf \\\n         videoinfo png \\\n         echo serial \\\n        \"\n\necho \"Building GRUB with modules:\"\nfor mod in $MODULES; do\n  echo \" - $mod\"\ndone\n\n# Modules that may or may not be available per-platform.\necho \"Adding additional modules:\"\nfor mod in efi_uga; do\n  if [ -f ",
          position: (256, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "grubPkgs",
            position: (280, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "grub2_efi",
              position: (280, 26),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/lib/grub/",
          position: (280, 36),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "grubPkgs",
            position: (280, 48),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "grub2_efi",
              position: (280, 57),
             },
             Raw {
              content: "grubTarget",
              position: (280, 67),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/$mod.mod ]; then\n    echo \" - $mod\"\n    MODULES+=\" $mod\"\n  fi\ndone\n\n# Make our own efi program, we can't rely on \"grub-install\" since it seems to\n# probe for devices, even with --skip-fs-probe.\ngrub-mkimage --directory=",
          position: (280, 78),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "grubPkgs",
            position: (288, 32),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "grub2_efi",
              position: (288, 41),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/lib/grub/",
          position: (288, 51),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "grubPkgs",
            position: (288, 63),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "grub2_efi",
              position: (288, 72),
             },
             Raw {
              content: "grubTarget",
              position: (288, 82),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: " -o $out/EFI/boot/boot",
          position: (288, 93),
         },
         Expression {
          expression: Variable {
           identifier: "targetArch",
           position: (288, 117),
          },
         },
         Raw {
          content: ".efi -p /EFI/boot -O ",
          position: (288, 128),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "grubPkgs",
            position: (288, 151),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "grub2_efi",
              position: (288, 160),
             },
             Raw {
              content: "grubTarget",
              position: (288, 170),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: " \\\n  $MODULES\ncp ",
          position: (288, 181),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "grubPkgs",
            position: (290, 10),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "grub2_efi",
              position: (290, 19),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/share/grub/unicode.pf2 $out/EFI/boot/\n\ncat <<EOF > $out/EFI/boot/grub.cfg\n\nset with_fonts=false\nset textmode=false\n# If you want to use serial for \"terminal_*\" commands, you need to set one up:\n#   Example manual configuration:\n#    → serial --unit=0 --speed=115200 --word=8 --parity=no --stop=1\n# This uses the defaults, and makes the serial terminal available.\nset with_serial=no\nif serial; then set with_serial=yes ;fi\nexport with_serial\nclear\nset timeout=10\n\n# This message will only be viewable when \"gfxterm\" is not used.\necho \"\"\necho \"Loading graphical boot menu...\"\necho \"\"\necho \"Press 't' to use the text boot menu on this console...\"\necho \"\"\n\n",
          position: (290, 29),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (313, 7),
          },
         },
         Raw {
          content: "\n\nhiddenentry 'Text mode' --hotkey 't' {\n  loadfont (\\$root)/EFI/boot/unicode.pf2\n  set textmode=true\n  terminal_output gfxterm console\n}\nhiddenentry 'GUI mode' --hotkey 'g' {\n  $(find ",
          position: (313, 19),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (321, 16),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "isoImage",
              position: (321, 23),
             },
             Raw {
              content: "grubTheme",
              position: (321, 32),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: " -iname '*.pf2' -printf \"loadfont (\\$root)/EFI/boot/grub-theme/%P\\n\")\n  set textmode=false\n  terminal_output gfxterm\n}\n\n\n# If the parameter iso_path is set, append the findiso parameter to the kernel\n# line. We need this to allow the nixos iso to be booted from grub directly.\nif [ \\",
          position: (321, 42),
         },
         Raw {
          content: "$",
          position: (329, 11),
         },
         Raw {
          content: "{iso_path} ] ; then\n  set isoboot=\"findiso=\\",
          position: (329, 14),
         },
         Raw {
          content: "$",
          position: (330, 29),
         },
         Raw {
          content: "{iso_path}\"\nfi\n\n#\n# Menu entries\n#\n\n",
          position: (330, 32),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuGrub2",
            position: (337, 7),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (337, 22),
            },
           ],
          },
         },
         Raw {
          content: "\nsubmenu \"HiDPI, Quirks and Accessibility\" --class hidpi --class submenu {\n  ",
          position: (337, 29),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (339, 9),
          },
         },
         Raw {
          content: "\n  submenu \"Suggests resolution @720p\" --class hidpi-720p {\n    ",
          position: (339, 21),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (341, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (341, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (342, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (342, 42),
            },
            String {
             parts: [
              Raw {
               content: "video=1280x720@60",
               position: (342, 50),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n  submenu \"Suggests resolution @1080p\" --class hidpi-1080p {\n    ",
          position: (342, 69),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (345, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (345, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (346, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (346, 42),
            },
            String {
             parts: [
              Raw {
               content: "video=1920x1080@60",
               position: (346, 50),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n\n  # If we boot into a graphical environment where X is autoran\n  # and always crashes, it makes the media unusable. Allow the user\n  # to disable this.\n  submenu \"Disable display-manager\" --class quirk-disable-displaymanager {\n    ",
          position: (346, 70),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (353, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (353, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (354, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (354, 42),
            },
            String {
             parts: [
              Raw {
               content: "systemd.mask=display-manager.service",
               position: (354, 50),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n\n  # Some laptop and convertibles have the panel installed in an\n  # inconvenient way, rotated away from the keyboard.\n  # Those entries makes it easier to use the installer.\n  submenu \"\" {return}\n  submenu \"Rotate framebuffer Clockwise\" --class rotate-90cw {\n    ",
          position: (354, 88),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (362, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (362, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (363, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (363, 42),
            },
            String {
             parts: [
              Raw {
               content: "fbcon=rotate:1",
               position: (363, 50),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n  submenu \"Rotate framebuffer Upside-Down\" --class rotate-180 {\n    ",
          position: (363, 66),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (366, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (366, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (367, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (367, 42),
            },
            String {
             parts: [
              Raw {
               content: "fbcon=rotate:2",
               position: (367, 50),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n  submenu \"Rotate framebuffer Counter-Clockwise\" --class rotate-90ccw {\n    ",
          position: (367, 66),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (370, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (370, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (371, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (371, 42),
            },
            String {
             parts: [
              Raw {
               content: "fbcon=rotate:3",
               position: (371, 50),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n\n  # As a proof of concept, mainly. (Not sure it has accessibility merits.)\n  submenu \"\" {return}\n  submenu \"Use black on white\" --class accessibility-blakconwhite {\n    ",
          position: (371, 66),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (377, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (377, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (378, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (378, 42),
            },
            String {
             parts: [
              Raw {
               content: "vt.default_red=0xFF,0xBC,0x4F,0xB4,0x56,0xBC,0x4F,0x00,0xA1,0xCF,0x84,0xCA,0x8D,0xB4,0x84,0x68 vt.default_grn=0xFF,0x55,0xBA,0xBA,0x4D,0x4D,0xB3,0x00,0xA0,0x8F,0xB3,0xCA,0x88,0x93,0xA4,0x68 vt.default_blu=0xFF,0x58,0x5F,0x58,0xC5,0xBD,0xC5,0x00,0xA8,0xBB,0xAB,0x97,0xBD,0xC7,0xC5,0x68",
               position: (378, 50),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n\n  # Serial access is a must!\n  submenu \"\" {return}\n  submenu \"Serial console=ttyS0,115200n8\" --class serial {\n    ",
          position: (378, 336),
         },
         Expression {
          expression: Variable {
           identifier: "grubMenuCfg",
           position: (384, 11),
          },
         },
         Raw {
          content: "\n    ",
          position: (384, 23),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "buildMenuAdditionalParamsGrub2",
            position: (385, 11),
           },
           arguments: [
            Variable {
             identifier: "config",
             position: (385, 42),
            },
            String {
             parts: [
              Raw {
               content: "console=ttyS0,115200n8",
               position: (385, 50),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n  }\n}\n\n",
          position: (385, 74),
         },
         Expression {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (389, 7),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "optionalString",
               position: (389, 11),
              },
             ],
            },
            default: None,
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              Variable {
               identifier: "refindBinary",
               position: (389, 27),
              },
              Variable {
               identifier: "null",
               position: (389, 43),
              },
             ],
             position: (389, 40),
            },
            String {
             parts: [
              Raw {
               content: "# GRUB apparently cannot do \"chainloader\" operations on \"CD\".\nif [ \"\\$root\" != \"cd0\" ]; then\n  # Force root to be the FAT partition\n  # Otherwise it breaks rEFInd's boot\n  search --set=root --no-floppy --fs-uuid 1234-5678\n  menuentry 'rEFInd' --class refind {\n    chainloader (\\$root)/EFI/boot/",
               position: (390, 1),
              },
              Expression {
               expression: Variable {
                identifier: "refindBinary",
                position: (396, 41),
               },
              },
              Raw {
               content: "\n  }\nfi\n",
               position: (396, 54),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\nmenuentry 'Firmware Setup' --class settings {\n  fwsetup\n  clear\n  echo \"\"\n  echo \"If you see this message, your EFI system doesn't support this feature.\"\n  echo \"\"\n}\nmenuentry 'Shutdown' --class shutdown {\n  halt\n}\nEOF\n\n",
          position: (399, 8),
         },
         Expression {
          expression: Variable {
           identifier: "refind",
           position: (412, 7),
          },
         },
         Raw {
          content: "\n",
          position: (412, 14),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "efiImg",
        position: (415, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (415, 12),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "runCommand",
          position: (415, 17),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "efi-image_eltorito",
          position: (415, 29),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "nativeBuildInputs",
             position: (416, 5),
            },
           ],
          },
          List {
           elements: [
            PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (416, 27),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "buildPackages",
                position: (416, 32),
               },
               Raw {
                content: "mtools",
                position: (416, 46),
               },
              ],
             },
             default: None,
            },
            PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (416, 53),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "buildPackages",
                position: (416, 58),
               },
               Raw {
                content: "libfaketime",
                position: (416, 72),
               },
              ],
             },
             default: None,
            },
            PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (416, 84),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "buildPackages",
                position: (416, 89),
               },
               Raw {
                content: "dosfstools",
                position: (416, 103),
               },
              ],
             },
             default: None,
            },
           ],
           position: (416, 25),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "strictDeps",
             position: (417, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (417, 18),
          },
         ),
        ],
        recursive: false,
        position: (415, 49),
       },
       String {
        parts: [
         Raw {
          content: "mkdir ./contents && cd ./contents\ncp -rp \"",
          position: (422, 1),
         },
         Expression {
          expression: Variable {
           identifier: "efiDir",
           position: (423, 17),
          },
         },
         Raw {
          content: "\"/EFI .\nmkdir ./boot\ncp -p \"",
          position: (423, 24),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (425, 16),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "boot",
              position: (425, 23),
             },
             Raw {
              content: "kernelPackages",
              position: (425, 28),
             },
             Raw {
              content: "kernel",
              position: (425, 43),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/",
          position: (425, 50),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (425, 53),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "system",
              position: (425, 60),
             },
             Raw {
              content: "boot",
              position: (425, 67),
             },
             Raw {
              content: "loader",
              position: (425, 72),
             },
             Raw {
              content: "kernelFile",
              position: (425, 79),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\" \\\n  \"",
          position: (425, 90),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (426, 12),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "system",
              position: (426, 19),
             },
             Raw {
              content: "build",
              position: (426, 26),
             },
             Raw {
              content: "initialRamdisk",
              position: (426, 32),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/",
          position: (426, 47),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (426, 50),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "system",
              position: (426, 57),
             },
             Raw {
              content: "boot",
              position: (426, 64),
             },
             Raw {
              content: "loader",
              position: (426, 69),
             },
             Raw {
              content: "initrdFile",
              position: (426, 76),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\" ./boot/\n\n# Rewrite dates for everything in the FS\nfind . -exec touch --date=2000-01-01 {} +\n\n# Round up to the nearest multiple of 1MB, for more deterministic du output\nusage_size=$(( $(du -s --block-size=1M --apparent-size . | tr -cd '[:digit:]') * 1024 * 1024 ))\n# Make the image 110% as big as the files need to make up for FAT overhead\nimage_size=$(( ($usage_size * 110) / 100 ))\n# Make the image fit blocks of 1M\nblock_size=$((1024*1024))\nimage_size=$(( ($image_size / $block_size + 1) * $block_size ))\necho \"Usage size: $usage_size\"\necho \"Image size: $image_size\"\ntruncate --size=$image_size \"$out\"\nfaketime \"2000-01-01 00:00:00\" mkfs.vfat -i 12345678 -n EFIBOOT \"$out\"\n\n# Force a fixed order in mcopy for better determinism, and avoid file globbing\nfor d in $(find EFI boot -type d | sort); do\n  faketime \"2000-01-01 00:00:00\" mmd -i \"$out\" \"::/$d\"\ndone\n\nfor f in $(find EFI boot -type f | sort); do\n  mcopy -pvm -i \"$out\" \"$f\" \"::/$f\"\ndone\n\n# Verify the FAT partition.\nfsck.vfat -vn \"$out\"\n",
          position: (426, 87),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "targetArch",
        position: (457, 3),
       },
      ],
     },
     IfThenElse {
      predicate: BinaryOperation {
       operator: LogicalOr,
       operands: [
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (458, 8),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "stdenv",
            position: (458, 13),
           },
           Raw {
            content: "isi686",
            position: (458, 20),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (458, 30),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (458, 37),
           },
           Raw {
            content: "loader",
            position: (458, 42),
           },
           Raw {
            content: "grub",
            position: (458, 49),
           },
           Raw {
            content: "forcei686",
            position: (458, 54),
           },
          ],
         },
         default: None,
        },
       ],
       position: (458, 27),
      },
      then: String {
       parts: [
        Raw {
         content: "ia32",
         position: (459, 8),
        },
       ],
      },
      else_: IfThenElse {
       predicate: PropertyAccess {
        expression: Variable {
         identifier: "pkgs",
         position: (460, 13),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "stdenv",
           position: (460, 18),
          },
          Raw {
           content: "isx86_64",
           position: (460, 25),
          },
         ],
        },
        default: None,
       },
       then: String {
        parts: [
         Raw {
          content: "x64",
          position: (461, 8),
         },
        ],
       },
       else_: IfThenElse {
        predicate: PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (462, 13),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "stdenv",
            position: (462, 18),
           },
           Raw {
            content: "isAarch32",
            position: (462, 25),
           },
          ],
         },
         default: None,
        },
        then: String {
         parts: [
          Raw {
           content: "arm",
           position: (463, 8),
          },
         ],
        },
        else_: IfThenElse {
         predicate: PropertyAccess {
          expression: Variable {
           identifier: "pkgs",
           position: (464, 13),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "stdenv",
             position: (464, 18),
            },
            Raw {
             content: "isAarch64",
             position: (464, 25),
            },
           ],
          },
          default: None,
         },
         then: String {
          parts: [
           Raw {
            content: "aa64",
            position: (465, 8),
           },
          ],
         },
         else_: FunctionApplication {
          function: Variable {
           identifier: "throw",
           position: (467, 7),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "Unsupported architecture",
              position: (467, 14),
             },
            ],
           },
          ],
         },
         position: (464, 10),
        },
        position: (462, 10),
       },
       position: (460, 10),
      },
      position: (458, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "canx86BiosBoot",
        position: (470, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (470, 20),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "stdenv",
         position: (470, 25),
        },
        Raw {
         content: "hostPlatform",
         position: (470, 32),
        },
        Raw {
         content: "isx86",
         position: (470, 45),
        },
       ],
      },
      default: None,
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (475, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (477, 5),
           },
           Raw {
            content: "isoName",
            position: (477, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (477, 24),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (478, 7),
                },
               ],
              },
              String {
               parts: [
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (478, 20),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "isoImage",
                     position: (478, 27),
                    },
                    Raw {
                     content: "isoBaseName",
                     position: (478, 36),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: ".iso",
                 position: (478, 48),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (479, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Name of the generated ISO image file.\n",
                 position: (480, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (477, 33),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (484, 5),
           },
           Raw {
            content: "isoBaseName",
            position: (484, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (484, 28),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (485, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "nixos",
                 position: (485, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (486, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Prefix of the name of the generated ISO image file.\n",
                 position: (487, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (484, 37),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (491, 5),
           },
           Raw {
            content: "compressImage",
            position: (491, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (491, 30),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (492, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (492, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (493, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Whether the ISO image should be compressed using\n<command>zstd</command>.\n",
                 position: (494, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (491, 39),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (499, 5),
           },
           Raw {
            content: "squashfsCompression",
            position: (499, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (499, 36),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (500, 7),
                },
               ],
              },
              With {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (500, 22),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "stdenv",
                   position: (500, 27),
                  },
                  Raw {
                   content: "targetPlatform",
                   position: (500, 34),
                  },
                 ],
                },
                default: None,
               },
               target: BinaryOperation {
                operator: Addition,
                operands: [
                 BinaryOperation {
                  operator: Addition,
                  operands: [
                   BinaryOperation {
                    operator: Addition,
                    operands: [
                     BinaryOperation {
                      operator: Addition,
                      operands: [
                       String {
                        parts: [
                         Raw {
                          content: "xz -Xdict-size 100% ",
                          position: (500, 51),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: PropertyAccess {
                         expression: Variable {
                          identifier: "lib",
                          position: (501, 19),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "optionalString",
                            position: (501, 23),
                           },
                          ],
                         },
                         default: None,
                        },
                        arguments: [
                         BinaryOperation {
                          operator: LogicalOr,
                          operands: [
                           Variable {
                            identifier: "isx86_32",
                            position: (501, 39),
                           },
                           Variable {
                            identifier: "isx86_64",
                            position: (501, 51),
                           },
                          ],
                          position: (501, 48),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "-Xbcj x86",
                            position: (501, 62),
                           },
                          ],
                         },
                        ],
                       },
                      ],
                      position: (501, 17),
                     },
                     FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "lib",
                        position: (503, 19),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "optionalString",
                          position: (503, 23),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       BinaryOperation {
                        operator: LogicalOr,
                        operands: [
                         Variable {
                          identifier: "isAarch32",
                          position: (503, 39),
                         },
                         Variable {
                          identifier: "isAarch64",
                          position: (503, 52),
                         },
                        ],
                        position: (503, 49),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "-Xbcj arm",
                          position: (503, 64),
                         },
                        ],
                       },
                      ],
                     },
                    ],
                    position: (503, 17),
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (504, 19),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "optionalString",
                        position: (504, 23),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Variable {
                      identifier: "isPowerPC",
                      position: (504, 39),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "-Xbcj powerpc",
                        position: (504, 51),
                       },
                      ],
                     },
                    ],
                   },
                  ],
                  position: (504, 17),
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (505, 19),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "optionalString",
                      position: (505, 23),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "isSparc",
                    position: (505, 39),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "-Xbcj sparc",
                      position: (505, 49),
                     },
                    ],
                   },
                  ],
                 },
                ],
                position: (505, 17),
               },
               position: (500, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (506, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Compression settings to use for the squashfs nix store.\n",
                 position: (507, 1),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (509, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "zstd -Xcompression-level 6",
                 position: (509, 18),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (499, 45),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (512, 5),
           },
           Raw {
            content: "edition",
            position: (512, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (512, 24),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (513, 7),
                },
               ],
              },
              String {
               parts: [],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (514, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Specifies which edition string to use in the volume ID of the generated\nISO image.\n",
                 position: (515, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (512, 33),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (520, 5),
           },
           Raw {
            content: "volumeID",
            position: (520, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (520, 25),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (522, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "nixos",
                 position: (522, 18),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (522, 25),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (522, 41),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "isoImage",
                         position: (522, 48),
                        },
                        Raw {
                         content: "edition",
                         position: (522, 57),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [],
                     },
                    ],
                    position: (522, 65),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "-",
                      position: (522, 73),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (522, 76),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "isoImage",
                          position: (522, 83),
                         },
                         Raw {
                          content: "edition",
                          position: (522, 92),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: "-",
                 position: (522, 102),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (522, 105),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "system",
                     position: (522, 112),
                    },
                    Raw {
                     content: "nixos",
                     position: (522, 119),
                    },
                    Raw {
                     content: "release",
                     position: (522, 125),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "-",
                 position: (522, 133),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (522, 136),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "stdenv",
                     position: (522, 141),
                    },
                    Raw {
                     content: "hostPlatform",
                     position: (522, 148),
                    },
                    Raw {
                     content: "uname",
                     position: (522, 161),
                    },
                    Raw {
                     content: "processor",
                     position: (522, 167),
                    },
                   ],
                  },
                  default: None,
                 },
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (523, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Specifies the label or volume ID of the generated ISO image.\nNote that the label is used by stage 1 of the boot process to\nmount the CD, so it should be reasonably distinctive.\n",
                 position: (524, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (520, 34),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (530, 5),
           },
           Raw {
            content: "contents",
            position: (530, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (530, 25),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (531, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (531, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "[ { source = pkgs.memtest86 + \"/memtest.bin\";\n    target = \"boot/memtest.bin\";\n  }\n]\n",
                   position: (532, 1),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (537, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "This option lists files to be copied to fixed locations in the\ngenerated ISO image.\n",
                 position: (538, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (530, 34),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (543, 5),
           },
           Raw {
            content: "storeContents",
            position: (543, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (543, 30),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (544, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (544, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "[ pkgs.stdenv ]",
                   position: (544, 36),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (545, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "This option lists additional derivations to be included in the\nNix store in the generated ISO image.\n",
                 position: (546, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (543, 39),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (551, 5),
           },
           Raw {
            content: "includeSystemBuildDependencies",
            position: (551, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (551, 47),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (552, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (552, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (553, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Set this option to include all the needed sources etc in the\nimage. It significantly increases image size. Use that when\nyou want to be able to keep all the sources needed to build your\nsystem or when you are going to install the system on a computer\nwith slow or non-existent network connection.\n",
                 position: (554, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (551, 56),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (562, 5),
           },
           Raw {
            content: "makeEfiBootable",
            position: (562, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (562, 32),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (563, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (563, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (564, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Whether the ISO image should be an efi-bootable volume.\n",
                 position: (565, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (562, 41),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (569, 5),
           },
           Raw {
            content: "makeUsbBootable",
            position: (569, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (569, 32),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (570, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (570, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (571, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Whether the ISO image should be bootable from CD as well as USB.\n",
                 position: (572, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (569, 41),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (576, 5),
           },
           Raw {
            content: "efiSplashImage",
            position: (576, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (576, 31),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (577, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (577, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "fetchurl",
                   position: (577, 22),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "url",
                      position: (578, 11),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "https://raw.githubusercontent.com/NixOS/nixos-artwork/a9e05d7deb38a8e005a2b52575a3f59a63a4dba0/bootloader/efi-background.png",
                      position: (578, 18),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "sha256",
                      position: (579, 11),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "18lfwmp8yq923322nlb9gxrh5qikj1wsk6g5qvdh31c4h5b1538x",
                      position: (579, 21),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (577, 31),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (581, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "The splash image to use in the EFI bootloader.\n",
                 position: (582, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (576, 40),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (586, 5),
           },
           Raw {
            content: "splashImage",
            position: (586, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (586, 28),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (587, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (587, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "fetchurl",
                   position: (587, 22),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "url",
                      position: (588, 11),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "https://raw.githubusercontent.com/NixOS/nixos-artwork/a9e05d7deb38a8e005a2b52575a3f59a63a4dba0/bootloader/isolinux/bios-boot.png",
                      position: (588, 18),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "sha256",
                      position: (589, 11),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "1wp822zrhbg4fgfbwkr7cbkr4labx477209agzc0hr6k62fr6rxd",
                      position: (589, 21),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (587, 31),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (591, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "The splash image to use in the legacy-boot bootloader.\n",
                 position: (592, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (586, 37),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (596, 5),
           },
           Raw {
            content: "grubTheme",
            position: (596, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (596, 26),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (597, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (597, 17),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "nixos-grub2-theme",
                  position: (597, 22),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (598, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (598, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "nullOr",
                   position: (598, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (598, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "either",
                     position: (598, 34),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (598, 41),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "path",
                      position: (598, 47),
                     },
                    ],
                   },
                   default: None,
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (598, 52),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "package",
                      position: (598, 58),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (599, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "The grub2 theme used for UEFI boot.\n",
                 position: (600, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (596, 35),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (604, 5),
           },
           Raw {
            content: "appendToMenuLabel",
            position: (604, 14),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (604, 34),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (605, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: " Installer",
                 position: (605, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (606, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: " Live System",
                 position: (606, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (607, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "The string to append after the menu label for the NixOS system.\nThis will be directly appended (without whitespace) to the NixOS version\nstring, like for example if it is set to <literal>XXX</literal>:\n\n<para><literal>NixOS 99.99-pre666XXX</literal></para>\n",
                 position: (608, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (604, 43),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (475, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (620, 3),
        },
        Raw {
         content: "lib",
         position: (620, 10),
        },
        Raw {
         content: "isoFileSystems",
         position: (620, 14),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Expression {
            expression: String {
             parts: [
              Raw {
               content: "/",
               position: (621, 6),
              },
             ],
            },
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkImageMediaOverride",
           position: (621, 11),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "fsType",
                 position: (623, 9),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "tmpfs",
                 position: (623, 19),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "options",
                 position: (624, 9),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "mode=0755",
                   position: (624, 22),
                  },
                 ],
                },
               ],
               position: (624, 19),
              },
             ),
            ],
            recursive: false,
            position: (622, 7),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Expression {
            expression: String {
             parts: [
              Raw {
               content: "/iso",
               position: (630, 6),
              },
             ],
            },
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkImageMediaOverride",
           position: (630, 14),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "device",
                 position: (631, 9),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/dev/root",
                 position: (631, 19),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "neededForBoot",
                 position: (632, 9),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (632, 25),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "noCheck",
                 position: (633, 9),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (633, 19),
              },
             ),
            ],
            recursive: false,
            position: (631, 7),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Expression {
            expression: String {
             parts: [
              Raw {
               content: "/nix/.ro-store",
               position: (638, 6),
              },
             ],
            },
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkImageMediaOverride",
           position: (638, 24),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "fsType",
                 position: (639, 9),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "squashfs",
                 position: (639, 19),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "device",
                 position: (640, 9),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/iso/nix-store.squashfs",
                 position: (640, 19),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "options",
                 position: (641, 9),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "loop",
                   position: (641, 22),
                  },
                 ],
                },
               ],
               position: (641, 19),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "neededForBoot",
                 position: (642, 9),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (642, 25),
              },
             ),
            ],
            recursive: false,
            position: (639, 7),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Expression {
            expression: String {
             parts: [
              Raw {
               content: "/nix/.rw-store",
               position: (645, 6),
              },
             ],
            },
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkImageMediaOverride",
           position: (645, 24),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "fsType",
                 position: (646, 9),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "tmpfs",
                 position: (646, 19),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "options",
                 position: (647, 9),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "mode=0755",
                   position: (647, 22),
                  },
                 ],
                },
               ],
               position: (647, 19),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "neededForBoot",
                 position: (648, 9),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (648, 25),
              },
             ),
            ],
            recursive: false,
            position: (646, 7),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Expression {
            expression: String {
             parts: [
              Raw {
               content: "/nix/store",
               position: (651, 6),
              },
             ],
            },
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkImageMediaOverride",
           position: (651, 20),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "fsType",
                 position: (652, 9),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "overlay",
                 position: (652, 19),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "device",
                 position: (653, 9),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "overlay",
                 position: (653, 19),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "options",
                 position: (654, 9),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "lowerdir=/nix/.ro-store",
                   position: (655, 12),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "upperdir=/nix/.rw-store/store",
                   position: (656, 12),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "workdir=/nix/.rw-store/work",
                   position: (657, 12),
                  },
                 ],
                },
               ],
               position: (654, 19),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "depends",
                 position: (659, 9),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "/nix/.ro-store",
                   position: (660, 12),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "/nix/.rw-store/store",
                   position: (661, 12),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "/nix/.rw-store/work",
                   position: (662, 12),
                  },
                 ],
                },
               ],
               position: (659, 19),
              },
             ),
            ],
            recursive: false,
            position: (652, 7),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (620, 31),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (667, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "assertions",
            position: (668, 5),
           },
          ],
         },
         List {
          elements: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "assertion",
                 position: (670, 9),
                },
               ],
              },
              UnaryOperation {
               operator: Not,
               operand: BinaryOperation {
                operator: GreaterThan,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "stringLength",
                   position: (670, 23),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (670, 36),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "isoImage",
                       position: (670, 43),
                      },
                      Raw {
                       content: "volumeID",
                       position: (670, 52),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                 Int {
                  value: 32,
                  position: (670, 63),
                 },
                ],
                position: (670, 61),
               },
               position: (670, 21),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "message",
                 position: (673, 9),
                },
               ],
              },
              LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "length",
                    position: (674, 11),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "stringLength",
                   position: (674, 20),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (674, 33),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "isoImage",
                       position: (674, 40),
                      },
                      Raw {
                       content: "volumeID",
                       position: (674, 49),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "howmany",
                    position: (675, 11),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (675, 21),
                  },
                  arguments: [
                   Variable {
                    identifier: "length",
                    position: (675, 30),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "toomany",
                    position: (676, 11),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (676, 21),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: Subtraction,
                    operands: [
                     Variable {
                      identifier: "length",
                      position: (676, 31),
                     },
                     Int {
                      value: 32,
                      position: (676, 40),
                     },
                    ],
                    position: (676, 38),
                   },
                  ],
                 },
                ),
               ],
               target: String {
                parts: [
                 Raw {
                  content: "isoImage.volumeID ",
                  position: (678, 10),
                 },
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (678, 30),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "isoImage",
                      position: (678, 37),
                     },
                     Raw {
                      content: "volumeID",
                      position: (678, 46),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: " is ",
                  position: (678, 55),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "howmany",
                   position: (678, 61),
                  },
                 },
                 Raw {
                  content: " characters. That is ",
                  position: (678, 69),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "toomany",
                   position: (678, 92),
                  },
                 },
                 Raw {
                  content: " characters longer than the limit of 32.",
                  position: (678, 100),
                 },
                ],
               },
               position: (673, 19),
              },
             ),
            ],
            recursive: false,
            position: (669, 7),
           },
          ],
          position: (668, 18),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (682, 5),
           },
           Raw {
            content: "loader",
            position: (682, 10),
           },
           Raw {
            content: "grub",
            position: (682, 17),
           },
           Raw {
            content: "version",
            position: (682, 22),
           },
          ],
         },
         Int {
          value: 2,
          position: (682, 32),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (686, 5),
           },
           Raw {
            content: "loader",
            position: (686, 10),
           },
           Raw {
            content: "grub",
            position: (686, 17),
           },
           Raw {
            content: "enable",
            position: (686, 22),
           },
          ],
         },
         Variable {
          identifier: "false",
          position: (686, 31),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (688, 5),
           },
           Raw {
            content: "systemPackages",
            position: (688, 17),
           },
          ],
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "grubPkgs",
               position: (688, 37),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "grub2",
                 position: (688, 46),
                },
               ],
              },
              default: None,
             },
             PropertyAccess {
              expression: Variable {
               identifier: "grubPkgs",
               position: (688, 52),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "grub2_efi",
                 position: (688, 61),
                },
               ],
              },
              default: None,
             },
            ],
            position: (688, 35),
           },
           FunctionApplication {
            function: Variable {
             identifier: "optional",
             position: (689, 10),
            },
            arguments: [
             Variable {
              identifier: "canx86BiosBoot",
              position: (689, 19),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (689, 34),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "syslinux",
                 position: (689, 39),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ],
          position: (689, 7),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (700, 5),
           },
           Raw {
            content: "kernelParams",
            position: (700, 10),
           },
          ],
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "root=LABEL=",
              position: (701, 10),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (701, 23),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "isoImage",
                  position: (701, 30),
                 },
                 Raw {
                  content: "volumeID",
                  position: (701, 39),
                 },
                ],
               },
               default: None,
              },
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "boot.shell_on_fail",
              position: (702, 10),
             },
            ],
           },
          ],
          position: (701, 7),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "fileSystems",
            position: (705, 5),
           },
          ],
         },
         PropertyAccess {
          expression: Variable {
           identifier: "config",
           position: (705, 19),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "lib",
             position: (705, 26),
            },
            Raw {
             content: "isoFileSystems",
             position: (705, 30),
            },
           ],
          },
          default: None,
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (707, 5),
           },
           Raw {
            content: "initrd",
            position: (707, 10),
           },
           Raw {
            content: "availableKernelModules",
            position: (707, 17),
           },
          ],
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "squashfs",
              position: (707, 45),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "iso9660",
              position: (707, 56),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "uas",
              position: (707, 66),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "overlay",
              position: (707, 72),
             },
            ],
           },
          ],
          position: (707, 42),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (709, 5),
           },
           Raw {
            content: "initrd",
            position: (709, 10),
           },
           Raw {
            content: "kernelModules",
            position: (709, 17),
           },
          ],
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "loop",
              position: (709, 36),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "overlay",
              position: (709, 43),
             },
            ],
           },
          ],
          position: (709, 33),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (713, 5),
           },
           Raw {
            content: "storeContents",
            position: (713, 14),
           },
          ],
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (714, 9),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "system",
                 position: (714, 16),
                },
                Raw {
                 content: "build",
                 position: (714, 23),
                },
                Raw {
                 content: "toplevel",
                 position: (714, 29),
                },
               ],
              },
              default: None,
             },
            ],
            position: (714, 7),
           },
           FunctionApplication {
            function: Variable {
             identifier: "optional",
             position: (715, 7),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (715, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "isoImage",
                 position: (715, 23),
                },
                Raw {
                 content: "includeSystemBuildDependencies",
                 position: (715, 32),
                },
               ],
              },
              default: None,
             },
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (716, 9),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "system",
                 position: (716, 16),
                },
                Raw {
                 content: "build",
                 position: (716, 23),
                },
                Raw {
                 content: "toplevel",
                 position: (716, 29),
                },
                Raw {
                 content: "drvPath",
                 position: (716, 38),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ],
          position: (714, 40),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (719, 5),
           },
           Raw {
            content: "build",
            position: (719, 12),
           },
           Raw {
            content: "squashfsStore",
            position: (719, 18),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "pkgs",
            position: (719, 34),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "callPackage",
              position: (719, 39),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Path {
            parts: [
             Raw {
              content: "../../../lib/make-squashfs.nix",
              position: (719, 51),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "storeContents",
                 position: (720, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (720, 23),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "isoImage",
                  position: (720, 30),
                 },
                 Raw {
                  content: "storeContents",
                  position: (720, 39),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "comp",
                 position: (721, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (721, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "isoImage",
                  position: (721, 21),
                 },
                 Raw {
                  content: "squashfsCompression",
                  position: (721, 30),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (719, 82),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "isoImage",
            position: (726, 5),
           },
           Raw {
            content: "contents",
            position: (726, 14),
           },
          ],
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           List {
            elements: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "source",
                   position: (728, 11),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  BinaryOperation {
                   operator: Addition,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (728, 20),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "boot",
                        position: (728, 27),
                       },
                       Raw {
                        content: "kernelPackages",
                        position: (728, 32),
                       },
                       Raw {
                        content: "kernel",
                        position: (728, 47),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/",
                       position: (728, 57),
                      },
                     ],
                    },
                   ],
                   position: (728, 54),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (728, 62),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "system",
                      position: (728, 69),
                     },
                     Raw {
                      content: "boot",
                      position: (728, 76),
                     },
                     Raw {
                      content: "loader",
                      position: (728, 81),
                     },
                     Raw {
                      content: "kernelFile",
                      position: (728, 88),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (728, 60),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "target",
                   position: (729, 11),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  String {
                   parts: [
                    Raw {
                     content: "/boot/",
                     position: (729, 21),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (729, 31),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "system",
                      position: (729, 38),
                     },
                     Raw {
                      content: "boot",
                      position: (729, 45),
                     },
                     Raw {
                      content: "loader",
                      position: (729, 50),
                     },
                     Raw {
                      content: "kernelFile",
                      position: (729, 57),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (729, 29),
                },
               ),
              ],
              recursive: false,
              position: (728, 9),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "source",
                   position: (731, 11),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  BinaryOperation {
                   operator: Addition,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (731, 20),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "system",
                        position: (731, 27),
                       },
                       Raw {
                        content: "build",
                        position: (731, 34),
                       },
                       Raw {
                        content: "initialRamdisk",
                        position: (731, 40),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/",
                       position: (731, 58),
                      },
                     ],
                    },
                   ],
                   position: (731, 55),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (731, 63),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "system",
                      position: (731, 70),
                     },
                     Raw {
                      content: "boot",
                      position: (731, 77),
                     },
                     Raw {
                      content: "loader",
                      position: (731, 82),
                     },
                     Raw {
                      content: "initrdFile",
                      position: (731, 89),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (731, 61),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "target",
                   position: (732, 11),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  String {
                   parts: [
                    Raw {
                     content: "/boot/",
                     position: (732, 21),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (732, 31),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "system",
                      position: (732, 38),
                     },
                     Raw {
                      content: "boot",
                      position: (732, 45),
                     },
                     Raw {
                      content: "loader",
                      position: (732, 50),
                     },
                     Raw {
                      content: "initrdFile",
                      position: (732, 57),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (732, 29),
                },
               ),
              ],
              recursive: false,
              position: (731, 9),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "source",
                   position: (734, 11),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (734, 20),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "system",
                    position: (734, 27),
                   },
                   Raw {
                    content: "build",
                    position: (734, 34),
                   },
                   Raw {
                    content: "squashfsStore",
                    position: (734, 40),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "target",
                   position: (735, 11),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "/nix-store.squashfs",
                   position: (735, 21),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (734, 9),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "source",
                   position: (737, 11),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (737, 20),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "writeText",
                     position: (737, 25),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "version",
                     position: (737, 36),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (737, 45),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "system",
                      position: (737, 52),
                     },
                     Raw {
                      content: "nixos",
                      position: (737, 59),
                     },
                     Raw {
                      content: "label",
                      position: (737, 65),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "target",
                   position: (738, 11),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "/version.txt",
                   position: (738, 21),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (737, 9),
             },
            ],
            position: (727, 7),
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "optionals",
               position: (740, 12),
              },
              arguments: [
               Variable {
                identifier: "canx86BiosBoot",
                position: (740, 22),
               },
               List {
                elements: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "source",
                       position: (741, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (741, 20),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "isoImage",
                        position: (741, 27),
                       },
                       Raw {
                        content: "splashImage",
                        position: (741, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "target",
                       position: (742, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/isolinux/background.png",
                       position: (742, 21),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (741, 9),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "source",
                       position: (744, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (744, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "substituteAll",
                         position: (744, 25),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "name",
                            position: (745, 13),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "isolinux.cfg",
                            position: (745, 21),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "src",
                            position: (746, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "pkgs",
                            position: (746, 19),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "writeText",
                              position: (746, 24),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: "isolinux.cfg-in",
                              position: (746, 35),
                             },
                            ],
                           },
                           Variable {
                            identifier: "isolinuxCfg",
                            position: (746, 52),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "bootRoot",
                            position: (747, 13),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "/boot",
                            position: (747, 25),
                           },
                          ],
                         },
                        ),
                       ],
                       recursive: false,
                       position: (744, 40),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "target",
                       position: (749, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/isolinux/isolinux.cfg",
                       position: (749, 21),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (744, 9),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "source",
                       position: (751, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (751, 23),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "syslinux",
                           position: (751, 28),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/share/syslinux",
                       position: (751, 37),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "target",
                       position: (752, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/isolinux",
                       position: (752, 21),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (751, 9),
                 },
                ],
                position: (740, 37),
               },
              ],
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "optionals",
                 position: (754, 12),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (754, 22),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "isoImage",
                     position: (754, 29),
                    },
                    Raw {
                     content: "makeEfiBootable",
                     position: (754, 38),
                    },
                   ],
                  },
                  default: None,
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "source",
                         position: (755, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "efiImg",
                       position: (755, 20),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "target",
                         position: (756, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/boot/efi.img",
                         position: (756, 21),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (755, 9),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "source",
                         position: (758, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: Variable {
                          identifier: "efiDir",
                          position: (758, 23),
                         },
                        },
                        Raw {
                         content: "/EFI",
                         position: (758, 30),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "target",
                         position: (759, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/EFI",
                         position: (759, 21),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (758, 9),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "source",
                         position: (761, 11),
                        },
                       ],
                      },
                      BinaryOperation {
                       operator: Addition,
                       operands: [
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (761, 21),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "writeTextDir",
                             position: (761, 26),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          String {
                           parts: [
                            Raw {
                             content: "grub/loopback.cfg",
                             position: (761, 40),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "source /EFI/boot/grub.cfg",
                             position: (761, 60),
                            },
                           ],
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "/grub",
                           position: (761, 91),
                          },
                         ],
                        },
                       ],
                       position: (761, 88),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "target",
                         position: (762, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/boot/grub",
                         position: (762, 21),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (761, 9),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "source",
                         position: (764, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (764, 20),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "isoImage",
                          position: (764, 27),
                         },
                         Raw {
                          content: "efiSplashImage",
                          position: (764, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "target",
                         position: (765, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/EFI/boot/efi-background.png",
                         position: (765, 21),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (764, 9),
                   },
                  ],
                  position: (754, 54),
                 },
                ],
               },
               BinaryOperation {
                operator: Concatenation,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionals",
                   position: (767, 12),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: LogicalAnd,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (767, 23),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "boot",
                         position: (767, 30),
                        },
                        Raw {
                         content: "loader",
                         position: (767, 35),
                        },
                        Raw {
                         content: "grub",
                         position: (767, 42),
                        },
                        Raw {
                         content: "memtest86",
                         position: (767, 47),
                        },
                        Raw {
                         content: "enable",
                         position: (767, 57),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "canx86BiosBoot",
                      position: (767, 67),
                     },
                    ],
                    position: (767, 64),
                   },
                   List {
                    elements: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "source",
                           position: (768, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (768, 23),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "memtest86plus",
                               position: (768, 28),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/memtest.bin",
                           position: (768, 42),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "target",
                           position: (769, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "/boot/memtest.bin",
                           position: (769, 21),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (768, 9),
                     },
                    ],
                    position: (767, 83),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionals",
                   position: (771, 12),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (771, 23),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "isoImage",
                         position: (771, 30),
                        },
                        Raw {
                         content: "grubTheme",
                         position: (771, 39),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (771, 52),
                     },
                    ],
                    position: (771, 49),
                   },
                   List {
                    elements: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "source",
                           position: (772, 11),
                          },
                         ],
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "config",
                          position: (772, 20),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "isoImage",
                            position: (772, 27),
                           },
                           Raw {
                            content: "grubTheme",
                            position: (772, 36),
                           },
                          ],
                         },
                         default: None,
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "target",
                           position: (773, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "/EFI/boot/grub-theme",
                           position: (773, 21),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (772, 9),
                     },
                    ],
                    position: (771, 58),
                   },
                  ],
                 },
                ],
                position: (771, 9),
               },
              ],
              position: (767, 9),
             },
            ],
            position: (754, 9),
           },
          ],
          position: (740, 9),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (777, 5),
           },
           Raw {
            content: "loader",
            position: (777, 10),
           },
           Raw {
            content: "timeout",
            position: (777, 17),
           },
          ],
         },
         Int {
          value: 10,
          position: (777, 27),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (780, 5),
           },
           Raw {
            content: "build",
            position: (780, 12),
           },
           Raw {
            content: "isoImage",
            position: (780, 18),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "pkgs",
            position: (780, 29),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "callPackage",
              position: (780, 34),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Path {
            parts: [
             Raw {
              content: "../../../lib/make-iso9660-image.nix",
              position: (780, 46),
             },
            ],
           },
           BinaryOperation {
            operator: Update,
            operands: [
             Map {
              bindings: [
               Inherit(
                Some(
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (781, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "isoImage",
                     position: (781, 23),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                [
                 Raw {
                  content: "isoName",
                  position: (781, 33),
                 },
                 Raw {
                  content: "compressImage",
                  position: (781, 41),
                 },
                 Raw {
                  content: "volumeID",
                  position: (781, 55),
                 },
                 Raw {
                  content: "contents",
                  position: (781, 64),
                 },
                ],
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "bootable",
                   position: (782, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "canx86BiosBoot",
                 position: (782, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "bootImage",
                   position: (783, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "/isolinux/isolinux.bin",
                   position: (783, 20),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "syslinux",
                   position: (784, 7),
                  },
                 ],
                },
                IfThenElse {
                 predicate: Variable {
                  identifier: "canx86BiosBoot",
                  position: (784, 21),
                 },
                 then: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (784, 41),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "syslinux",
                     position: (784, 46),
                    },
                   ],
                  },
                  default: None,
                 },
                 else_: Variable {
                  identifier: "null",
                  position: (784, 60),
                 },
                 position: (784, 18),
                },
               ),
              ],
              recursive: false,
              position: (780, 83),
             },
             BinaryOperation {
              operator: Update,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "optionalAttrs",
                 position: (785, 10),
                },
                arguments: [
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (785, 25),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "isoImage",
                       position: (785, 32),
                      },
                      Raw {
                       content: "makeUsbBootable",
                       position: (785, 41),
                      },
                     ],
                    },
                    default: None,
                   },
                   Variable {
                    identifier: "canx86BiosBoot",
                    position: (785, 60),
                   },
                  ],
                  position: (785, 57),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "usbBootable",
                       position: (786, 7),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (786, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "isohybridMbrImage",
                       position: (787, 7),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (787, 30),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "syslinux",
                           position: (787, 35),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/share/syslinux/isohdpfx.bin",
                       position: (787, 44),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (785, 76),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optionalAttrs",
                 position: (788, 10),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (788, 24),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "isoImage",
                     position: (788, 31),
                    },
                    Raw {
                     content: "makeEfiBootable",
                     position: (788, 40),
                    },
                   ],
                  },
                  default: None,
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "efiBootable",
                       position: (789, 7),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (789, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "efiBootImage",
                       position: (790, 7),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "boot/efi.img",
                       position: (790, 23),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (788, 56),
                 },
                ],
               },
              ],
              position: (788, 7),
             },
            ],
            position: (785, 7),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (793, 5),
           },
           Raw {
            content: "postBootCommands",
            position: (793, 10),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "# After booting, register the contents of the Nix store on the\n# CD in the Nix database in the tmpfs.\n",
            position: (795, 1),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (797, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "nix",
                position: (797, 18),
               },
               Raw {
                content: "package",
                position: (797, 22),
               },
               Raw {
                content: "out",
                position: (797, 30),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: "/bin/nix-store --load-db < /nix/store/nix-path-registration\n\n# nixos-rebuild also requires a \"system\" profile and an\n# /etc/NIXOS tag.\ntouch /etc/NIXOS\n",
            position: (797, 34),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (802, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "nix",
                position: (802, 18),
               },
               Raw {
                content: "package",
                position: (802, 22),
               },
               Raw {
                content: "out",
                position: (802, 30),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: "/bin/nix-env -p /nix/var/nix/profiles/system --set /run/current-system\n",
            position: (802, 34),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (807, 5),
           },
           Raw {
            content: "initrd",
            position: (807, 10),
           },
           Raw {
            content: "supportedFilesystems",
            position: (807, 17),
           },
          ],
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "vfat",
              position: (807, 43),
             },
            ],
           },
          ],
          position: (807, 40),
         },
        ),
       ],
       recursive: false,
       position: (667, 12),
      },
     ),
    ],
    recursive: false,
    position: (474, 1),
   },
   position: (9, 1),
  },
  position: (7, 1),
 },
 position: (5, 1),
}