-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 + UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Add(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_Addition(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 + UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Add(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_Addition(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? + UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Add(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_Addition(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 + UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Add(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Addition(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? + UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Add(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Addition(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 - UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Subtract(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_Subtraction(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 - UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Subtract(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_Subtraction(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? - UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Subtract(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_Subtraction(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 - UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Subtract(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Subtraction(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? - UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Subtract(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Subtraction(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 * UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Multiply(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_Multiply(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 * UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Multiply(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_Multiply(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? * UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Multiply(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_Multiply(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 * UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Multiply(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Multiply(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? * UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Multiply(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Multiply(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 / UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Divide(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_Division(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 / UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Divide(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_Division(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? / UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Divide(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_Division(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 / UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Divide(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Division(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? / UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Divide(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Division(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 \ UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Divide(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_IntegerDivision(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 \ UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Divide(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_IntegerDivision(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? \ UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Divide(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_IntegerDivision(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 \ UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Divide(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_IntegerDivision(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? \ UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Divide(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_IntegerDivision(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 Mod UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Modulo(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_Modulus(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 Mod UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Modulo(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_Modulus(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? Mod UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Modulo(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_Modulus(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 Mod UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Modulo(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Modulus(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? Mod UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Modulo(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Modulus(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 ^ UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Power(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_Exponent(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 ^ UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Power(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_Exponent(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? ^ UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Power(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_Exponent(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 ^ UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Power(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Exponent(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? ^ UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Power(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Exponent(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 = UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Equal(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_Equality(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 = UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Equal(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_Equality(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? = UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Equal(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_Equality(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 = UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Equal(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Equality(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? = UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Equal(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Equality(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 <> UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    NotEqual(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_Inequality(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 <> UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      NotEqual(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_Inequality(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? <> UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      NotEqual(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_Inequality(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 <> UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    NotEqual(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Inequality(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? <> UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    NotEqual(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_Inequality(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 < UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    LessThan(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_LessThan(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 < UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      LessThan(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_LessThan(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? < UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      LessThan(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_LessThan(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 < UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    LessThan(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_LessThan(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? < UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    LessThan(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_LessThan(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 > UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    GreaterThan(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_GreaterThan(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 > UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      GreaterThan(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_GreaterThan(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? > UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      GreaterThan(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_GreaterThan(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 > UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    GreaterThan(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_GreaterThan(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? > UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    GreaterThan(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_GreaterThan(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 <= UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    LessThanOrEqual(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_LessThanOrEqual(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 <= UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      LessThanOrEqual(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_LessThanOrEqual(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? <= UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      LessThanOrEqual(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_LessThanOrEqual(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 <= UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    LessThanOrEqual(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_LessThanOrEqual(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? <= UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    LessThanOrEqual(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_LessThanOrEqual(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 >= UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    GreaterThanOrEqual(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_GreaterThanOrEqual(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 >= UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      GreaterThanOrEqual(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_GreaterThanOrEqual(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? >= UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      GreaterThanOrEqual(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_GreaterThanOrEqual(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 >= UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    GreaterThanOrEqual(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_GreaterThanOrEqual(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? >= UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    GreaterThanOrEqual(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_GreaterThanOrEqual(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 Like UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator0 op_Like(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0 (
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
      )
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 Like UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator0 op_Like(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0 (
          Parameter(
            x
            type: UserDefinedBinaryOperator0
          )
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
        )
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? Like UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Convert(
        Call(
          <NULL>
          method: UserDefinedBinaryOperator0 op_Like(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0 (
            Convert(
              Parameter(
                x
                type: System.Nullable`1[UserDefinedBinaryOperator0]
              )
              Lifted
              type: UserDefinedBinaryOperator0
            )
            Convert(
              Convert(
                Parameter(
                  y
                  type: UserDefinedBinaryOperator0
                )
                Lifted
                LiftedToNull
                type: System.Nullable`1[UserDefinedBinaryOperator0]
              )
              Lifted
              type: UserDefinedBinaryOperator0
            )
          )
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 Like UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator0 op_Like(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0 (
          Convert(
            Convert(
              Parameter(
                x
                type: UserDefinedBinaryOperator0
              )
              Lifted
              LiftedToNull
              type: System.Nullable`1[UserDefinedBinaryOperator0]
            )
            Lifted
            type: UserDefinedBinaryOperator0
          )
          Convert(
            Parameter(
              y
              type: System.Nullable`1[UserDefinedBinaryOperator0]
            )
            Lifted
            type: UserDefinedBinaryOperator0
          )
        )
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? Like UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator0 op_Like(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0 (
          Convert(
            Parameter(
              x
              type: System.Nullable`1[UserDefinedBinaryOperator0]
            )
            Lifted
            type: UserDefinedBinaryOperator0
          )
          Convert(
            Parameter(
              y
              type: System.Nullable`1[UserDefinedBinaryOperator0]
            )
            Lifted
            type: UserDefinedBinaryOperator0
          )
        )
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 & UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator0 op_Concatenate(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0 (
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
      )
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 & UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator0 op_Concatenate(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0 (
          Parameter(
            x
            type: UserDefinedBinaryOperator0
          )
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
        )
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? & UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Convert(
        Call(
          <NULL>
          method: UserDefinedBinaryOperator0 op_Concatenate(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0 (
            Convert(
              Parameter(
                x
                type: System.Nullable`1[UserDefinedBinaryOperator0]
              )
              Lifted
              type: UserDefinedBinaryOperator0
            )
            Convert(
              Convert(
                Parameter(
                  y
                  type: UserDefinedBinaryOperator0
                )
                Lifted
                LiftedToNull
                type: System.Nullable`1[UserDefinedBinaryOperator0]
              )
              Lifted
              type: UserDefinedBinaryOperator0
            )
          )
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 & UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator0 op_Concatenate(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0 (
          Convert(
            Convert(
              Parameter(
                x
                type: UserDefinedBinaryOperator0
              )
              Lifted
              LiftedToNull
              type: System.Nullable`1[UserDefinedBinaryOperator0]
            )
            Lifted
            type: UserDefinedBinaryOperator0
          )
          Convert(
            Parameter(
              y
              type: System.Nullable`1[UserDefinedBinaryOperator0]
            )
            Lifted
            type: UserDefinedBinaryOperator0
          )
        )
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? & UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator0 op_Concatenate(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0 (
          Convert(
            Parameter(
              x
              type: System.Nullable`1[UserDefinedBinaryOperator0]
            )
            Lifted
            type: UserDefinedBinaryOperator0
          )
          Convert(
            Parameter(
              y
              type: System.Nullable`1[UserDefinedBinaryOperator0]
            )
            Lifted
            type: UserDefinedBinaryOperator0
          )
        )
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 And UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    And(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_BitwiseAnd(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 And UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      And(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_BitwiseAnd(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? And UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      And(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_BitwiseAnd(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 And UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    And(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_BitwiseAnd(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? And UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    And(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_BitwiseAnd(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 Or UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Or(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_BitwiseOr(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 Or UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Or(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_BitwiseOr(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? Or UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      Or(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_BitwiseOr(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 Or UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Or(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_BitwiseOr(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? Or UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    Or(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_BitwiseOr(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 Xor UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    ExclusiveOr(
      Parameter(
        x
        type: UserDefinedBinaryOperator0
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator0
      )
      method: UserDefinedBinaryOperator0 op_ExclusiveOr(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 Xor UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      ExclusiveOr(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator0
        )
        method: UserDefinedBinaryOperator0 op_ExclusiveOr(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? Xor UserDefinedBinaryOperator0 => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator0
  )
  body {
    Convert(
      ExclusiveOr(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator0
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_ExclusiveOr(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],UserDefinedBinaryOperator0,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 Xor UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    ExclusiveOr(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_ExclusiveOr(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? Xor UserDefinedBinaryOperator0? => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  body {
    ExclusiveOr(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Parameter(
        y
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      LiftedToNull
      method: UserDefinedBinaryOperator0 op_ExclusiveOr(UserDefinedBinaryOperator0, UserDefinedBinaryOperator0) in UserDefinedBinaryOperator0
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0],System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 << Integer => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    Convert(
      LeftShift(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: System.Int32
        )
        method: UserDefinedBinaryOperator0 op_LeftShift(UserDefinedBinaryOperator0, Int32) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Int32,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? << Integer => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    Convert(
      LeftShift(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: System.Int32
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[System.Int32]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_LeftShift(UserDefinedBinaryOperator0, Int32) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Int32,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0 >> Integer => UserDefinedBinaryOperator0? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator0
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    Convert(
      RightShift(
        Parameter(
          x
          type: UserDefinedBinaryOperator0
        )
        Parameter(
          y
          type: System.Int32
        )
        method: UserDefinedBinaryOperator0 op_RightShift(UserDefinedBinaryOperator0, Int32) in UserDefinedBinaryOperator0
        type: UserDefinedBinaryOperator0
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator0]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator0]
  type: System.Func`3[UserDefinedBinaryOperator0,System.Int32,System.Nullable`1[UserDefinedBinaryOperator0]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator0? >> Integer => UserDefinedBinaryOperator0 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator0]
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    Convert(
      RightShift(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator0]
        )
        Convert(
          Parameter(
            y
            type: System.Int32
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[System.Int32]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator0 op_RightShift(UserDefinedBinaryOperator0, Int32) in UserDefinedBinaryOperator0
        type: System.Nullable`1[UserDefinedBinaryOperator0]
      )
      Lifted
      type: UserDefinedBinaryOperator0
    )
  }
  return type: UserDefinedBinaryOperator0
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator0],System.Int32,UserDefinedBinaryOperator0]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 + UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Add(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Addition(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 + UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      Add(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Addition(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? + UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Add(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Addition(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 + UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Add(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Addition(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? + UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Add(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Addition(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 - UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Subtract(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Subtraction(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 - UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      Subtract(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Subtraction(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? - UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Subtract(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Subtraction(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 - UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Subtract(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Subtraction(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? - UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Subtract(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Subtraction(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 * UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Multiply(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Multiply(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 * UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      Multiply(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Multiply(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? * UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Multiply(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Multiply(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 * UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Multiply(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Multiply(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? * UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Multiply(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Multiply(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 / UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Divide(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Division(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 / UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      Divide(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Division(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? / UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Divide(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Division(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 / UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Divide(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Division(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? / UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Divide(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Division(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 \ UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Divide(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_IntegerDivision(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 \ UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      Divide(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_IntegerDivision(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? \ UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Divide(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_IntegerDivision(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 \ UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Divide(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_IntegerDivision(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? \ UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Divide(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_IntegerDivision(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 Mod UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Modulo(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Modulus(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 Mod UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      Modulo(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Modulus(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? Mod UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Modulo(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Modulus(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 Mod UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Modulo(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Modulus(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? Mod UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Modulo(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Modulus(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 ^ UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Power(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Exponent(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 ^ UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      Power(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Exponent(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? ^ UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Power(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Exponent(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 ^ UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Power(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Exponent(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? ^ UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Power(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Exponent(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 = UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Equal(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Equality(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 = UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      Equal(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Equality(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? = UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Equal(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Equality(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 = UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Equal(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Equality(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? = UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Equal(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Equality(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 <> UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    NotEqual(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Inequality(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 <> UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      NotEqual(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Inequality(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? <> UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    NotEqual(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_Inequality(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 <> UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      NotEqual(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Inequality(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? <> UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      NotEqual(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_Inequality(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 < UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    LessThan(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_LessThan(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 < UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      LessThan(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_LessThan(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? < UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    LessThan(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_LessThan(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 < UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      LessThan(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_LessThan(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? < UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      LessThan(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_LessThan(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 > UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    GreaterThan(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_GreaterThan(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 > UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      GreaterThan(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_GreaterThan(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? > UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    GreaterThan(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_GreaterThan(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 > UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      GreaterThan(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_GreaterThan(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? > UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      GreaterThan(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_GreaterThan(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 <= UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    LessThanOrEqual(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_LessThanOrEqual(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 <= UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      LessThanOrEqual(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_LessThanOrEqual(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? <= UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    LessThanOrEqual(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_LessThanOrEqual(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 <= UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      LessThanOrEqual(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_LessThanOrEqual(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? <= UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      LessThanOrEqual(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_LessThanOrEqual(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 >= UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    GreaterThanOrEqual(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_GreaterThanOrEqual(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 >= UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      GreaterThanOrEqual(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_GreaterThanOrEqual(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? >= UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    GreaterThanOrEqual(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_GreaterThanOrEqual(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 >= UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      GreaterThanOrEqual(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_GreaterThanOrEqual(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? >= UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      GreaterThanOrEqual(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_GreaterThanOrEqual(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 Like UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator1 op_Like(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1 (
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
      )
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 Like UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator1 op_Like(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1 (
          Parameter(
            x
            type: UserDefinedBinaryOperator1
          )
          Convert(
            Parameter(
              y
              type: UserDefinedBinaryOperator1
            )
            Lifted
            LiftedToNull
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
        )
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? Like UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator1 op_Like(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1 (
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
      )
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 Like UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator1 op_Like(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1 (
          Parameter(
            x
            type: UserDefinedBinaryOperator1
          )
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
        )
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? Like UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator1 op_Like(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1 (
          Convert(
            Parameter(
              x
              type: System.Nullable`1[UserDefinedBinaryOperator1]
            )
            Lifted
            type: UserDefinedBinaryOperator1
          )
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
        )
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 & UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator1 op_Concatenate(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1 (
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
      )
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 & UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator1 op_Concatenate(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1 (
          Parameter(
            x
            type: UserDefinedBinaryOperator1
          )
          Convert(
            Parameter(
              y
              type: UserDefinedBinaryOperator1
            )
            Lifted
            LiftedToNull
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
        )
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? & UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator1 op_Concatenate(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1 (
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
      )
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 & UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator1 op_Concatenate(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1 (
          Parameter(
            x
            type: UserDefinedBinaryOperator1
          )
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
        )
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? & UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator1 op_Concatenate(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1 (
          Convert(
            Parameter(
              x
              type: System.Nullable`1[UserDefinedBinaryOperator1]
            )
            Lifted
            type: UserDefinedBinaryOperator1
          )
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
        )
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 And UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    And(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_BitwiseAnd(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 And UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      And(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_BitwiseAnd(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? And UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    And(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_BitwiseAnd(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 And UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      And(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_BitwiseAnd(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? And UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_BitwiseAnd(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 Or UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Or(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_BitwiseOr(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 Or UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      Or(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_BitwiseOr(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? Or UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Or(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_BitwiseOr(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 Or UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Or(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_BitwiseOr(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? Or UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_BitwiseOr(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 Xor UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    ExclusiveOr(
      Parameter(
        x
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_ExclusiveOr(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 Xor UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    Convert(
      ExclusiveOr(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator1
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_ExclusiveOr(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? Xor UserDefinedBinaryOperator1 => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator1
  )
  body {
    ExclusiveOr(
      Convert(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Lifted
        type: UserDefinedBinaryOperator1
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator1
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      method: UserDefinedBinaryOperator1 op_ExclusiveOr(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],UserDefinedBinaryOperator1,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 Xor UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      ExclusiveOr(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_ExclusiveOr(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? Xor UserDefinedBinaryOperator1? => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator1]
          )
          Lifted
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        method: UserDefinedBinaryOperator1 op_ExclusiveOr(UserDefinedBinaryOperator1, System.Nullable`1[UserDefinedBinaryOperator1]) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1],System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 << Integer => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    Convert(
      LeftShift(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Int32
        )
        method: UserDefinedBinaryOperator1 op_LeftShift(UserDefinedBinaryOperator1, Int32) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Int32,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? << Integer => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    Convert(
      LeftShift(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Convert(
          Parameter(
            y
            type: System.Int32
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[System.Int32]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator1 op_LeftShift(UserDefinedBinaryOperator1, Int32) in UserDefinedBinaryOperator1
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      Lifted
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Int32,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1 >> Integer => UserDefinedBinaryOperator1? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator1
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    Convert(
      RightShift(
        Parameter(
          x
          type: UserDefinedBinaryOperator1
        )
        Parameter(
          y
          type: System.Int32
        )
        method: UserDefinedBinaryOperator1 op_RightShift(UserDefinedBinaryOperator1, Int32) in UserDefinedBinaryOperator1
        type: UserDefinedBinaryOperator1
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator1]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator1]
  type: System.Func`3[UserDefinedBinaryOperator1,System.Int32,System.Nullable`1[UserDefinedBinaryOperator1]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator1? >> Integer => UserDefinedBinaryOperator1 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator1]
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    Convert(
      RightShift(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator1]
        )
        Convert(
          Parameter(
            y
            type: System.Int32
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[System.Int32]
        )
        Lifted
        LiftedToNull
        method: UserDefinedBinaryOperator1 op_RightShift(UserDefinedBinaryOperator1, Int32) in UserDefinedBinaryOperator1
        type: System.Nullable`1[UserDefinedBinaryOperator1]
      )
      Lifted
      type: UserDefinedBinaryOperator1
    )
  }
  return type: UserDefinedBinaryOperator1
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator1],System.Int32,UserDefinedBinaryOperator1]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 + UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Add(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Addition(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 + UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      Add(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Addition(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? + UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Add(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Addition(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 + UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Add(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Addition(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? + UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Add(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Addition(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 - UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Subtract(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Subtraction(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 - UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      Subtract(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Subtraction(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? - UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Subtract(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Subtraction(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 - UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Subtract(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Subtraction(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? - UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Subtract(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Subtraction(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 * UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Multiply(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Multiply(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 * UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      Multiply(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Multiply(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? * UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Multiply(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Multiply(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 * UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Multiply(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Multiply(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? * UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Multiply(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Multiply(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 / UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Divide(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Division(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 / UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      Divide(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Division(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? / UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Divide(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Division(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 / UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Divide(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Division(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? / UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Divide(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Division(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 \ UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Divide(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_IntegerDivision(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 \ UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      Divide(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_IntegerDivision(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? \ UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Divide(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_IntegerDivision(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 \ UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Divide(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_IntegerDivision(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? \ UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Divide(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_IntegerDivision(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 Mod UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Modulo(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Modulus(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 Mod UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      Modulo(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Modulus(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? Mod UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Modulo(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Modulus(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 Mod UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Modulo(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Modulus(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? Mod UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Modulo(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Modulus(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 ^ UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Power(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Exponent(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 ^ UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      Power(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Exponent(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? ^ UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Power(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Exponent(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 ^ UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Power(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Exponent(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? ^ UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Power(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Exponent(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 = UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Equal(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Equality(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 = UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      Equal(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Equality(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? = UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Equal(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Equality(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 = UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Equal(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Equality(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? = UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Equal(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Equality(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 <> UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    NotEqual(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Inequality(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 <> UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      NotEqual(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Inequality(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? <> UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    NotEqual(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_Inequality(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 <> UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      NotEqual(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Inequality(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? <> UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      NotEqual(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_Inequality(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 < UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    LessThan(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_LessThan(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 < UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      LessThan(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_LessThan(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? < UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    LessThan(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_LessThan(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 < UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      LessThan(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_LessThan(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? < UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      LessThan(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_LessThan(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 > UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    GreaterThan(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_GreaterThan(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 > UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      GreaterThan(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_GreaterThan(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? > UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    GreaterThan(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_GreaterThan(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 > UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      GreaterThan(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_GreaterThan(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? > UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      GreaterThan(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_GreaterThan(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 <= UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    LessThanOrEqual(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_LessThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 <= UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      LessThanOrEqual(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_LessThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? <= UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    LessThanOrEqual(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_LessThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 <= UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      LessThanOrEqual(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_LessThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? <= UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      LessThanOrEqual(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_LessThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 >= UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    GreaterThanOrEqual(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_GreaterThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 >= UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      GreaterThanOrEqual(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_GreaterThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? >= UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    GreaterThanOrEqual(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_GreaterThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 >= UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      GreaterThanOrEqual(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_GreaterThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? >= UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      GreaterThanOrEqual(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_GreaterThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 Like UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator2 op_Like(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2 (
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
      )
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 Like UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator2 op_Like(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2 (
          Convert(
            Parameter(
              x
              type: UserDefinedBinaryOperator2
            )
            Lifted
            LiftedToNull
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Parameter(
            y
            type: UserDefinedBinaryOperator2
          )
        )
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? Like UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator2 op_Like(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2 (
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
      )
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 Like UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator2 op_Like(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2 (
          Convert(
            Parameter(
              x
              type: UserDefinedBinaryOperator2
            )
            Lifted
            LiftedToNull
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Convert(
            Parameter(
              y
              type: System.Nullable`1[UserDefinedBinaryOperator2]
            )
            Lifted
            type: UserDefinedBinaryOperator2
          )
        )
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? Like UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator2 op_Like(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2 (
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Convert(
            Parameter(
              y
              type: System.Nullable`1[UserDefinedBinaryOperator2]
            )
            Lifted
            type: UserDefinedBinaryOperator2
          )
        )
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 & UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator2 op_Concatenate(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2 (
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
      )
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 & UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator2 op_Concatenate(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2 (
          Convert(
            Parameter(
              x
              type: UserDefinedBinaryOperator2
            )
            Lifted
            LiftedToNull
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Parameter(
            y
            type: UserDefinedBinaryOperator2
          )
        )
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? & UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator2 op_Concatenate(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2 (
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
      )
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 & UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator2 op_Concatenate(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2 (
          Convert(
            Parameter(
              x
              type: UserDefinedBinaryOperator2
            )
            Lifted
            LiftedToNull
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Convert(
            Parameter(
              y
              type: System.Nullable`1[UserDefinedBinaryOperator2]
            )
            Lifted
            type: UserDefinedBinaryOperator2
          )
        )
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? & UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator2 op_Concatenate(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2 (
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Convert(
            Parameter(
              y
              type: System.Nullable`1[UserDefinedBinaryOperator2]
            )
            Lifted
            type: UserDefinedBinaryOperator2
          )
        )
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 And UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    And(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_BitwiseAnd(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 And UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_BitwiseAnd(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? And UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    And(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_BitwiseAnd(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 And UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_BitwiseAnd(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? And UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      And(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_BitwiseAnd(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 Or UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Or(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_BitwiseOr(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 Or UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_BitwiseOr(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? Or UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Or(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_BitwiseOr(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 Or UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_BitwiseOr(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? Or UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      Or(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_BitwiseOr(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 Xor UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    ExclusiveOr(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator2
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_ExclusiveOr(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 Xor UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_ExclusiveOr(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? Xor UserDefinedBinaryOperator2 => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator2
  )
  body {
    ExclusiveOr(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: UserDefinedBinaryOperator2
      )
      method: UserDefinedBinaryOperator2 op_ExclusiveOr(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],UserDefinedBinaryOperator2,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 Xor UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_ExclusiveOr(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? Xor UserDefinedBinaryOperator2? => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  body {
    Convert(
      ExclusiveOr(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Convert(
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator2]
          )
          Lifted
          type: UserDefinedBinaryOperator2
        )
        method: UserDefinedBinaryOperator2 op_ExclusiveOr(System.Nullable`1[UserDefinedBinaryOperator2], UserDefinedBinaryOperator2) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2],System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 << Integer => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    Convert(
      LeftShift(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: System.Int32
        )
        method: UserDefinedBinaryOperator2 op_LeftShift(System.Nullable`1[UserDefinedBinaryOperator2], Int32) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Int32,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? << Integer => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    LeftShift(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: System.Int32
      )
      method: UserDefinedBinaryOperator2 op_LeftShift(System.Nullable`1[UserDefinedBinaryOperator2], Int32) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Int32,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2 >> Integer => UserDefinedBinaryOperator2? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator2
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    Convert(
      RightShift(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator2
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator2]
        )
        Parameter(
          y
          type: System.Int32
        )
        method: UserDefinedBinaryOperator2 op_RightShift(System.Nullable`1[UserDefinedBinaryOperator2], Int32) in UserDefinedBinaryOperator2
        type: UserDefinedBinaryOperator2
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator2]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator2]
  type: System.Func`3[UserDefinedBinaryOperator2,System.Int32,System.Nullable`1[UserDefinedBinaryOperator2]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator2? >> Integer => UserDefinedBinaryOperator2 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator2]
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    RightShift(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator2]
      )
      Parameter(
        y
        type: System.Int32
      )
      method: UserDefinedBinaryOperator2 op_RightShift(System.Nullable`1[UserDefinedBinaryOperator2], Int32) in UserDefinedBinaryOperator2
      type: UserDefinedBinaryOperator2
    )
  }
  return type: UserDefinedBinaryOperator2
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator2],System.Int32,UserDefinedBinaryOperator2]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 + UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Add(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Addition(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 + UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      Add(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Addition(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? + UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Add(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Addition(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 + UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Add(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Addition(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? + UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Add(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Addition(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 - UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Subtract(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Subtraction(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 - UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      Subtract(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Subtraction(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? - UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Subtract(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Subtraction(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 - UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Subtract(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Subtraction(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? - UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Subtract(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Subtraction(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 * UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Multiply(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Multiply(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 * UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      Multiply(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Multiply(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? * UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Multiply(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Multiply(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 * UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Multiply(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Multiply(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? * UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Multiply(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Multiply(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 / UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Divide(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Division(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 / UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      Divide(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Division(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? / UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Divide(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Division(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 / UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Divide(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Division(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? / UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Divide(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Division(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 \ UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Divide(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_IntegerDivision(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 \ UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      Divide(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_IntegerDivision(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? \ UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Divide(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_IntegerDivision(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 \ UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Divide(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_IntegerDivision(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? \ UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Divide(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_IntegerDivision(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 Mod UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Modulo(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Modulus(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 Mod UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      Modulo(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Modulus(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? Mod UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Modulo(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Modulus(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 Mod UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Modulo(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Modulus(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? Mod UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Modulo(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Modulus(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 ^ UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Power(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Exponent(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 ^ UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      Power(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Exponent(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? ^ UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Power(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Exponent(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 ^ UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Power(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Exponent(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? ^ UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Power(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Exponent(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 = UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Equal(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Equality(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 = UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      Equal(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Equality(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? = UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Equal(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Equality(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 = UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Equal(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Equality(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? = UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Equal(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Equality(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 <> UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    NotEqual(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Inequality(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 <> UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      NotEqual(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Inequality(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? <> UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    NotEqual(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_Inequality(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 <> UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      NotEqual(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Inequality(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? <> UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      NotEqual(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_Inequality(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 < UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    LessThan(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_LessThan(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 < UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      LessThan(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_LessThan(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? < UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    LessThan(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_LessThan(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 < UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      LessThan(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_LessThan(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? < UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      LessThan(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_LessThan(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 > UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    GreaterThan(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_GreaterThan(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 > UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      GreaterThan(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_GreaterThan(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? > UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    GreaterThan(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_GreaterThan(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 > UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      GreaterThan(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_GreaterThan(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? > UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      GreaterThan(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_GreaterThan(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 <= UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    LessThanOrEqual(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_LessThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 <= UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      LessThanOrEqual(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_LessThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? <= UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    LessThanOrEqual(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_LessThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 <= UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      LessThanOrEqual(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_LessThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? <= UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      LessThanOrEqual(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_LessThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 >= UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    GreaterThanOrEqual(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_GreaterThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 >= UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      GreaterThanOrEqual(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_GreaterThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? >= UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    GreaterThanOrEqual(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_GreaterThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 >= UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      GreaterThanOrEqual(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_GreaterThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? >= UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      GreaterThanOrEqual(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_GreaterThanOrEqual(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 Like UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator3 op_Like(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3 (
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
      )
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 Like UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator3 op_Like(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3 (
          Convert(
            Parameter(
              x
              type: UserDefinedBinaryOperator3
            )
            Lifted
            LiftedToNull
            type: System.Nullable`1[UserDefinedBinaryOperator3]
          )
          Convert(
            Parameter(
              y
              type: UserDefinedBinaryOperator3
            )
            Lifted
            LiftedToNull
            type: System.Nullable`1[UserDefinedBinaryOperator3]
          )
        )
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? Like UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator3 op_Like(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3 (
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
      )
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 Like UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator3 op_Like(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3 (
          Convert(
            Parameter(
              x
              type: UserDefinedBinaryOperator3
            )
            Lifted
            LiftedToNull
            type: System.Nullable`1[UserDefinedBinaryOperator3]
          )
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator3]
          )
        )
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? Like UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator3 op_Like(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3 (
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator3]
          )
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator3]
          )
        )
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 & UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator3 op_Concatenate(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3 (
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
      )
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 & UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator3 op_Concatenate(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3 (
          Convert(
            Parameter(
              x
              type: UserDefinedBinaryOperator3
            )
            Lifted
            LiftedToNull
            type: System.Nullable`1[UserDefinedBinaryOperator3]
          )
          Convert(
            Parameter(
              y
              type: UserDefinedBinaryOperator3
            )
            Lifted
            LiftedToNull
            type: System.Nullable`1[UserDefinedBinaryOperator3]
          )
        )
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? & UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Call(
      <NULL>
      method: UserDefinedBinaryOperator3 op_Concatenate(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3 (
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
      )
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 & UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator3 op_Concatenate(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3 (
          Convert(
            Parameter(
              x
              type: UserDefinedBinaryOperator3
            )
            Lifted
            LiftedToNull
            type: System.Nullable`1[UserDefinedBinaryOperator3]
          )
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator3]
          )
        )
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? & UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Call(
        <NULL>
        method: UserDefinedBinaryOperator3 op_Concatenate(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3 (
          Parameter(
            x
            type: System.Nullable`1[UserDefinedBinaryOperator3]
          )
          Parameter(
            y
            type: System.Nullable`1[UserDefinedBinaryOperator3]
          )
        )
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 And UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    And(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_BitwiseAnd(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 And UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_BitwiseAnd(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? And UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    And(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_BitwiseAnd(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 And UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_BitwiseAnd(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? And UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      And(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_BitwiseAnd(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 Or UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Or(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_BitwiseOr(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 Or UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_BitwiseOr(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? Or UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Or(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_BitwiseOr(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 Or UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_BitwiseOr(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? Or UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      Or(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_BitwiseOr(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 Xor UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    ExclusiveOr(
      Convert(
        Parameter(
          x
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_ExclusiveOr(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 Xor UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Convert(
          Parameter(
            y
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_ExclusiveOr(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? Xor UserDefinedBinaryOperator3 => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: UserDefinedBinaryOperator3
  )
  body {
    ExclusiveOr(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Convert(
        Parameter(
          y
          type: UserDefinedBinaryOperator3
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      method: UserDefinedBinaryOperator3 op_ExclusiveOr(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],UserDefinedBinaryOperator3,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 Xor UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_ExclusiveOr(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? Xor UserDefinedBinaryOperator3? => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  body {
    Convert(
      ExclusiveOr(
        Parameter(
          x
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        method: UserDefinedBinaryOperator3 op_ExclusiveOr(System.Nullable`1[UserDefinedBinaryOperator3], System.Nullable`1[UserDefinedBinaryOperator3]) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3],System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 << Integer => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    Convert(
      LeftShift(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Int32
        )
        method: UserDefinedBinaryOperator3 op_LeftShift(System.Nullable`1[UserDefinedBinaryOperator3], Int32) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Int32,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? << Integer => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    LeftShift(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Parameter(
        y
        type: System.Int32
      )
      method: UserDefinedBinaryOperator3 op_LeftShift(System.Nullable`1[UserDefinedBinaryOperator3], Int32) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Int32,UserDefinedBinaryOperator3]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3 >> Integer => UserDefinedBinaryOperator3? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: UserDefinedBinaryOperator3
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    Convert(
      RightShift(
        Convert(
          Parameter(
            x
            type: UserDefinedBinaryOperator3
          )
          Lifted
          LiftedToNull
          type: System.Nullable`1[UserDefinedBinaryOperator3]
        )
        Parameter(
          y
          type: System.Int32
        )
        method: UserDefinedBinaryOperator3 op_RightShift(System.Nullable`1[UserDefinedBinaryOperator3], Int32) in UserDefinedBinaryOperator3
        type: UserDefinedBinaryOperator3
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[UserDefinedBinaryOperator3]
    )
  }
  return type: System.Nullable`1[UserDefinedBinaryOperator3]
  type: System.Func`3[UserDefinedBinaryOperator3,System.Int32,System.Nullable`1[UserDefinedBinaryOperator3]]
)

-=-=-=-=-=-=-=-=- UserDefinedBinaryOperator3? >> Integer => UserDefinedBinaryOperator3 -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[UserDefinedBinaryOperator3]
  )
  Parameter(
    y
    type: System.Int32
  )
  body {
    RightShift(
      Parameter(
        x
        type: System.Nullable`1[UserDefinedBinaryOperator3]
      )
      Parameter(
        y
        type: System.Int32
      )
      method: UserDefinedBinaryOperator3 op_RightShift(System.Nullable`1[UserDefinedBinaryOperator3], Int32) in UserDefinedBinaryOperator3
      type: UserDefinedBinaryOperator3
    )
  }
  return type: UserDefinedBinaryOperator3
  type: System.Func`3[System.Nullable`1[UserDefinedBinaryOperator3],System.Int32,UserDefinedBinaryOperator3]
)