---
Function {
 argument: Some(
  "f",
 ),
 arguments: FunctionArguments {
  arguments: [],
  ellipsis: false,
 },
 definition: Function {
  argument: Some(
   "x",
  ),
  arguments: FunctionArguments {
   arguments: [],
   ellipsis: false,
  },
  definition: Function {
   argument: Some(
    "y",
   ),
   arguments: FunctionArguments {
    arguments: [],
    ellipsis: false,
   },
   definition: LetIn {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "intToBits",
         position: (8, 5),
        },
       ],
      },
      Function {
       argument: Some(
        "x",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: IfThenElse {
        predicate: BinaryOperation {
         operator: LogicalOr,
         operands: [
          BinaryOperation {
           operator: EqualTo,
           operands: [
            Variable {
             identifier: "x",
             position: (9, 10),
            },
            Int {
             value: 0,
             position: (9, 15),
            },
           ],
           position: (9, 12),
          },
          BinaryOperation {
           operator: EqualTo,
           operands: [
            Variable {
             identifier: "x",
             position: (9, 20),
            },
            UnaryOperation {
             operator: Negate,
             operand: Int {
              value: 1,
              position: (9, 26),
             },
             position: (9, 25),
            },
           ],
           position: (9, 22),
          },
         ],
         position: (9, 17),
        },
        then: List {
         elements: [],
         position: (10, 9),
        },
        else_: LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "headbit",
              position: (13, 11),
             },
            ],
           },
           IfThenElse {
            predicate: BinaryOperation {
             operator: NotEqualTo,
             operands: [
              BinaryOperation {
               operator: Multiplication,
               operands: [
                BinaryOperation {
                 operator: Division,
                 operands: [
                  Variable {
                   identifier: "x",
                   position: (13, 26),
                  },
                  Int {
                   value: 2,
                   position: (13, 30),
                  },
                 ],
                 position: (13, 28),
                },
                Int {
                 value: 2,
                 position: (13, 35),
                },
               ],
               position: (13, 33),
              },
              Variable {
               identifier: "x",
               position: (13, 40),
              },
             ],
             position: (13, 37),
            },
            then: Int {
             value: 1,
             position: (13, 47),
            },
            else_: Int {
             value: 0,
             position: (13, 54),
            },
            position: (13, 22),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "tailbits",
              position: (14, 11),
             },
            ],
           },
           IfThenElse {
            predicate: BinaryOperation {
             operator: LessThan,
             operands: [
              Variable {
               identifier: "x",
               position: (14, 25),
              },
              Int {
               value: 0,
               position: (14, 29),
              },
             ],
             position: (14, 27),
            },
            then: BinaryOperation {
             operator: Subtraction,
             operands: [
              BinaryOperation {
               operator: Division,
               operands: [
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  Variable {
                   identifier: "x",
                   position: (14, 38),
                  },
                  Int {
                   value: 1,
                   position: (14, 42),
                  },
                 ],
                 position: (14, 40),
                },
                Int {
                 value: 2,
                 position: (14, 47),
                },
               ],
               position: (14, 45),
              },
              Int {
               value: 1,
               position: (14, 52),
              },
             ],
             position: (14, 50),
            },
            else_: BinaryOperation {
             operator: Division,
             operands: [
              Variable {
               identifier: "x",
               position: (14, 59),
              },
              Int {
               value: 2,
               position: (14, 63),
              },
             ],
             position: (14, 61),
            },
            position: (14, 22),
           },
          ),
         ],
         target: BinaryOperation {
          operator: Concatenation,
          operands: [
           List {
            elements: [
             Variable {
              identifier: "headbit",
              position: (16, 12),
             },
            ],
            position: (16, 11),
           },
           FunctionApplication {
            function: Variable {
             identifier: "intToBits",
             position: (16, 25),
            },
            arguments: [
             Variable {
              identifier: "tailbits",
              position: (16, 35),
             },
            ],
           },
          ],
          position: (16, 21),
         },
         position: (12, 9),
        },
        position: (9, 7),
       },
       position: (8, 17),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "bitsToInt",
         position: (20, 5),
        },
       ],
      },
      Function {
       argument: Some(
        "l",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "signum",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: IfThenElse {
         predicate: BinaryOperation {
          operator: EqualTo,
          operands: [
           Variable {
            identifier: "l",
            position: (21, 10),
           },
           List {
            elements: [],
            position: (21, 15),
           },
          ],
          position: (21, 12),
         },
         then: IfThenElse {
          predicate: BinaryOperation {
           operator: EqualTo,
           operands: [
            Variable {
             identifier: "signum",
             position: (22, 13),
            },
            Int {
             value: 0,
             position: (22, 23),
            },
           ],
           position: (22, 20),
          },
          then: Int {
           value: 0,
           position: (22, 30),
          },
          else_: UnaryOperation {
           operator: Negate,
           operand: Int {
            value: 1,
            position: (22, 38),
           },
           position: (22, 37),
          },
          position: (22, 10),
         },
         else_: BinaryOperation {
          operator: Addition,
          operands: [
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (24, 10),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "head",
                position: (24, 19),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "l",
              position: (24, 24),
             },
            ],
           },
           BinaryOperation {
            operator: Multiplication,
            operands: [
             Int {
              value: 2,
              position: (24, 30),
             },
             FunctionApplication {
              function: Variable {
               identifier: "bitsToInt",
               position: (24, 35),
              },
              arguments: [
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (24, 46),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "tail",
                    position: (24, 55),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "l",
                  position: (24, 60),
                 },
                ],
               },
               Variable {
                identifier: "signum",
                position: (24, 63),
               },
              ],
             },
            ],
            position: (24, 32),
           },
          ],
          position: (24, 27),
         },
         position: (21, 7),
        },
        position: (20, 20),
       },
       position: (20, 17),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "xsignum",
         position: (26, 5),
        },
       ],
      },
      IfThenElse {
       predicate: BinaryOperation {
        operator: LessThan,
        operands: [
         Variable {
          identifier: "x",
          position: (26, 18),
         },
         Int {
          value: 0,
          position: (26, 22),
         },
        ],
        position: (26, 20),
       },
       then: Int {
        value: 1,
        position: (26, 29),
       },
       else_: Int {
        value: 0,
        position: (26, 36),
       },
       position: (26, 15),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "ysignum",
         position: (27, 5),
        },
       ],
      },
      IfThenElse {
       predicate: BinaryOperation {
        operator: LessThan,
        operands: [
         Variable {
          identifier: "y",
          position: (27, 18),
         },
         Int {
          value: 0,
          position: (27, 22),
         },
        ],
        position: (27, 20),
       },
       then: Int {
        value: 1,
        position: (27, 29),
       },
       else_: Int {
        value: 0,
        position: (27, 36),
       },
       position: (27, 15),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "zipListsWith'",
         position: (28, 5),
        },
       ],
      },
      Function {
       argument: Some(
        "fst",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "snd",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: IfThenElse {
         predicate: BinaryOperation {
          operator: LogicalAnd,
          operands: [
           BinaryOperation {
            operator: EqualTo,
            operands: [
             Variable {
              identifier: "fst",
              position: (29, 10),
             },
             List {
              elements: [],
              position: (29, 15),
             },
            ],
            position: (29, 13),
           },
           BinaryOperation {
            operator: EqualTo,
            operands: [
             Variable {
              identifier: "snd",
              position: (29, 21),
             },
             List {
              elements: [],
              position: (29, 26),
             },
            ],
            position: (29, 24),
           },
          ],
          position: (29, 18),
         },
         then: List {
          elements: [],
          position: (30, 9),
         },
         else_: IfThenElse {
          predicate: BinaryOperation {
           operator: EqualTo,
           operands: [
            Variable {
             identifier: "fst",
             position: (31, 15),
            },
            List {
             elements: [],
             position: (31, 20),
            },
           ],
           position: (31, 18),
          },
          then: BinaryOperation {
           operator: Concatenation,
           operands: [
            List {
             elements: [
              FunctionApplication {
               function: Variable {
                identifier: "f",
                position: (32, 11),
               },
               arguments: [
                Variable {
                 identifier: "xsignum",
                 position: (32, 13),
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "builtins",
                   position: (32, 34),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "head",
                     position: (32, 43),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Variable {
                   identifier: "snd",
                   position: (32, 48),
                  },
                 ],
                },
               ],
              },
             ],
             position: (32, 9),
            },
            FunctionApplication {
             function: Variable {
              identifier: "zipListsWith'",
              position: (32, 59),
             },
             arguments: [
              List {
               elements: [],
               position: (32, 73),
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "builtins",
                 position: (32, 94),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "tail",
                   position: (32, 103),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "snd",
                 position: (32, 108),
                },
               ],
              },
             ],
            },
           ],
           position: (32, 55),
          },
          else_: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             Variable {
              identifier: "snd",
              position: (33, 15),
             },
             List {
              elements: [],
              position: (33, 20),
             },
            ],
            position: (33, 18),
           },
           then: BinaryOperation {
            operator: Concatenation,
            operands: [
             List {
              elements: [
               FunctionApplication {
                function: Variable {
                 identifier: "f",
                 position: (34, 11),
                },
                arguments: [
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "builtins",
                    position: (34, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "head",
                      position: (34, 23),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "fst",
                    position: (34, 28),
                   },
                  ],
                 },
                 Variable {
                  identifier: "ysignum",
                  position: (34, 33),
                 },
                ],
               },
              ],
              position: (34, 9),
             },
             FunctionApplication {
              function: Variable {
               identifier: "zipListsWith'",
               position: (34, 59),
              },
              arguments: [
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (34, 74),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "tail",
                    position: (34, 83),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "fst",
                  position: (34, 88),
                 },
                ],
               },
               List {
                elements: [],
                position: (34, 93),
               },
              ],
             },
            ],
            position: (34, 55),
           },
           else_: BinaryOperation {
            operator: Concatenation,
            operands: [
             List {
              elements: [
               FunctionApplication {
                function: Variable {
                 identifier: "f",
                 position: (36, 11),
                },
                arguments: [
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "builtins",
                    position: (36, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "head",
                      position: (36, 23),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "fst",
                    position: (36, 28),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "builtins",
                    position: (36, 34),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "head",
                      position: (36, 43),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "snd",
                    position: (36, 48),
                   },
                  ],
                 },
                ],
               },
              ],
              position: (36, 9),
             },
             FunctionApplication {
              function: Variable {
               identifier: "zipListsWith'",
               position: (36, 59),
              },
              arguments: [
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (36, 74),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "tail",
                    position: (36, 83),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "fst",
                  position: (36, 88),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "builtins",
                  position: (36, 94),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "tail",
                    position: (36, 103),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "snd",
                  position: (36, 108),
                 },
                ],
               },
              ],
             },
            ],
            position: (36, 55),
           },
           position: (33, 12),
          },
          position: (31, 12),
         },
         position: (29, 7),
        },
        position: (28, 26),
       },
       position: (28, 21),
      },
     ),
    ],
    target: Assert {
     expression: BinaryOperation {
      operator: LogicalAnd,
      operands: [
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (38, 13),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "isInt",
            position: (38, 22),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "x",
          position: (38, 28),
         },
        ],
       },
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (38, 35),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "isInt",
            position: (38, 44),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "y",
          position: (38, 50),
         },
        ],
       },
      ],
      position: (38, 31),
     },
     target: FunctionApplication {
      function: Variable {
       identifier: "bitsToInt",
       position: (39, 5),
      },
      arguments: [
       FunctionApplication {
        function: Variable {
         identifier: "zipListsWith'",
         position: (39, 16),
        },
        arguments: [
         FunctionApplication {
          function: Variable {
           identifier: "intToBits",
           position: (39, 31),
          },
          arguments: [
           Variable {
            identifier: "x",
            position: (39, 41),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "intToBits",
           position: (39, 45),
          },
          arguments: [
           Variable {
            identifier: "y",
            position: (39, 55),
           },
          ],
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "f",
         position: (39, 60),
        },
        arguments: [
         Variable {
          identifier: "xsignum",
          position: (39, 62),
         },
         Variable {
          identifier: "ysignum",
          position: (39, 70),
         },
        ],
       },
      ],
     },
     position: (38, 5),
    },
    position: (6, 3),
   },
   position: (5, 7),
  },
  position: (5, 4),
 },
 position: (5, 1),
}