---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "stdenv",
    default: None,
   },
   DestructuredArgument {
    identifier: "linuxHeaders",
    default: None,
   },
   DestructuredArgument {
    identifier: "parentWrapperDir",
    default: None,
   },
   DestructuredArgument {
    identifier: "debug",
    default: Some(
     Variable {
      identifier: "false",
      position: (1, 51),
     },
    ),
   },
  ],
  ellipsis: false,
 },
 definition: FunctionApplication {
  function: PropertyAccess {
   expression: Variable {
    identifier: "stdenv",
    position: (4, 1),
   },
   attribute_path: AttributePath {
    parts: [
     Raw {
      content: "mkDerivation",
      position: (4, 8),
     },
    ],
   },
   default: None,
  },
  arguments: [
   Map {
    bindings: [
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "name",
         position: (5, 3),
        },
       ],
      },
      to: String {
       parts: [
        Raw {
         content: "security-wrapper",
         position: (5, 11),
        },
       ],
       position: (5, 10),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "buildInputs",
         position: (6, 3),
        },
       ],
      },
      to: List {
       elements: [
        Variable {
         identifier: "linuxHeaders",
         position: (6, 19),
        },
       ],
       position: (6, 17),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "dontUnpack",
         position: (7, 3),
        },
       ],
      },
      to: Variable {
       identifier: "true",
       position: (7, 16),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "hardeningEnable",
         position: (8, 3),
        },
       ],
      },
      to: List {
       elements: [
        String {
         parts: [
          Raw {
           content: "pie",
           position: (8, 24),
          },
         ],
         position: (8, 23),
        },
       ],
       position: (8, 21),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "CFLAGS",
         position: (9, 3),
        },
       ],
      },
      to: BinaryOperation {
       operator: Concatenation,
       operands: [
        List {
         elements: [
          String {
           parts: [
            Raw {
             content: "-DWRAPPER_DIR=\"",
             position: (10, 7),
            },
            Interpolation {
             expression: Variable {
              identifier: "parentWrapperDir",
              position: (10, 24),
             },
            },
            Raw {
             content: "\"",
             position: (10, 41),
            },
           ],
           position: (10, 5),
          },
         ],
         position: (9, 12),
        },
        Parentheses {
         expression: IfThenElse {
          predicate: Variable {
           identifier: "debug",
           position: (11, 12),
          },
          then: List {
           elements: [
            String {
             parts: [
              Raw {
               content: "-Werror",
               position: (12, 6),
              },
             ],
             position: (12, 5),
            },
            String {
             parts: [
              Raw {
               content: "-Og",
               position: (12, 16),
              },
             ],
             position: (12, 15),
            },
            String {
             parts: [
              Raw {
               content: "-g",
               position: (12, 22),
              },
             ],
             position: (12, 21),
            },
           ],
           position: (11, 23),
          },
          else_: List {
           elements: [
            String {
             parts: [
              Raw {
               content: "-Wall",
               position: (14, 6),
              },
             ],
             position: (14, 5),
            },
            String {
             parts: [
              Raw {
               content: "-O2",
               position: (14, 14),
              },
             ],
             position: (14, 13),
            },
           ],
           position: (13, 10),
          },
          position: (11, 9),
         },
         position: (11, 8),
        },
       ],
       position: (11, 5),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "dontStrip",
         position: (16, 3),
        },
       ],
      },
      to: Variable {
       identifier: "debug",
       position: (16, 15),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "installPhase",
         position: (17, 3),
        },
       ],
      },
      to: String {
       parts: [
        Raw {
         content: "mkdir -p $out/bin\n$CC $CFLAGS ",
         position: (18, 1),
        },
        Interpolation {
         expression: Path {
          parts: [
           Raw {
            content: "./wrapper.c",
            position: (19, 19),
           },
          ],
          position: (19, 19),
         },
        },
        Raw {
         content: " -o $out/bin/security-wrapper\n",
         position: (19, 31),
        },
       ],
       position: (17, 18),
      },
     },
    ],
    recursive: false,
    position: (4, 21),
   },
  ],
 },
 position: (1, 1),
}