---
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: "versionFile",
        position: (11, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (11, 17),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (11, 22),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "nixos-label",
          position: (11, 33),
         },
        ],
       },
       PropertyAccess {
        expression: Variable {
         identifier: "config",
         position: (11, 46),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "system",
           position: (11, 53),
          },
          Raw {
           content: "nixos",
           position: (11, 60),
          },
          Raw {
           content: "label",
           position: (11, 66),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (16, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "tarball",
            position: (17, 5),
           },
           Raw {
            content: "contents",
            position: (17, 13),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (17, 24),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (18, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (18, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "[ { source = pkgs.memtest86 + \"/memtest.bin\";\n    target = \"boot/memtest.bin\";\n  }\n]\n",
                   position: (19, 1),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (24, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "This option lists files to be copied to fixed locations in the\ngenerated ISO image.\n",
                 position: (25, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (17, 33),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "tarball",
            position: (30, 5),
           },
           Raw {
            content: "storeContents",
            position: (30, 13),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (30, 29),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (31, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (31, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "[ pkgs.stdenv ]",
                   position: (31, 36),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (32, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "This option lists additional derivations to be included in the\nNix store in the generated ISO image.\n",
                 position: (33, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (30, 38),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (16, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (40, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "fileSystems",
            position: (44, 5),
           },
          ],
         },
         Map {
          bindings: [],
          recursive: false,
          position: (44, 19),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "tarball",
            position: (52, 5),
           },
           Raw {
            content: "storeContents",
            position: (52, 13),
           },
          ],
         },
         List {
          elements: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "object",
                 position: (53, 11),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (53, 20),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "system",
                  position: (53, 27),
                 },
                 Raw {
                  content: "build",
                  position: (53, 34),
                 },
                 Raw {
                  content: "toplevel",
                  position: (53, 40),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "symlink",
                 position: (54, 11),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/run/current-system",
                 position: (54, 22),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (53, 9),
           },
          ],
          position: (53, 7),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "tarball",
            position: (60, 5),
           },
           Raw {
            content: "contents",
            position: (60, 13),
           },
          ],
         },
         List {
          elements: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "source",
                 position: (61, 11),
                },
               ],
              },
              BinaryOperation {
               operator: Addition,
               operands: [
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (61, 20),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "system",
                      position: (61, 27),
                     },
                     Raw {
                      content: "build",
                      position: (61, 34),
                     },
                     Raw {
                      content: "initialRamdisk",
                      position: (61, 40),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "/",
                     position: (61, 58),
                    },
                   ],
                  },
                 ],
                 position: (61, 55),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (61, 63),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "system",
                    position: (61, 70),
                   },
                   Raw {
                    content: "boot",
                    position: (61, 77),
                   },
                   Raw {
                    content: "loader",
                    position: (61, 82),
                   },
                   Raw {
                    content: "initrdFile",
                    position: (61, 89),
                   },
                  ],
                 },
                 default: None,
                },
               ],
               position: (61, 61),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "target",
                 position: (62, 11),
                },
               ],
              },
              BinaryOperation {
               operator: Addition,
               operands: [
                String {
                 parts: [
                  Raw {
                   content: "/boot/",
                   position: (62, 21),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (62, 31),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "system",
                    position: (62, 38),
                   },
                   Raw {
                    content: "boot",
                    position: (62, 45),
                   },
                   Raw {
                    content: "loader",
                    position: (62, 50),
                   },
                   Raw {
                    content: "initrdFile",
                    position: (62, 57),
                   },
                  ],
                 },
                 default: None,
                },
               ],
               position: (62, 29),
              },
             ),
            ],
            recursive: false,
            position: (61, 9),
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "source",
                 position: (64, 11),
                },
               ],
              },
              Variable {
               identifier: "versionFile",
               position: (64, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "target",
                 position: (65, 11),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/nixos-version.txt",
                 position: (65, 21),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (64, 9),
           },
          ],
          position: (61, 7),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (70, 5),
           },
           Raw {
            content: "build",
            position: (70, 12),
           },
           Raw {
            content: "tarball",
            position: (70, 18),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "import",
           position: (70, 28),
          },
          arguments: [
           Path {
            parts: [
             Raw {
              content: "../../../lib/make-system-tarball.nix",
              position: (70, 35),
             },
            ],
           },
           Map {
            bindings: [
             Inherit(
              Some(
               Variable {
                identifier: "pkgs",
                position: (71, 16),
               },
              ),
              [
               Raw {
                content: "stdenv",
                position: (71, 22),
               },
               Raw {
                content: "closureInfo",
                position: (71, 29),
               },
               Raw {
                content: "pixz",
                position: (71, 41),
               },
              ],
             ),
             Inherit(
              Some(
               PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (73, 16),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "tarball",
                   position: (73, 23),
                  },
                 ],
                },
                default: None,
               },
              ),
              [
               Raw {
                content: "contents",
                position: (73, 32),
               },
               Raw {
                content: "storeContents",
                position: (73, 41),
               },
              ],
             ),
            ],
            recursive: false,
            position: (70, 72),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (76, 5),
           },
           Raw {
            content: "postBootCommands",
            position: (76, 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.\nif [ -f /nix-path-registration ]; then\n  ",
            position: (78, 1),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (81, 13),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "nix",
                position: (81, 20),
               },
               Raw {
                content: "package",
                position: (81, 24),
               },
               Raw {
                content: "out",
                position: (81, 32),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: "/bin/nix-store --load-db < /nix-path-registration &&\n  rm /nix-path-registration\nfi\n\n# nixos-rebuild also requires a \"system\" profile and an\n# /etc/NIXOS tag.\ntouch /etc/NIXOS\n",
            position: (81, 36),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (88, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "nix",
                position: (88, 18),
               },
               Raw {
                content: "package",
                position: (88, 22),
               },
               Raw {
                content: "out",
                position: (88, 30),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: "/bin/nix-env -p /nix/var/nix/profiles/system --set /run/current-system\n",
            position: (88, 34),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (40, 12),
      },
     ),
    ],
    recursive: false,
    position: (15, 1),
   },
   position: (9, 1),
  },
  position: (7, 1),
 },
 position: (5, 1),
}