﻿-=-=-=-=-=-=-=-=- SByte And SByte => SByte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  Parameter(
    y
    type: System.SByte
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: System.SByte
          )
          type: System.Int32
        )
        Convert(
          Parameter(
            y
            type: System.SByte
          )
          type: System.Int32
        )
        type: System.Int32
      )
      type: System.SByte
    )
  }
  return type: System.SByte
  type: System.Func`3[System.SByte,System.SByte,System.SByte]
)

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

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

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

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

-=-=-=-=-=-=-=-=- E_SByte And E_SByte => E_SByte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  Parameter(
    y
    type: E_SByte
  )
  body {
    Convert(
      Convert(
        And(
          Convert(
            Convert(
              Parameter(
                x
                type: E_SByte
              )
              type: System.SByte
            )
            type: System.Int32
          )
          Convert(
            Convert(
              Parameter(
                y
                type: E_SByte
              )
              type: System.SByte
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: System.SByte
      )
      type: E_SByte
    )
  }
  return type: E_SByte
  type: System.Func`3[E_SByte,E_SByte,E_SByte]
)

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

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

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

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

-=-=-=-=-=-=-=-=- Byte And Byte => Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  Parameter(
    y
    type: System.Byte
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: System.Byte
          )
          type: System.Int32
        )
        Convert(
          Parameter(
            y
            type: System.Byte
          )
          type: System.Int32
        )
        type: System.Int32
      )
      type: System.Byte
    )
  }
  return type: System.Byte
  type: System.Func`3[System.Byte,System.Byte,System.Byte]
)

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

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

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

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

-=-=-=-=-=-=-=-=- E_Byte And E_Byte => E_Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  Parameter(
    y
    type: E_Byte
  )
  body {
    Convert(
      Convert(
        And(
          Convert(
            Convert(
              Parameter(
                x
                type: E_Byte
              )
              type: System.Byte
            )
            type: System.Int32
          )
          Convert(
            Convert(
              Parameter(
                y
                type: E_Byte
              )
              type: System.Byte
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: System.Byte
      )
      type: E_Byte
    )
  }
  return type: E_Byte
  type: System.Func`3[E_Byte,E_Byte,E_Byte]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_Short And E_Short => E_Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  Parameter(
    y
    type: E_Short
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: E_Short
          )
          type: System.Int16
        )
        Convert(
          Parameter(
            y
            type: E_Short
          )
          type: System.Int16
        )
        type: System.Int16
      )
      type: E_Short
    )
  }
  return type: E_Short
  type: System.Func`3[E_Short,E_Short,E_Short]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_UShort And E_UShort => E_UShort -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  Parameter(
    y
    type: E_UShort
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: E_UShort
          )
          type: System.UInt16
        )
        Convert(
          Parameter(
            y
            type: E_UShort
          )
          type: System.UInt16
        )
        type: System.UInt16
      )
      type: E_UShort
    )
  }
  return type: E_UShort
  type: System.Func`3[E_UShort,E_UShort,E_UShort]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_Integer And E_Integer => E_Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  Parameter(
    y
    type: E_Integer
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: E_Integer
          )
          type: System.Int32
        )
        Convert(
          Parameter(
            y
            type: E_Integer
          )
          type: System.Int32
        )
        type: System.Int32
      )
      type: E_Integer
    )
  }
  return type: E_Integer
  type: System.Func`3[E_Integer,E_Integer,E_Integer]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_UInteger And E_UInteger => E_UInteger -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  Parameter(
    y
    type: E_UInteger
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: E_UInteger
          )
          type: System.UInt32
        )
        Convert(
          Parameter(
            y
            type: E_UInteger
          )
          type: System.UInt32
        )
        type: System.UInt32
      )
      type: E_UInteger
    )
  }
  return type: E_UInteger
  type: System.Func`3[E_UInteger,E_UInteger,E_UInteger]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_Long And E_Long => E_Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  Parameter(
    y
    type: E_Long
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: E_Long
          )
          type: System.Int64
        )
        Convert(
          Parameter(
            y
            type: E_Long
          )
          type: System.Int64
        )
        type: System.Int64
      )
      type: E_Long
    )
  }
  return type: E_Long
  type: System.Func`3[E_Long,E_Long,E_Long]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_ULong And E_ULong => E_ULong -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_ULong
  )
  Parameter(
    y
    type: E_ULong
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: E_ULong
          )
          type: System.UInt64
        )
        Convert(
          Parameter(
            y
            type: E_ULong
          )
          type: System.UInt64
        )
        type: System.UInt64
      )
      type: E_ULong
    )
  }
  return type: E_ULong
  type: System.Func`3[E_ULong,E_ULong,E_ULong]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- Decimal And Decimal => Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  Parameter(
    y
    type: System.Decimal
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: System.Decimal
          )
          method: Int64 op_Explicit(System.Decimal) in System.Decimal
          type: System.Int64
        )
        Convert(
          Parameter(
            y
            type: System.Decimal
          )
          method: Int64 op_Explicit(System.Decimal) in System.Decimal
          type: System.Int64
        )
        type: System.Int64
      )
      method: System.Decimal op_Implicit(Int64) in System.Decimal
      type: System.Decimal
    )
  }
  return type: System.Decimal
  type: System.Func`3[System.Decimal,System.Decimal,System.Decimal]
)

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

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

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

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

-=-=-=-=-=-=-=-=- String And String => String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  Parameter(
    y
    type: System.String
  )
  body {
    Convert(
      And(
        Convert(
          Parameter(
            x
            type: System.String
          )
          method: Int64 ToLong(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.Int64
        )
        Convert(
          Parameter(
            y
            type: System.String
          )
          method: Int64 ToLong(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.Int64
        )
        type: System.Int64
      )
      method: System.String ToString(Int64) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`3[System.String,System.String,System.String]
)

