---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "config",
    default: None,
   },
   DestructuredArgument {
    identifier: "lib",
    default: None,
   },
   DestructuredArgument {
    identifier: "pkgs",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "dummyConfiguration",
        position: (13, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (13, 24),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "writeText",
          position: (13, 29),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "configuration.nix",
          position: (13, 40),
         },
        ],
        position: (13, 39),
       },
       String {
        parts: [
         Raw {
          content: "{ config, pkgs, ... }:\n\n{ # Add your own options below, e.g.:\n  #   services.openssh.enable = true;\n  nixpkgs.config.platform = pkgs.platforms.fuloong2f_n32;\n}\n",
          position: (15, 1),
         },
        ],
        position: (14, 5),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "pkgs2storeContents",
        position: (24, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "l",
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "map",
        position: (24, 28),
       },
       arguments: [
        Parentheses {
         expression: Function {
          argument: Simple {
           identifier: "x",
          },
          definition: Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "object",
                position: (24, 38),
               },
              ],
             },
             to: Variable {
              identifier: "x",
              position: (24, 47),
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "symlink",
                position: (24, 50),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "none",
                position: (24, 61),
               },
              ],
              position: (24, 60),
             },
            },
           ],
           recursive: false,
           position: (24, 36),
          },
          position: (24, 33),
         },
         position: (24, 32),
        },
        Variable {
         identifier: "l",
         position: (24, 71),
        },
       ],
      },
      position: (24, 24),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "kernelParams",
        position: (27, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (27, 18),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "writeText",
          position: (27, 23),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "kernel-params.txt",
          position: (27, 34),
         },
        ],
        position: (27, 33),
       },
       String {
        parts: [
         Raw {
          content: "Kernel Parameters:\n  init=/boot/init ",
          position: (28, 1),
         },
         Interpolation {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (29, 25),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "config",
              position: (29, 34),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "boot",
                position: (29, 41),
               },
               Raw {
                content: "kernelParams",
                position: (29, 46),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (29, 59),
         },
        ],
        position: (27, 53),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "nixpkgsUserConfig",
        position: (33, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (33, 23),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "writeText",
          position: (33, 28),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "config.nix",
          position: (33, 39),
         },
        ],
        position: (33, 38),
       },
       String {
        parts: [
         Raw {
          content: "pkgs:\n{\n  platform = pkgs.platforms.fuloong2f_n32;\n}\n",
          position: (34, 1),
         },
        ],
        position: (33, 51),
       },
      ],
     },
    },
   ],
   target: Map {
    bindings: [
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "imports",
         position: (43, 3),
        },
       ],
      },
      to: List {
       elements: [
        Path {
         parts: [
          Raw {
           content: "./system-tarball.nix",
           position: (43, 15),
          },
         ],
         position: (43, 15),
        },
       ],
       position: (43, 13),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "security",
         position: (46, 3),
        },
        Raw {
         content: "sudo",
         position: (46, 12),
        },
        Raw {
         content: "enable",
         position: (46, 17),
        },
       ],
      },
      to: Variable {
       identifier: "false",
       position: (46, 26),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "i18n",
         position: (50, 3),
        },
        Raw {
         content: "supportedLocales",
         position: (50, 8),
        },
       ],
      },
      to: List {
       elements: [
        String {
         parts: [
          Raw {
           content: "en_US.UTF-8/UTF-8",
           position: (50, 29),
          },
         ],
         position: (50, 28),
        },
        String {
         parts: [
          Raw {
           content: "en_US/ISO-8859-1",
           position: (50, 49),
          },
         ],
         position: (50, 48),
        },
       ],
       position: (50, 27),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "environment",
         position: (54, 3),
        },
        Raw {
         content: "systemPackages",
         position: (54, 15),
        },
       ],
      },
      to: List {
       elements: [
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (55, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "w3m",
            position: (55, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (56, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "testdisk",
            position: (56, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (57, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "ms-sys",
            position: (57, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (58, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "parted",
            position: (58, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (59, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "ddrescue",
            position: (59, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (60, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "ccrypt",
            position: (60, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (61, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "cryptsetup",
            position: (61, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (64, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "sshfs-fuse",
            position: (64, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (65, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "socat",
            position: (65, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (66, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "screen",
            position: (66, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (67, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "wpa_supplicant",
            position: (67, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (70, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "sdparm",
            position: (70, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (71, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "hdparm",
            position: (71, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (72, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "dmraid",
            position: (72, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (75, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "ntfsprogs",
            position: (75, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (76, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "btrfs-progs",
            position: (76, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (77, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "jfsutils",
            position: (77, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (80, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "unzip",
            position: (80, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (81, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "zip",
            position: (81, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (82, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "xz",
            position: (82, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (83, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "dar",
            position: (83, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (86, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "nvi",
            position: (86, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (87, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "bvi",
            position: (87, 12),
           },
          ],
         },
         default: None,
        },
        PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (88, 7),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "joe",
            position: (88, 12),
           },
          ],
         },
         default: None,
        },
       ],
       position: (55, 5),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "boot",
         position: (93, 3),
        },
        Raw {
         content: "initrd",
         position: (93, 8),
        },
        Raw {
         content: "availableKernelModules",
         position: (93, 15),
        },
       ],
      },
      to: List {
       elements: [
        String {
         parts: [
          Raw {
           content: "vfat",
           position: (94, 8),
          },
         ],
         position: (94, 7),
        },
        String {
         parts: [
          Raw {
           content: "reiserfs",
           position: (94, 15),
          },
         ],
         position: (94, 14),
        },
       ],
       position: (94, 5),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "boot",
         position: (96, 3),
        },
        Raw {
         content: "kernelPackages",
         position: (96, 8),
        },
       ],
      },
      to: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (96, 25),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "linuxKernel",
          position: (96, 30),
         },
         Raw {
          content: "packages",
          position: (96, 42),
         },
         Raw {
          content: "linux_3_10",
          position: (96, 51),
         },
        ],
       },
       default: None,
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "boot",
         position: (97, 3),
        },
        Raw {
         content: "kernelParams",
         position: (97, 8),
        },
       ],
      },
      to: List {
       elements: [
        String {
         parts: [
          Raw {
           content: "console=tty1",
           position: (97, 26),
          },
         ],
         position: (97, 25),
        },
       ],
       position: (97, 23),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "boot",
         position: (99, 3),
        },
        Raw {
         content: "postBootCommands",
         position: (99, 8),
        },
       ],
      },
      to: String {
       parts: [
        Raw {
         content: "mkdir -p /mnt\n\ncp ",
         position: (101, 1),
        },
        Interpolation {
         expression: Variable {
          identifier: "dummyConfiguration",
          position: (103, 12),
         },
        },
        Raw {
         content: " /etc/nixos/configuration.nix\n",
         position: (103, 31),
        },
       ],
       position: (100, 5),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "services",
         position: (107, 3),
        },
        Raw {
         content: "getty",
         position: (107, 12),
        },
        Raw {
         content: "helpLine",
         position: (107, 18),
        },
       ],
      },
      to: String {
       parts: [
        Raw {
         content: "\nLog in as \"root\" with an empty password.  ",
         position: (109, 1),
        },
        Interpolation {
         expression: IfThenElse {
          predicate: PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (111, 12),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "services",
              position: (111, 19),
             },
             Raw {
              content: "xserver",
              position: (111, 28),
             },
             Raw {
              content: "enable",
              position: (111, 36),
             },
            ],
           },
           default: None,
          },
          then: String {
           parts: [
            Raw {
             content: "Type `start xserver' to start\nthe graphical user interface.",
             position: (112, 12),
            },
           ],
           position: (112, 11),
          },
          else_: String {
           parts: [],
           position: (113, 14),
          },
          position: (111, 9),
         },
        },
        Raw {
         content: "\n",
         position: (114, 8),
        },
       ],
       position: (108, 5),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "networking",
         position: (118, 3),
        },
        Raw {
         content: "enableRalinkFirmware",
         position: (118, 14),
        },
       ],
      },
      to: Variable {
       identifier: "true",
       position: (118, 37),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "networking",
         position: (119, 3),
        },
        Raw {
         content: "enableIntel2200BGFirmware",
         position: (119, 14),
        },
       ],
      },
      to: Variable {
       identifier: "true",
       position: (119, 42),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "tarball",
         position: (123, 3),
        },
        Raw {
         content: "storeContents",
         position: (123, 11),
        },
       ],
      },
      to: BinaryOperation {
       operator: Concatenation,
       operands: [
        FunctionApplication {
         function: Variable {
          identifier: "pkgs2storeContents",
          position: (123, 27),
         },
         arguments: [
          List {
           elements: [
            PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (123, 48),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "stdenv",
                position: (123, 53),
               },
              ],
             },
             default: None,
            },
           ],
           position: (123, 46),
          },
         ],
        },
        List {
         elements: [
          Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "object",
                position: (126, 9),
               },
              ],
             },
             to: PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (126, 18),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "system",
                 position: (126, 25),
                },
                Raw {
                 content: "build",
                 position: (126, 32),
                },
                Raw {
                 content: "bootStage2",
                 position: (126, 38),
                },
               ],
              },
              default: None,
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "symlink",
                position: (127, 9),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "/boot/init",
                position: (127, 20),
               },
              ],
              position: (127, 19),
             },
            },
           ],
           recursive: false,
           position: (125, 7),
          },
          Map {
           bindings: [
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "object",
                position: (130, 9),
               },
              ],
             },
             to: PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (130, 18),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "system",
                 position: (130, 25),
                },
                Raw {
                 content: "build",
                 position: (130, 32),
                },
                Raw {
                 content: "toplevel",
                 position: (130, 38),
                },
               ],
              },
              default: None,
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "symlink",
                position: (131, 9),
               },
              ],
             },
             to: String {
              parts: [
               Raw {
                content: "/boot/system",
                position: (131, 20),
               },
              ],
              position: (131, 19),
             },
            },
           ],
           recursive: false,
           position: (129, 7),
          },
         ],
         position: (124, 8),
        },
       ],
       position: (124, 5),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "tarball",
         position: (135, 3),
        },
        Raw {
         content: "contents",
         position: (135, 11),
        },
       ],
      },
      to: List {
       elements: [
        Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "source",
              position: (136, 7),
             },
            ],
           },
           to: Variable {
            identifier: "kernelParams",
            position: (136, 16),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "target",
              position: (137, 7),
             },
            ],
           },
           to: String {
            parts: [
             Raw {
              content: "/kernelparams.txt",
              position: (137, 17),
             },
            ],
            position: (137, 16),
           },
          },
         ],
         recursive: false,
         position: (136, 5),
        },
        Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "source",
              position: (139, 7),
             },
            ],
           },
           to: BinaryOperation {
            operator: Addition,
            operands: [
             BinaryOperation {
              operator: Addition,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (139, 16),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "boot",
                   position: (139, 23),
                  },
                  Raw {
                   content: "kernelPackages",
                   position: (139, 28),
                  },
                  Raw {
                   content: "kernel",
                   position: (139, 43),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "/",
                  position: (139, 53),
                 },
                ],
                position: (139, 52),
               },
              ],
              position: (139, 50),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (139, 58),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "system",
                 position: (139, 65),
                },
                Raw {
                 content: "boot",
                 position: (139, 72),
                },
                Raw {
                 content: "loader",
                 position: (139, 77),
                },
                Raw {
                 content: "kernelFile",
                 position: (139, 84),
                },
               ],
              },
              default: None,
             },
            ],
            position: (139, 56),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "target",
              position: (140, 7),
             },
            ],
           },
           to: BinaryOperation {
            operator: Addition,
            operands: [
             String {
              parts: [
               Raw {
                content: "/boot/",
                position: (140, 17),
               },
              ],
              position: (140, 16),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (140, 27),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "system",
                 position: (140, 34),
                },
                Raw {
                 content: "boot",
                 position: (140, 41),
                },
                Raw {
                 content: "loader",
                 position: (140, 46),
                },
                Raw {
                 content: "kernelFile",
                 position: (140, 53),
                },
               ],
              },
              default: None,
             },
            ],
            position: (140, 25),
           },
          },
         ],
         recursive: false,
         position: (139, 5),
        },
        Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "source",
              position: (142, 7),
             },
            ],
           },
           to: Variable {
            identifier: "nixpkgsUserConfig",
            position: (142, 16),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "target",
              position: (143, 7),
             },
            ],
           },
           to: String {
            parts: [
             Raw {
              content: "/root/.nixpkgs/config.nix",
              position: (143, 17),
             },
            ],
            position: (143, 16),
           },
          },
         ],
         recursive: false,
         position: (142, 5),
        },
       ],
       position: (135, 22),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "services",
         position: (150, 3),
        },
        Raw {
         content: "openssh",
         position: (150, 12),
        },
        Raw {
         content: "enable",
         position: (150, 20),
        },
       ],
      },
      to: Variable {
       identifier: "true",
       position: (150, 29),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "systemd",
         position: (151, 3),
        },
        Raw {
         content: "services",
         position: (151, 11),
        },
        Raw {
         content: "openssh",
         position: (151, 20),
        },
        Raw {
         content: "wantedBy",
         position: (151, 28),
        },
       ],
      },
      to: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "lib",
         position: (151, 39),
        },
        attribute_path: AttributePath {
         parts: [
          Raw {
           content: "mkOverride",
           position: (151, 43),
          },
         ],
        },
        default: None,
       },
       arguments: [
        Int {
         value: 50,
         position: (151, 54),
        },
        List {
         elements: [],
         position: (151, 57),
        },
       ],
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "boot",
         position: (153, 3),
        },
        Raw {
         content: "loader",
         position: (153, 8),
        },
        Raw {
         content: "grub",
         position: (153, 15),
        },
        Raw {
         content: "enable",
         position: (153, 20),
        },
       ],
      },
      to: Variable {
       identifier: "false",
       position: (153, 29),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "boot",
         position: (154, 3),
        },
        Raw {
         content: "loader",
         position: (154, 8),
        },
        Raw {
         content: "generationsDir",
         position: (154, 15),
        },
        Raw {
         content: "enable",
         position: (154, 30),
        },
       ],
      },
      to: Variable {
       identifier: "false",
       position: (154, 39),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "system",
         position: (155, 3),
        },
        Raw {
         content: "boot",
         position: (155, 10),
        },
        Raw {
         content: "loader",
         position: (155, 15),
        },
        Raw {
         content: "kernelFile",
         position: (155, 22),
        },
       ],
      },
      to: String {
       parts: [
        Raw {
         content: "vmlinux",
         position: (155, 36),
        },
       ],
       position: (155, 35),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "nixpkgs",
         position: (157, 3),
        },
        Raw {
         content: "config",
         position: (157, 11),
        },
       ],
      },
      to: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "platform",
            position: (158, 5),
           },
          ],
         },
         to: PropertyAccess {
          expression: Variable {
           identifier: "pkgs",
           position: (158, 16),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "platforms",
             position: (158, 21),
            },
            Raw {
             content: "fuloong2f_n32",
             position: (158, 31),
            },
           ],
          },
          default: None,
         },
        },
       ],
       recursive: false,
       position: (157, 20),
      },
     },
    ],
    recursive: false,
    position: (42, 1),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}