---
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: (6, 6),
  },
  target: Map {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "options",
        position: (9, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "netboot",
           position: (11, 5),
          },
          Raw {
           content: "storeContents",
           position: (11, 13),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkOption",
          position: (11, 29),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "example",
                position: (12, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "literalExpression",
               position: (12, 17),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "[ pkgs.stdenv ]",
                  position: (12, 36),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (13, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "This option lists additional derivations to be included in the\nNix store in the generated netboot image.\n",
                position: (14, 1),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (11, 38),
          },
         ],
        },
       ),
      ],
      recursive: false,
      position: (9, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "config",
        position: (21, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "boot",
           position: (24, 5),
          },
          Raw {
           content: "loader",
           position: (24, 10),
          },
          Raw {
           content: "grub",
           position: (24, 17),
          },
          Raw {
           content: "enable",
           position: (24, 22),
          },
         ],
        },
        Variable {
         identifier: "false",
         position: (24, 31),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "environment",
           position: (27, 5),
          },
          Raw {
           content: "systemPackages",
           position: (27, 17),
          },
         ],
        },
        BinaryOperation {
         operator: Concatenation,
         operands: [
          List {
           elements: [
            PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (27, 36),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "grub2_efi",
                position: (27, 41),
               },
              ],
             },
             default: None,
            },
           ],
           position: (27, 34),
          },
          IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (28, 14),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "stdenv",
                 position: (28, 19),
                },
                Raw {
                 content: "hostPlatform",
                 position: (28, 26),
                },
                Raw {
                 content: "system",
                 position: (28, 39),
                },
               ],
              },
              default: None,
             },
             String {
              parts: [
               Raw {
                content: "aarch64-linux",
                position: (28, 50),
               },
              ],
             },
            ],
            position: (28, 46),
           },
           then: List {
            elements: [],
            position: (29, 16),
           },
           else_: List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (30, 18),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "grub2",
                 position: (30, 23),
                },
               ],
              },
              default: None,
             },
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (30, 29),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "syslinux",
                 position: (30, 34),
                },
               ],
              },
              default: None,
             },
            ],
            position: (30, 16),
           },
           position: (28, 11),
          },
         ],
         position: (28, 7),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "fileSystems",
           position: (32, 5),
          },
          Expression {
           expression: String {
            parts: [
             Raw {
              content: "/",
              position: (32, 18),
             },
            ],
           },
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkImageMediaOverride",
          position: (32, 23),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "fsType",
                position: (33, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "tmpfs",
                position: (33, 19),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (34, 9),
               },
              ],
             },
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "mode=0755",
                  position: (34, 22),
                 },
                ],
               },
              ],
              position: (34, 19),
             },
            ),
           ],
           recursive: false,
           position: (33, 7),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "fileSystems",
           position: (39, 5),
          },
          Expression {
           expression: String {
            parts: [
             Raw {
              content: "/nix/.ro-store",
              position: (39, 18),
             },
            ],
           },
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkImageMediaOverride",
          position: (39, 36),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "fsType",
                position: (40, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "squashfs",
                position: (40, 19),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "device",
                position: (41, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "../nix-store.squashfs",
                position: (41, 19),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (42, 9),
               },
              ],
             },
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "loop",
                  position: (42, 22),
                 },
                ],
               },
              ],
              position: (42, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "neededForBoot",
                position: (43, 9),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (43, 25),
             },
            ),
           ],
           recursive: false,
           position: (40, 7),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "fileSystems",
           position: (46, 5),
          },
          Expression {
           expression: String {
            parts: [
             Raw {
              content: "/nix/.rw-store",
              position: (46, 18),
             },
            ],
           },
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkImageMediaOverride",
          position: (46, 36),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "fsType",
                position: (47, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "tmpfs",
                position: (47, 19),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (48, 9),
               },
              ],
             },
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "mode=0755",
                  position: (48, 22),
                 },
                ],
               },
              ],
              position: (48, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "neededForBoot",
                position: (49, 9),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (49, 25),
             },
            ),
           ],
           recursive: false,
           position: (47, 7),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "fileSystems",
           position: (52, 5),
          },
          Expression {
           expression: String {
            parts: [
             Raw {
              content: "/nix/store",
              position: (52, 18),
             },
            ],
           },
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkImageMediaOverride",
          position: (52, 32),
         },
         arguments: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "fsType",
                position: (53, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "overlay",
                position: (53, 19),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "device",
                position: (54, 9),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "overlay",
                position: (54, 19),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (55, 9),
               },
              ],
             },
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "lowerdir=/nix/.ro-store",
                  position: (56, 12),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "upperdir=/nix/.rw-store/store",
                  position: (57, 12),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "workdir=/nix/.rw-store/work",
                  position: (58, 12),
                 },
                ],
               },
              ],
              position: (55, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "depends",
                position: (61, 9),
               },
              ],
             },
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "/nix/.ro-store",
                  position: (62, 12),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "/nix/.rw-store/store",
                  position: (63, 12),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "/nix/.rw-store/work",
                  position: (64, 12),
                 },
                ],
               },
              ],
              position: (61, 19),
             },
            ),
           ],
           recursive: false,
           position: (53, 7),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "boot",
           position: (68, 5),
          },
          Raw {
           content: "initrd",
           position: (68, 10),
          },
          Raw {
           content: "availableKernelModules",
           position: (68, 17),
          },
         ],
        },
        List {
         elements: [
          String {
           parts: [
            Raw {
             content: "squashfs",
             position: (68, 45),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "overlay",
             position: (68, 56),
            },
           ],
          },
         ],
         position: (68, 42),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "boot",
           position: (70, 5),
          },
          Raw {
           content: "initrd",
           position: (70, 10),
          },
          Raw {
           content: "kernelModules",
           position: (70, 17),
          },
         ],
        },
        List {
         elements: [
          String {
           parts: [
            Raw {
             content: "loop",
             position: (70, 36),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "overlay",
             position: (70, 43),
            },
           ],
          },
         ],
         position: (70, 33),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "netboot",
           position: (74, 5),
          },
          Raw {
           content: "storeContents",
           position: (74, 13),
          },
         ],
        },
        List {
         elements: [
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (75, 9),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "system",
              position: (75, 16),
             },
             Raw {
              content: "build",
              position: (75, 23),
             },
             Raw {
              content: "toplevel",
              position: (75, 29),
             },
            ],
           },
           default: None,
          },
         ],
         position: (75, 7),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "system",
           position: (78, 5),
          },
          Raw {
           content: "build",
           position: (78, 12),
          },
          Raw {
           content: "squashfsStore",
           position: (78, 18),
          },
         ],
        },
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "pkgs",
           position: (78, 34),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "callPackage",
             position: (78, 39),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Path {
           parts: [
            Raw {
             content: "../../../lib/make-squashfs.nix",
             position: (78, 51),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "storeContents",
                position: (79, 7),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (79, 23),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "netboot",
                 position: (79, 30),
                },
                Raw {
                 content: "storeContents",
                 position: (79, 38),
                },
               ],
              },
              default: None,
             },
            ),
           ],
           recursive: false,
           position: (78, 82),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "system",
           position: (84, 5),
          },
          Raw {
           content: "build",
           position: (84, 12),
          },
          Raw {
           content: "netbootRamdisk",
           position: (84, 18),
          },
         ],
        },
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "pkgs",
           position: (84, 35),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "makeInitrd",
             position: (84, 40),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Map {
           bindings: [
            Inherit(
             Some(
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (85, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "boot",
                  position: (85, 23),
                 },
                 Raw {
                  content: "initrd",
                  position: (85, 28),
                 },
                ],
               },
               default: None,
              },
             ),
             [
              Raw {
               content: "compressor",
               position: (85, 36),
              },
             ],
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "prepend",
                position: (86, 7),
               },
              ],
             },
             List {
              elements: [
               String {
                parts: [
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (86, 22),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "system",
                      position: (86, 29),
                     },
                     Raw {
                      content: "build",
                      position: (86, 36),
                     },
                     Raw {
                      content: "initialRamdisk",
                      position: (86, 42),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: "/initrd",
                  position: (86, 57),
                 },
                ],
               },
              ],
              position: (86, 17),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "contents",
                position: (88, 7),
               },
              ],
             },
             List {
              elements: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "object",
                     position: (89, 13),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (89, 22),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "system",
                      position: (89, 29),
                     },
                     Raw {
                      content: "build",
                      position: (89, 36),
                     },
                     Raw {
                      content: "squashfsStore",
                      position: (89, 42),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "symlink",
                     position: (90, 13),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "/nix-store.squashfs",
                     position: (90, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (89, 11),
               },
              ],
              position: (89, 9),
             },
            ),
           ],
           recursive: false,
           position: (84, 51),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "system",
           position: (95, 5),
          },
          Raw {
           content: "build",
           position: (95, 12),
          },
          Raw {
           content: "netbootIpxeScript",
           position: (95, 18),
          },
         ],
        },
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "pkgs",
           position: (95, 38),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "writeTextDir",
             position: (95, 43),
            },
           ],
          },
          default: None,
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "netboot.ipxe",
             position: (95, 57),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "#!ipxe\n# Use the cmdline variable to allow the user to specify custom kernel params\n# when chainloading this script from other iPXE scripts like netboot.xyz\nkernel ",
             position: (96, 1),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (99, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "stdenv",
                 position: (99, 21),
                },
                Raw {
                 content: "hostPlatform",
                 position: (99, 28),
                },
                Raw {
                 content: "linux-kernel",
                 position: (99, 41),
                },
                Raw {
                 content: "target",
                 position: (99, 54),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: " init=",
             position: (99, 61),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (99, 69),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "system",
                 position: (99, 76),
                },
                Raw {
                 content: "build",
                 position: (99, 83),
                },
                Raw {
                 content: "toplevel",
                 position: (99, 89),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "/init initrd=initrd ",
             position: (99, 98),
            },
            Expression {
             expression: FunctionApplication {
              function: Variable {
               identifier: "toString",
               position: (99, 120),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (99, 129),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "boot",
                   position: (99, 136),
                  },
                  Raw {
                   content: "kernelParams",
                   position: (99, 141),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            },
            Raw {
             content: " ",
             position: (99, 154),
            },
            Raw {
             content: "$",
             position: (99, 155),
            },
            Raw {
             content: "{cmdline}\ninitrd initrd\nboot\n",
             position: (99, 158),
            },
           ],
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "boot",
           position: (104, 5),
          },
          Raw {
           content: "loader",
           position: (104, 10),
          },
          Raw {
           content: "timeout",
           position: (104, 17),
          },
         ],
        },
        Int {
         value: 10,
         position: (104, 27),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "boot",
           position: (106, 5),
          },
          Raw {
           content: "postBootCommands",
           position: (106, 10),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "# After booting, register the contents of the Nix store\n# in the Nix database in the tmpfs.\n",
           position: (108, 1),
          },
          Expression {
           expression: PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (110, 11),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "nix",
               position: (110, 18),
              },
              Raw {
               content: "package",
               position: (110, 22),
              },
             ],
            },
            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: (110, 30),
          },
          Expression {
           expression: PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (115, 11),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "nix",
               position: (115, 18),
              },
              Raw {
               content: "package",
               position: (115, 22),
              },
             ],
            },
            default: None,
           },
          },
          Raw {
           content: "/bin/nix-env -p /nix/var/nix/profiles/system --set /run/current-system\n",
           position: (115, 30),
          },
         ],
        },
       ),
      ],
      recursive: false,
      position: (21, 12),
     },
    ),
   ],
   recursive: false,
   position: (8, 1),
  },
  position: (6, 1),
 },
 position: (4, 1),
}