-=-=-=-=-=-=-=-=- Object And Object => Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  Parameter(
    y
    type: System.Object
  )
  body {
    And(
      Parameter(
        x
        type: System.Object
      )
      Parameter(
        y
        type: System.Object
      )
      method: System.Object AndObject(System.Object, System.Object) in Microsoft.VisualBasic.CompilerServices.Operators
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`3[System.Object,System.Object,System.Object]
)

-=-=-=-=-=-=-=-=- SByte Or SByte => SByte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  Parameter(
    y
    type: System.SByte
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: System.SByte
          )
          type: System.Int32
        )
        Convert(
          Parameter(
            y
            type: System.SByte
          )
          type: System.Int32
        )
        type: System.Int32
      )
      type: System.SByte
    )
  }
  return type: System.SByte
  type: System.Func`3[System.SByte,System.SByte,System.SByte]
)

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

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

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

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

-=-=-=-=-=-=-=-=- E_SByte Or E_SByte => E_SByte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  Parameter(
    y
    type: E_SByte
  )
  body {
    Convert(
      Convert(
        Or(
          Convert(
            Convert(
              Parameter(
                x
                type: E_SByte
              )
              type: System.SByte
            )
            type: System.Int32
          )
          Convert(
            Convert(
              Parameter(
                y
                type: E_SByte
              )
              type: System.SByte
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: System.SByte
      )
      type: E_SByte
    )
  }
  return type: E_SByte
  type: System.Func`3[E_SByte,E_SByte,E_SByte]
)

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

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

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

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

-=-=-=-=-=-=-=-=- Byte Or Byte => Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  Parameter(
    y
    type: System.Byte
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: System.Byte
          )
          type: System.Int32
        )
        Convert(
          Parameter(
            y
            type: System.Byte
          )
          type: System.Int32
        )
        type: System.Int32
      )
      type: System.Byte
    )
  }
  return type: System.Byte
  type: System.Func`3[System.Byte,System.Byte,System.Byte]
)

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

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

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

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

-=-=-=-=-=-=-=-=- E_Byte Or E_Byte => E_Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  Parameter(
    y
    type: E_Byte
  )
  body {
    Convert(
      Convert(
        Or(
          Convert(
            Convert(
              Parameter(
                x
                type: E_Byte
              )
              type: System.Byte
            )
            type: System.Int32
          )
          Convert(
            Convert(
              Parameter(
                y
                type: E_Byte
              )
              type: System.Byte
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: System.Byte
      )
      type: E_Byte
    )
  }
  return type: E_Byte
  type: System.Func`3[E_Byte,E_Byte,E_Byte]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_Short Or E_Short => E_Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  Parameter(
    y
    type: E_Short
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: E_Short
          )
          type: System.Int16
        )
        Convert(
          Parameter(
            y
            type: E_Short
          )
          type: System.Int16
        )
        type: System.Int16
      )
      type: E_Short
    )
  }
  return type: E_Short
  type: System.Func`3[E_Short,E_Short,E_Short]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_UShort Or E_UShort => E_UShort -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  Parameter(
    y
    type: E_UShort
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: E_UShort
          )
          type: System.UInt16
        )
        Convert(
          Parameter(
            y
            type: E_UShort
          )
          type: System.UInt16
        )
        type: System.UInt16
      )
      type: E_UShort
    )
  }
  return type: E_UShort
  type: System.Func`3[E_UShort,E_UShort,E_UShort]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_Integer Or E_Integer => E_Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  Parameter(
    y
    type: E_Integer
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: E_Integer
          )
          type: System.Int32
        )
        Convert(
          Parameter(
            y
            type: E_Integer
          )
          type: System.Int32
        )
        type: System.Int32
      )
      type: E_Integer
    )
  }
  return type: E_Integer
  type: System.Func`3[E_Integer,E_Integer,E_Integer]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_UInteger Or E_UInteger => E_UInteger -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  Parameter(
    y
    type: E_UInteger
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: E_UInteger
          )
          type: System.UInt32
        )
        Convert(
          Parameter(
            y
            type: E_UInteger
          )
          type: System.UInt32
        )
        type: System.UInt32
      )
      type: E_UInteger
    )
  }
  return type: E_UInteger
  type: System.Func`3[E_UInteger,E_UInteger,E_UInteger]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_Long Or E_Long => E_Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  Parameter(
    y
    type: E_Long
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: E_Long
          )
          type: System.Int64
        )
        Convert(
          Parameter(
            y
            type: E_Long
          )
          type: System.Int64
        )
        type: System.Int64
      )
      type: E_Long
    )
  }
  return type: E_Long
  type: System.Func`3[E_Long,E_Long,E_Long]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_ULong Or E_ULong => E_ULong -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_ULong
  )
  Parameter(
    y
    type: E_ULong
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: E_ULong
          )
          type: System.UInt64
        )
        Convert(
          Parameter(
            y
            type: E_ULong
          )
          type: System.UInt64
        )
        type: System.UInt64
      )
      type: E_ULong
    )
  }
  return type: E_ULong
  type: System.Func`3[E_ULong,E_ULong,E_ULong]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- Decimal Or Decimal => Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  Parameter(
    y
    type: System.Decimal
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: System.Decimal
          )
          method: Int64 op_Explicit(System.Decimal) in System.Decimal
          type: System.Int64
        )
        Convert(
          Parameter(
            y
            type: System.Decimal
          )
          method: Int64 op_Explicit(System.Decimal) in System.Decimal
          type: System.Int64
        )
        type: System.Int64
      )
      method: System.Decimal op_Implicit(Int64) in System.Decimal
      type: System.Decimal
    )
  }
  return type: System.Decimal
  type: System.Func`3[System.Decimal,System.Decimal,System.Decimal]
)

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

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

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

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

-=-=-=-=-=-=-=-=- String Or String => String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  Parameter(
    y
    type: System.String
  )
  body {
    Convert(
      Or(
        Convert(
          Parameter(
            x
            type: System.String
          )
          method: Int64 ToLong(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.Int64
        )
        Convert(
          Parameter(
            y
            type: System.String
          )
          method: Int64 ToLong(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.Int64
        )
        type: System.Int64
      )
      method: System.String ToString(Int64) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`3[System.String,System.String,System.String]
)

-=-=-=-=-=-=-=-=- Object Or Object => Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  Parameter(
    y
    type: System.Object
  )
  body {
    Or(
      Parameter(
        x
        type: System.Object
      )
      Parameter(
        y
        type: System.Object
      )
      method: System.Object OrObject(System.Object, System.Object) in Microsoft.VisualBasic.CompilerServices.Operators
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`3[System.Object,System.Object,System.Object]
)

-=-=-=-=-=-=-=-=- SByte Xor SByte => SByte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  Parameter(
    y
    type: System.SByte
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: System.SByte
          )
          type: System.Int32
        )
        Convert(
          Parameter(
            y
            type: System.SByte
          )
          type: System.Int32
        )
        type: System.Int32
      )
      type: System.SByte
    )
  }
  return type: System.SByte
  type: System.Func`3[System.SByte,System.SByte,System.SByte]
)

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

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

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

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

-=-=-=-=-=-=-=-=- E_SByte Xor E_SByte => E_SByte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  Parameter(
    y
    type: E_SByte
  )
  body {
    Convert(
      Convert(
        ExclusiveOr(
          Convert(
            Convert(
              Parameter(
                x
                type: E_SByte
              )
              type: System.SByte
            )
            type: System.Int32
          )
          Convert(
            Convert(
              Parameter(
                y
                type: E_SByte
              )
              type: System.SByte
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: System.SByte
      )
      type: E_SByte
    )
  }
  return type: E_SByte
  type: System.Func`3[E_SByte,E_SByte,E_SByte]
)

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

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

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

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

-=-=-=-=-=-=-=-=- Byte Xor Byte => Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  Parameter(
    y
    type: System.Byte
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: System.Byte
          )
          type: System.Int32
        )
        Convert(
          Parameter(
            y
            type: System.Byte
          )
          type: System.Int32
        )
        type: System.Int32
      )
      type: System.Byte
    )
  }
  return type: System.Byte
  type: System.Func`3[System.Byte,System.Byte,System.Byte]
)

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

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

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

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

-=-=-=-=-=-=-=-=- E_Byte Xor E_Byte => E_Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  Parameter(
    y
    type: E_Byte
  )
  body {
    Convert(
      Convert(
        ExclusiveOr(
          Convert(
            Convert(
              Parameter(
                x
                type: E_Byte
              )
              type: System.Byte
            )
            type: System.Int32
          )
          Convert(
            Convert(
              Parameter(
                y
                type: E_Byte
              )
              type: System.Byte
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: System.Byte
      )
      type: E_Byte
    )
  }
  return type: E_Byte
  type: System.Func`3[E_Byte,E_Byte,E_Byte]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_Short Xor E_Short => E_Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  Parameter(
    y
    type: E_Short
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: E_Short
          )
          type: System.Int16
        )
        Convert(
          Parameter(
            y
            type: E_Short
          )
          type: System.Int16
        )
        type: System.Int16
      )
      type: E_Short
    )
  }
  return type: E_Short
  type: System.Func`3[E_Short,E_Short,E_Short]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_UShort Xor E_UShort => E_UShort -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  Parameter(
    y
    type: E_UShort
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: E_UShort
          )
          type: System.UInt16
        )
        Convert(
          Parameter(
            y
            type: E_UShort
          )
          type: System.UInt16
        )
        type: System.UInt16
      )
      type: E_UShort
    )
  }
  return type: E_UShort
  type: System.Func`3[E_UShort,E_UShort,E_UShort]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_Integer Xor E_Integer => E_Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  Parameter(
    y
    type: E_Integer
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: E_Integer
          )
          type: System.Int32
        )
        Convert(
          Parameter(
            y
            type: E_Integer
          )
          type: System.Int32
        )
        type: System.Int32
      )
      type: E_Integer
    )
  }
  return type: E_Integer
  type: System.Func`3[E_Integer,E_Integer,E_Integer]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_UInteger Xor E_UInteger => E_UInteger -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  Parameter(
    y
    type: E_UInteger
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: E_UInteger
          )
          type: System.UInt32
        )
        Convert(
          Parameter(
            y
            type: E_UInteger
          )
          type: System.UInt32
        )
        type: System.UInt32
      )
      type: E_UInteger
    )
  }
  return type: E_UInteger
  type: System.Func`3[E_UInteger,E_UInteger,E_UInteger]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_Long Xor E_Long => E_Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  Parameter(
    y
    type: E_Long
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: E_Long
          )
          type: System.Int64
        )
        Convert(
          Parameter(
            y
            type: E_Long
          )
          type: System.Int64
        )
        type: System.Int64
      )
      type: E_Long
    )
  }
  return type: E_Long
  type: System.Func`3[E_Long,E_Long,E_Long]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- E_ULong Xor E_ULong => E_ULong -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_ULong
  )
  Parameter(
    y
    type: E_ULong
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: E_ULong
          )
          type: System.UInt64
        )
        Convert(
          Parameter(
            y
            type: E_ULong
          )
          type: System.UInt64
        )
        type: System.UInt64
      )
      type: E_ULong
    )
  }
  return type: E_ULong
  type: System.Func`3[E_ULong,E_ULong,E_ULong]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- Decimal Xor Decimal => Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  Parameter(
    y
    type: System.Decimal
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: System.Decimal
          )
          method: Int64 op_Explicit(System.Decimal) in System.Decimal
          type: System.Int64
        )
        Convert(
          Parameter(
            y
            type: System.Decimal
          )
          method: Int64 op_Explicit(System.Decimal) in System.Decimal
          type: System.Int64
        )
        type: System.Int64
      )
      method: System.Decimal op_Implicit(Int64) in System.Decimal
      type: System.Decimal
    )
  }
  return type: System.Decimal
  type: System.Func`3[System.Decimal,System.Decimal,System.Decimal]
)

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

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

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

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

-=-=-=-=-=-=-=-=- String Xor String => String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  Parameter(
    y
    type: System.String
  )
  body {
    Convert(
      ExclusiveOr(
        Convert(
          Parameter(
            x
            type: System.String
          )
          method: Int64 ToLong(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.Int64
        )
        Convert(
          Parameter(
            y
            type: System.String
          )
          method: Int64 ToLong(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.Int64
        )
        type: System.Int64
      )
      method: System.String ToString(Int64) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`3[System.String,System.String,System.String]
)

-=-=-=-=-=-=-=-=- Object Xor Object => Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  Parameter(
    y
    type: System.Object
  )
  body {
    ExclusiveOr(
      Parameter(
        x
        type: System.Object
      )
      Parameter(
        y
        type: System.Object
      )
      method: System.Object XorObject(System.Object, System.Object) in Microsoft.VisualBasic.CompilerServices.Operators
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`3[System.Object,System.Object,System.Object]
)