-=-=-=-=-=-=-=-=- CType(SByte, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.SByte
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.SByte,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- SByte -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.SByte,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(SByte, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.SByte,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- SByte -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.SByte,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(SByte, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.SByte,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- SByte -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.SByte,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(SByte, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.SByte,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- SByte -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.SByte,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(SByte, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.SByte,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- SByte -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.SByte,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(SByte, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.SByte,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- SByte -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.SByte,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(SByte, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.SByte,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- SByte -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.SByte
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.SByte,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(SByte, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: System.SByte
          )
          type: System.Int32
        )
        method: Boolean ToBoolean(Int32) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.SByte,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- SByte -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.SByte
        )
        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`2[System.SByte,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(SByte, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.SByte
        )
        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`2[System.SByte,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- SByte -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: System.SByte
          )
          type: System.Int32
        )
        method: System.Decimal op_Implicit(Int32) 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`2[System.SByte,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- SByte -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    Convert(
      Parameter(
        x
        type: System.SByte
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.SByte,System.Object]
)

-=-=-=-=-=-=-=-=- CType(SByte?, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Nullable`1[System.SByte],System.Nullable`1[System.SByte]]
)

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

-=-=-=-=-=-=-=-=- CType(SByte?, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Nullable`1[System.SByte],System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- SByte? -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Nullable`1[System.SByte],System.Nullable`1[E_Byte]]
)

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

-=-=-=-=-=-=-=-=- SByte? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Nullable`1[System.SByte],System.Nullable`1[E_Short]]
)

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

-=-=-=-=-=-=-=-=- SByte? -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Nullable`1[System.SByte],System.Nullable`1[E_UShort]]
)

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

-=-=-=-=-=-=-=-=- SByte? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Nullable`1[System.SByte],System.Nullable`1[E_Integer]]
)

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

-=-=-=-=-=-=-=-=- SByte? -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Nullable`1[System.SByte],System.Nullable`1[E_UInteger]]
)

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

-=-=-=-=-=-=-=-=- SByte? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Nullable`1[System.SByte],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(SByte?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.SByte]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Int32) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[System.SByte],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- SByte? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.SByte]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: System.Decimal op_Implicit(Int32) in System.Decimal
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[System.SByte],System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- SByte? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.SByte]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[System.SByte],System.Object]
)

-=-=-=-=-=-=-=-=- CType(E_SByte, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[E_SByte,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_SByte -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: E_SByte
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[E_SByte,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_SByte, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[E_SByte,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_SByte -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[E_SByte,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(E_SByte, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[E_SByte,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- E_SByte -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[E_SByte,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(E_SByte, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[E_SByte,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- E_SByte -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[E_SByte,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(E_SByte, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[E_SByte,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- E_SByte -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[E_SByte,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(E_SByte, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[E_SByte,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- E_SByte -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[E_SByte,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(E_SByte, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[E_SByte,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- E_SByte -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_SByte
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[E_SByte,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_SByte, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_SByte
          )
          type: System.Int32
        )
        method: Boolean ToBoolean(Int32) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[E_SByte,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- E_SByte -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_SByte
        )
        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`2[E_SByte,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(E_SByte, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_SByte
        )
        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`2[E_SByte,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- E_SByte -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_SByte
          )
          type: System.Int32
        )
        method: System.Decimal op_Implicit(Int32) 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`2[E_SByte,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_SByte -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    Convert(
      Parameter(
        x
        type: E_SByte
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[E_SByte,System.Object]
)

-=-=-=-=-=-=-=-=- CType(E_SByte?, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Nullable`1[E_SByte],System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_SByte? -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Nullable`1[E_SByte],System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_SByte?, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Nullable`1[E_SByte],System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_SByte? -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Nullable`1[E_SByte],System.Nullable`1[E_Byte]]
)

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

-=-=-=-=-=-=-=-=- E_SByte? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Nullable`1[E_SByte],System.Nullable`1[E_Short]]
)

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

-=-=-=-=-=-=-=-=- E_SByte? -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Nullable`1[E_SByte],System.Nullable`1[E_UShort]]
)

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

-=-=-=-=-=-=-=-=- E_SByte? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Nullable`1[E_SByte],System.Nullable`1[E_Integer]]
)

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

-=-=-=-=-=-=-=-=- E_SByte? -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Nullable`1[E_SByte],System.Nullable`1[E_UInteger]]
)

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

-=-=-=-=-=-=-=-=- E_SByte? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Nullable`1[E_SByte],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_SByte?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_SByte]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Int32) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[E_SByte],System.Nullable`1[System.Boolean]]
)

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

-=-=-=-=-=-=-=-=- CType(E_SByte?, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[E_SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Double]
    )
  }
  return type: System.Nullable`1[System.Double]
  type: System.Func`2[System.Nullable`1[E_SByte],System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- E_SByte? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_SByte]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: System.Decimal op_Implicit(Int32) in System.Decimal
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[E_SByte],System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_SByte? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[E_SByte]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[E_SByte],System.Object]
)

-=-=-=-=-=-=-=-=- CType(Byte, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Byte,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Byte -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Byte,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Byte, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Byte
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Byte,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- Byte -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Byte,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(Byte, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Byte,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- Byte -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Byte,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Byte, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Byte,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- Byte -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Byte,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(Byte, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Byte,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- Byte -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Byte,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Byte, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Byte,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- Byte -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Byte,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(Byte, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Byte,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- Byte -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Byte
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Byte,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(Byte, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: System.Byte
          )
          type: System.Int32
        )
        method: Boolean ToBoolean(Int32) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Byte,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- Byte -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Byte
        )
        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`2[System.Byte,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(Byte, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Byte
        )
        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`2[System.Byte,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- Byte -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: System.Byte
          )
          type: System.Int32
        )
        method: System.Decimal op_Implicit(Int32) 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`2[System.Byte,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- Byte -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Byte
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Byte,System.Object]
)

-=-=-=-=-=-=-=-=- CType(Byte?, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Nullable`1[System.Byte],System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Byte? -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Nullable`1[System.Byte],System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Byte?, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Nullable`1[System.Byte],System.Nullable`1[System.Byte]]
)

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

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

-=-=-=-=-=-=-=-=- Byte? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Nullable`1[System.Byte],System.Nullable`1[E_Short]]
)

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

-=-=-=-=-=-=-=-=- Byte? -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Nullable`1[System.Byte],System.Nullable`1[E_UShort]]
)

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

-=-=-=-=-=-=-=-=- Byte? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Nullable`1[System.Byte],System.Nullable`1[E_Integer]]
)

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

-=-=-=-=-=-=-=-=- Byte? -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Nullable`1[System.Byte],System.Nullable`1[E_UInteger]]
)

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

-=-=-=-=-=-=-=-=- Byte? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Nullable`1[System.Byte],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(Byte?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Byte]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Int32) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[System.Byte],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- Byte? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Byte]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: System.Decimal op_Implicit(Int32) in System.Decimal
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[System.Byte],System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- Byte? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Byte]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[System.Byte],System.Object]
)

-=-=-=-=-=-=-=-=- CType(E_Byte, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[E_Byte,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_Byte -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[E_Byte,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_Byte, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[E_Byte,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_Byte -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: E_Byte
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[E_Byte,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(E_Byte, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[E_Byte,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- E_Byte -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[E_Byte,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(E_Byte, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[E_Byte,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- E_Byte -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[E_Byte,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(E_Byte, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[E_Byte,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- E_Byte -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[E_Byte,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(E_Byte, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[E_Byte,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- E_Byte -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[E_Byte,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(E_Byte, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[E_Byte,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- E_Byte -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Byte
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[E_Byte,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_Byte, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_Byte
          )
          type: System.Int32
        )
        method: Boolean ToBoolean(Int32) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[E_Byte,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- E_Byte -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_Byte
        )
        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`2[E_Byte,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(E_Byte, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_Byte
        )
        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`2[E_Byte,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- E_Byte -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_Byte
          )
          type: System.Int32
        )
        method: System.Decimal op_Implicit(Int32) 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`2[E_Byte,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_Byte -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    Convert(
      Parameter(
        x
        type: E_Byte
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[E_Byte,System.Object]
)

-=-=-=-=-=-=-=-=- CType(E_Byte?, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Nullable`1[E_Byte],System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_Byte? -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Nullable`1[E_Byte],System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_Byte?, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Nullable`1[E_Byte],System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_Byte? -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Nullable`1[E_Byte],System.Nullable`1[E_Byte]]
)

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

-=-=-=-=-=-=-=-=- E_Byte? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Nullable`1[E_Byte],System.Nullable`1[E_Short]]
)

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

-=-=-=-=-=-=-=-=- E_Byte? -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Nullable`1[E_Byte],System.Nullable`1[E_UShort]]
)

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

-=-=-=-=-=-=-=-=- E_Byte? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Nullable`1[E_Byte],System.Nullable`1[E_Integer]]
)

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

-=-=-=-=-=-=-=-=- E_Byte? -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Nullable`1[E_Byte],System.Nullable`1[E_UInteger]]
)

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

-=-=-=-=-=-=-=-=- E_Byte? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Nullable`1[E_Byte],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_Byte?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_Byte]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Int32) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[E_Byte],System.Nullable`1[System.Boolean]]
)

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

-=-=-=-=-=-=-=-=- CType(E_Byte?, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[E_Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Double]
    )
  }
  return type: System.Nullable`1[System.Double]
  type: System.Func`2[System.Nullable`1[E_Byte],System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- E_Byte? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_Byte]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: System.Decimal op_Implicit(Int32) in System.Decimal
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[E_Byte],System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_Byte? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[E_Byte]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[E_Byte],System.Object]
)

-=-=-=-=-=-=-=-=- CType(Short, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Int16,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Short -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Int16,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Short, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Int16,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- Short -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Int16,System.Nullable`1[E_Byte]]
)

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

-=-=-=-=-=-=-=-=- Short -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Int16,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Short, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Int16,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- Short -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Int16,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(Short, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Int16,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- Short -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Int16,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Short, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Int16,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- Short -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Int16,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(Short, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Int16,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- Short -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int16
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Int16,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(Short, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: System.Int16
          )
          type: System.Int32
        )
        method: Boolean ToBoolean(Int32) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Int16,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- Short -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Int16
        )
        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`2[System.Int16,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(Short, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Int16
        )
        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`2[System.Int16,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- Short -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: System.Int16
          )
          type: System.Int32
        )
        method: System.Decimal op_Implicit(Int32) 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`2[System.Int16,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- Short -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Int16
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Int16,System.Object]
)

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

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

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

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

-=-=-=-=-=-=-=-=- CType(Short?, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int16]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Nullable`1[System.Int16],System.Nullable`1[System.Int16]]
)

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

-=-=-=-=-=-=-=-=- CType(Short?, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int16]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Int16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Nullable`1[System.Int16],System.Nullable`1[System.UInt16]]
)

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

-=-=-=-=-=-=-=-=- CType(Short?, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int16]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Int16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Nullable`1[System.Int16],System.Nullable`1[System.Int32]]
)

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

-=-=-=-=-=-=-=-=- CType(Short?, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int16]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Int16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Nullable`1[System.Int16],System.Nullable`1[System.UInt32]]
)

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

-=-=-=-=-=-=-=-=- CType(Short?, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int16]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Int16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Nullable`1[System.Int16],System.Nullable`1[System.Int64]]
)

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

-=-=-=-=-=-=-=-=- CType(Short?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int16]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Int16]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Int32) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[System.Int16],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- Short? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int16]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Int16]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: System.Decimal op_Implicit(Int32) in System.Decimal
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[System.Int16],System.Nullable`1[System.Decimal]]
)

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

-=-=-=-=-=-=-=-=- CType(E_Short, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[E_Short,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_Short -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[E_Short,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_Short, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[E_Short,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_Short -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[E_Short,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(E_Short, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[E_Short,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- E_Short -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: E_Short
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[E_Short,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(E_Short, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[E_Short,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- E_Short -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[E_Short,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(E_Short, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[E_Short,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- E_Short -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[E_Short,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(E_Short, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[E_Short,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- E_Short -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[E_Short,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(E_Short, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[E_Short,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- E_Short -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Short
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[E_Short,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_Short, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_Short
          )
          type: System.Int32
        )
        method: Boolean ToBoolean(Int32) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[E_Short,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- E_Short -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_Short
        )
        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`2[E_Short,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(E_Short, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_Short
        )
        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`2[E_Short,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- E_Short -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_Short
          )
          type: System.Int32
        )
        method: System.Decimal op_Implicit(Int32) 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`2[E_Short,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_Short -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    Convert(
      Parameter(
        x
        type: E_Short
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[E_Short,System.Object]
)

-=-=-=-=-=-=-=-=- CType(E_Short?, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Short]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Short]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Nullable`1[E_Short],System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_Short? -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Short]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Short]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Nullable`1[E_Short],System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_Short?, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Short]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Short]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Nullable`1[E_Short],System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_Short? -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Short]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Short]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Nullable`1[E_Short],System.Nullable`1[E_Byte]]
)

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

-=-=-=-=-=-=-=-=- E_Short? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Short]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Nullable`1[E_Short],System.Nullable`1[E_Short]]
)

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

-=-=-=-=-=-=-=-=- E_Short? -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Short]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Short]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Nullable`1[E_Short],System.Nullable`1[E_UShort]]
)

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

-=-=-=-=-=-=-=-=- E_Short? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Short]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Short]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Nullable`1[E_Short],System.Nullable`1[E_Integer]]
)

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

-=-=-=-=-=-=-=-=- E_Short? -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Short]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Short]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Nullable`1[E_Short],System.Nullable`1[E_UInteger]]
)

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

-=-=-=-=-=-=-=-=- E_Short? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Short]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Short]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Nullable`1[E_Short],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_Short?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Short]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_Short]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Int32) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[E_Short],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- E_Short? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Short]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_Short]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: System.Decimal op_Implicit(Int32) in System.Decimal
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[E_Short],System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_Short? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Short]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[E_Short]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[E_Short],System.Object]
)

-=-=-=-=-=-=-=-=- CType(UShort, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.UInt16,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- UShort -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.UInt16,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(UShort, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.UInt16,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- UShort -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.UInt16,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(UShort, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.UInt16,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- UShort -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.UInt16,System.Nullable`1[E_Short]]
)

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

-=-=-=-=-=-=-=-=- UShort -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.UInt16,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(UShort, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.UInt16,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- UShort -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.UInt16,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(UShort, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.UInt16,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- UShort -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.UInt16,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(UShort, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.UInt16,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- UShort -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt16
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.UInt16,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(UShort, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: System.UInt16
          )
          type: System.Int32
        )
        method: Boolean ToBoolean(Int32) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.UInt16,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- UShort -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.UInt16
        )
        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`2[System.UInt16,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(UShort, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.UInt16
        )
        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`2[System.UInt16,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- UShort -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: System.UInt16
          )
          type: System.Int32
        )
        method: System.Decimal op_Implicit(Int32) 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`2[System.UInt16,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- UShort -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    Convert(
      Parameter(
        x
        type: System.UInt16
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.UInt16,System.Object]
)

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

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

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

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

-=-=-=-=-=-=-=-=- CType(UShort?, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt16]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.UInt16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Nullable`1[System.UInt16],System.Nullable`1[System.Int16]]
)

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

-=-=-=-=-=-=-=-=- CType(UShort?, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt16]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Nullable`1[System.UInt16],System.Nullable`1[System.UInt16]]
)

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

-=-=-=-=-=-=-=-=- CType(UShort?, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt16]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.UInt16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Nullable`1[System.UInt16],System.Nullable`1[System.Int32]]
)

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

-=-=-=-=-=-=-=-=- CType(UShort?, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt16]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.UInt16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Nullable`1[System.UInt16],System.Nullable`1[System.UInt32]]
)

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

-=-=-=-=-=-=-=-=- CType(UShort?, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt16]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.UInt16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Nullable`1[System.UInt16],System.Nullable`1[System.Int64]]
)

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

-=-=-=-=-=-=-=-=- CType(UShort?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt16]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.UInt16]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Int32) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[System.UInt16],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- UShort? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt16]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.UInt16]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: System.Decimal op_Implicit(Int32) in System.Decimal
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[System.UInt16],System.Nullable`1[System.Decimal]]
)

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

-=-=-=-=-=-=-=-=- CType(E_UShort, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[E_UShort,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_UShort -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[E_UShort,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_UShort, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[E_UShort,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_UShort -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[E_UShort,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(E_UShort, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[E_UShort,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- E_UShort -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[E_UShort,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(E_UShort, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[E_UShort,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- E_UShort -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: E_UShort
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[E_UShort,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(E_UShort, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[E_UShort,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- E_UShort -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[E_UShort,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(E_UShort, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[E_UShort,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- E_UShort -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[E_UShort,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(E_UShort, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[E_UShort,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- E_UShort -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UShort
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[E_UShort,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_UShort, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_UShort
          )
          type: System.Int32
        )
        method: Boolean ToBoolean(Int32) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[E_UShort,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- E_UShort -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_UShort
        )
        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`2[E_UShort,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(E_UShort, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_UShort
        )
        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`2[E_UShort,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- E_UShort -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_UShort
          )
          type: System.Int32
        )
        method: System.Decimal op_Implicit(Int32) 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`2[E_UShort,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_UShort -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    Convert(
      Parameter(
        x
        type: E_UShort
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[E_UShort,System.Object]
)

-=-=-=-=-=-=-=-=- CType(E_UShort?, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UShort]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Nullable`1[E_UShort],System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_UShort? -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UShort]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Nullable`1[E_UShort],System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_UShort?, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UShort]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Nullable`1[E_UShort],System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_UShort? -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UShort]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Nullable`1[E_UShort],System.Nullable`1[E_Byte]]
)

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

-=-=-=-=-=-=-=-=- E_UShort? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UShort]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Nullable`1[E_UShort],System.Nullable`1[E_Short]]
)

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

-=-=-=-=-=-=-=-=- E_UShort? -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Nullable`1[E_UShort],System.Nullable`1[E_UShort]]
)

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

-=-=-=-=-=-=-=-=- E_UShort? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UShort]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Nullable`1[E_UShort],System.Nullable`1[E_Integer]]
)

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

-=-=-=-=-=-=-=-=- E_UShort? -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UShort]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Nullable`1[E_UShort],System.Nullable`1[E_UInteger]]
)

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

-=-=-=-=-=-=-=-=- E_UShort? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UShort]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Nullable`1[E_UShort],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_UShort?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_UShort]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Int32) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[E_UShort],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- E_UShort? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_UShort]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: System.Decimal op_Implicit(Int32) in System.Decimal
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[E_UShort],System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_UShort? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[E_UShort]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[E_UShort],System.Object]
)

-=-=-=-=-=-=-=-=- CType(Integer, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Int32,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Integer -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Int32,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Integer, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Int32,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- Integer -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Int32,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(Integer, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Int32,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- Integer -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Int32,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Integer, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Int32,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- Integer -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Int32,System.Nullable`1[E_UShort]]
)

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

-=-=-=-=-=-=-=-=- Integer -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Int32,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Integer, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Int32,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- Integer -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Int32,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(Integer, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Int32,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- Integer -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int32
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Int32,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(Integer, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Int32
        )
        method: Boolean ToBoolean(Int32) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Int32,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- Integer -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Int32
        )
        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`2[System.Int32,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(Integer, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Int32
        )
        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`2[System.Int32,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- Integer -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Int32
        )
        method: System.Decimal op_Implicit(Int32) 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`2[System.Int32,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- Integer -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int32
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Int32
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Int32,System.Object]
)

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

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

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

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

-=-=-=-=-=-=-=-=- CType(Integer?, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int32]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Nullable`1[System.Int32],System.Nullable`1[System.Int16]]
)

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

-=-=-=-=-=-=-=-=- CType(Integer?, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int32]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Nullable`1[System.Int32],System.Nullable`1[System.UInt16]]
)

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

-=-=-=-=-=-=-=-=- CType(Integer?, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int32]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Nullable`1[System.Int32],System.Nullable`1[System.Int32]]
)

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

-=-=-=-=-=-=-=-=- CType(Integer?, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int32]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Nullable`1[System.Int32],System.Nullable`1[System.UInt32]]
)

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

-=-=-=-=-=-=-=-=- CType(Integer?, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int32]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Nullable`1[System.Int32],System.Nullable`1[System.Int64]]
)

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

-=-=-=-=-=-=-=-=- CType(Integer?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int32]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Int32) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[System.Int32],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- Integer? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int32]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: System.Decimal op_Implicit(Int32) in System.Decimal
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[System.Int32],System.Nullable`1[System.Decimal]]
)

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

-=-=-=-=-=-=-=-=- CType(E_Integer, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[E_Integer,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_Integer -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[E_Integer,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_Integer, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[E_Integer,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_Integer -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[E_Integer,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(E_Integer, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[E_Integer,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- E_Integer -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[E_Integer,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(E_Integer, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[E_Integer,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- E_Integer -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[E_Integer,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(E_Integer, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[E_Integer,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- E_Integer -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: E_Integer
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[E_Integer,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(E_Integer, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[E_Integer,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- E_Integer -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[E_Integer,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(E_Integer, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[E_Integer,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- E_Integer -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Integer
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[E_Integer,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_Integer, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_Integer
          )
          type: System.Int32
        )
        method: Boolean ToBoolean(Int32) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[E_Integer,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- E_Integer -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_Integer
        )
        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`2[E_Integer,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(E_Integer, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_Integer
        )
        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`2[E_Integer,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- E_Integer -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_Integer
          )
          type: System.Int32
        )
        method: System.Decimal op_Implicit(Int32) 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`2[E_Integer,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_Integer -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    Convert(
      Parameter(
        x
        type: E_Integer
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[E_Integer,System.Object]
)

-=-=-=-=-=-=-=-=- CType(E_Integer?, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Integer]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Integer]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Nullable`1[E_Integer],System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_Integer? -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Integer]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Integer]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Nullable`1[E_Integer],System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_Integer?, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Integer]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Integer]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Nullable`1[E_Integer],System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_Integer? -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Integer]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Integer]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Nullable`1[E_Integer],System.Nullable`1[E_Byte]]
)

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

-=-=-=-=-=-=-=-=- E_Integer? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Integer]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Integer]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Nullable`1[E_Integer],System.Nullable`1[E_Short]]
)

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

-=-=-=-=-=-=-=-=- E_Integer? -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Integer]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Integer]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Nullable`1[E_Integer],System.Nullable`1[E_UShort]]
)

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

-=-=-=-=-=-=-=-=- E_Integer? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Integer]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Nullable`1[E_Integer],System.Nullable`1[E_Integer]]
)

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

-=-=-=-=-=-=-=-=- E_Integer? -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Integer]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Integer]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Nullable`1[E_Integer],System.Nullable`1[E_UInteger]]
)

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

-=-=-=-=-=-=-=-=- E_Integer? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Integer]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Integer]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Nullable`1[E_Integer],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_Integer?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Integer]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_Integer]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Int32) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[E_Integer],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- E_Integer? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Integer]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_Integer]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      method: System.Decimal op_Implicit(Int32) in System.Decimal
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[E_Integer],System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_Integer? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Integer]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[E_Integer]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[E_Integer],System.Object]
)

-=-=-=-=-=-=-=-=- CType(UInteger, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.UInt32,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- UInteger -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.UInt32,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(UInteger, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.UInt32,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- UInteger -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.UInt32,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(UInteger, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.UInt32,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- UInteger -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.UInt32,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(UInteger, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.UInt32,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- UInteger -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.UInt32,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(UInteger, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.UInt32,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- UInteger -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.UInt32,System.Nullable`1[E_Integer]]
)

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

-=-=-=-=-=-=-=-=- UInteger -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.UInt32,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(UInteger, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.UInt32,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- UInteger -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.UInt32
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.UInt32,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(UInteger, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.UInt32
        )
        method: Boolean ToBoolean(UInt32) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.UInt32,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- UInteger -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.UInt32
        )
        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`2[System.UInt32,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(UInteger, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.UInt32
        )
        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`2[System.UInt32,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- UInteger -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.UInt32
        )
        method: System.Decimal op_Implicit(UInt32) 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`2[System.UInt32,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- UInteger -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt32
  )
  body {
    Convert(
      Parameter(
        x
        type: System.UInt32
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.UInt32,System.Object]
)

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

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

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

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

-=-=-=-=-=-=-=-=- CType(UInteger?, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt32]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.UInt32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Nullable`1[System.UInt32],System.Nullable`1[System.Int16]]
)

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

-=-=-=-=-=-=-=-=- CType(UInteger?, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt32]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.UInt32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Nullable`1[System.UInt32],System.Nullable`1[System.UInt16]]
)

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

-=-=-=-=-=-=-=-=- CType(UInteger?, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt32]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.UInt32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Nullable`1[System.UInt32],System.Nullable`1[System.Int32]]
)

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

-=-=-=-=-=-=-=-=- CType(UInteger?, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt32]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Nullable`1[System.UInt32],System.Nullable`1[System.UInt32]]
)

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

-=-=-=-=-=-=-=-=- CType(UInteger?, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt32]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.UInt32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Nullable`1[System.UInt32],System.Nullable`1[System.Int64]]
)

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

-=-=-=-=-=-=-=-=- CType(UInteger?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt32]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.UInt32]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(UInt32) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[System.UInt32],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- UInteger? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.UInt32]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.UInt32]
      )
      Lifted
      LiftedToNull
      method: System.Decimal op_Implicit(UInt32) in System.Decimal
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[System.UInt32],System.Nullable`1[System.Decimal]]
)

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

-=-=-=-=-=-=-=-=- CType(E_UInteger, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[E_UInteger,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_UInteger -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[E_UInteger,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_UInteger, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[E_UInteger,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_UInteger -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[E_UInteger,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(E_UInteger, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[E_UInteger,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- E_UInteger -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[E_UInteger,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(E_UInteger, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[E_UInteger,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- E_UInteger -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[E_UInteger,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(E_UInteger, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[E_UInteger,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- E_UInteger -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[E_UInteger,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(E_UInteger, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[E_UInteger,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- E_UInteger -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: E_UInteger
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[E_UInteger,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(E_UInteger, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[E_UInteger,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- E_UInteger -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_UInteger
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[E_UInteger,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_UInteger, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_UInteger
          )
          type: System.UInt32
        )
        method: Boolean ToBoolean(UInt32) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[E_UInteger,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- E_UInteger -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_UInteger
        )
        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`2[E_UInteger,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(E_UInteger, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_UInteger
        )
        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`2[E_UInteger,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- E_UInteger -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_UInteger
          )
          type: System.UInt32
        )
        method: System.Decimal op_Implicit(UInt32) 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`2[E_UInteger,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_UInteger -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    Convert(
      Parameter(
        x
        type: E_UInteger
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[E_UInteger,System.Object]
)

-=-=-=-=-=-=-=-=- CType(E_UInteger?, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UInteger]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Nullable`1[E_UInteger],System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_UInteger? -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UInteger]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Nullable`1[E_UInteger],System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_UInteger?, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UInteger]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Nullable`1[E_UInteger],System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_UInteger? -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UInteger]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Nullable`1[E_UInteger],System.Nullable`1[E_Byte]]
)

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

-=-=-=-=-=-=-=-=- E_UInteger? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UInteger]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Nullable`1[E_UInteger],System.Nullable`1[E_Short]]
)

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

-=-=-=-=-=-=-=-=- E_UInteger? -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UInteger]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Nullable`1[E_UInteger],System.Nullable`1[E_UShort]]
)

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

-=-=-=-=-=-=-=-=- E_UInteger? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UInteger]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Nullable`1[E_UInteger],System.Nullable`1[E_Integer]]
)

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

-=-=-=-=-=-=-=-=- E_UInteger? -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Nullable`1[E_UInteger],System.Nullable`1[E_UInteger]]
)

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

-=-=-=-=-=-=-=-=- E_UInteger? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_UInteger]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Nullable`1[E_UInteger],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_UInteger?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_UInteger]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.UInt32]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(UInt32) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[E_UInteger],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- E_UInteger? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_UInteger]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.UInt32]
      )
      Lifted
      LiftedToNull
      method: System.Decimal op_Implicit(UInt32) in System.Decimal
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[E_UInteger],System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_UInteger? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[E_UInteger]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[E_UInteger],System.Object]
)

-=-=-=-=-=-=-=-=- CType(Long, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Int64,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Long -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Int64,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Long, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Int64,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- Long -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Int64,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(Long, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Int64,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- Long -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Int64,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Long, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Int64,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- Long -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Int64,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(Long, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Int64,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- Long -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Int64,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Long, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Int64,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- Long -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Int64,System.Nullable`1[E_UInteger]]
)

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

-=-=-=-=-=-=-=-=- Long -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Int64
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Int64,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(Long, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Int64
        )
        method: Boolean ToBoolean(Int64) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Int64,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- Long -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          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`2[System.Int64,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(Long, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          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`2[System.Int64,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- Long -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          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`2[System.Int64,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- Long -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int64
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Int64
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Int64,System.Object]
)

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

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

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

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

-=-=-=-=-=-=-=-=- CType(Long?, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int64]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Int64]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Nullable`1[System.Int64],System.Nullable`1[System.Int16]]
)

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

-=-=-=-=-=-=-=-=- CType(Long?, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int64]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Int64]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Nullable`1[System.Int64],System.Nullable`1[System.UInt16]]
)

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

-=-=-=-=-=-=-=-=- CType(Long?, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int64]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Int64]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Nullable`1[System.Int64],System.Nullable`1[System.Int32]]
)

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

-=-=-=-=-=-=-=-=- CType(Long?, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int64]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Int64]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Nullable`1[System.Int64],System.Nullable`1[System.UInt32]]
)

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

-=-=-=-=-=-=-=-=- CType(Long?, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int64]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Nullable`1[System.Int64],System.Nullable`1[System.Int64]]
)

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

-=-=-=-=-=-=-=-=- CType(Long?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int64]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Int64]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Int64) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[System.Int64],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- Long? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Int64]
  )
  body {
    Convert(
      Parameter(
        x
        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`2[System.Nullable`1[System.Int64],System.Nullable`1[System.Decimal]]
)

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

-=-=-=-=-=-=-=-=- CType(E_Long, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[E_Long,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_Long -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[E_Long,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_Long, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[E_Long,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_Long -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[E_Long,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(E_Long, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[E_Long,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- E_Long -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[E_Long,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(E_Long, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[E_Long,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- E_Long -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[E_Long,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(E_Long, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[E_Long,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- E_Long -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[E_Long,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(E_Long, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[E_Long,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- E_Long -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[E_Long,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(E_Long, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: E_Long
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[E_Long,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- E_Long -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: E_Long
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[E_Long,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_Long, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_Long
          )
          type: System.Int64
        )
        method: Boolean ToBoolean(Int64) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[E_Long,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- E_Long -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_Long
        )
        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`2[E_Long,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(E_Long, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_Long
        )
        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`2[E_Long,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- E_Long -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    Convert(
      Convert(
        ConvertChecked(
          Parameter(
            x
            type: E_Long
          )
          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`2[E_Long,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_Long -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    Convert(
      Parameter(
        x
        type: E_Long
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[E_Long,System.Object]
)

-=-=-=-=-=-=-=-=- CType(E_Long?, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Long]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Long]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Nullable`1[E_Long],System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- E_Long? -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Long]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Long]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Nullable`1[E_Long],System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(E_Long?, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Long]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Long]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Nullable`1[E_Long],System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- E_Long? -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Long]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Long]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Nullable`1[E_Long],System.Nullable`1[E_Byte]]
)

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

-=-=-=-=-=-=-=-=- E_Long? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Long]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Long]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Nullable`1[E_Long],System.Nullable`1[E_Short]]
)

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

-=-=-=-=-=-=-=-=- E_Long? -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Long]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Long]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Nullable`1[E_Long],System.Nullable`1[E_UShort]]
)

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

-=-=-=-=-=-=-=-=- E_Long? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Long]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Long]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Nullable`1[E_Long],System.Nullable`1[E_Integer]]
)

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

-=-=-=-=-=-=-=-=- E_Long? -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Long]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[E_Long]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Nullable`1[E_Long],System.Nullable`1[E_UInteger]]
)

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

-=-=-=-=-=-=-=-=- E_Long? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Long]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Nullable`1[E_Long],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(E_Long?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Long]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_Long]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int64]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Int64) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[E_Long],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- E_Long? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Long]
  )
  body {
    Convert(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[E_Long]
        )
        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`2[System.Nullable`1[E_Long],System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- E_Long? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Long]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[E_Long]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[E_Long],System.Object]
)

-=-=-=-=-=-=-=-=- CType(Boolean, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      Convert(
        Negate(
          Convert(
            Parameter(
              x
              type: System.Boolean
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Boolean,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Boolean -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      Convert(
        Negate(
          Convert(
            Parameter(
              x
              type: System.Boolean
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Boolean,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Boolean, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      Convert(
        Negate(
          Convert(
            Parameter(
              x
              type: System.Boolean
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Boolean,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- Boolean -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      Convert(
        Negate(
          Convert(
            Parameter(
              x
              type: System.Boolean
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Boolean,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(Boolean, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      Negate(
        ConvertChecked(
          Parameter(
            x
            type: System.Boolean
          )
          type: System.Int16
        )
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Boolean,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- Boolean -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Negate(
          ConvertChecked(
            Parameter(
              x
              type: System.Boolean
            )
            type: System.Int16
          )
          type: System.Int16
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Boolean,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Boolean, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      Convert(
        Negate(
          Convert(
            Parameter(
              x
              type: System.Boolean
            )
            type: System.Int16
          )
          type: System.Int16
        )
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Boolean,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- Boolean -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      Convert(
        Negate(
          Convert(
            Parameter(
              x
              type: System.Boolean
            )
            type: System.Int16
          )
          type: System.Int16
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Boolean,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(Boolean, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      Negate(
        ConvertChecked(
          Parameter(
            x
            type: System.Boolean
          )
          type: System.Int32
        )
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Boolean,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- Boolean -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Negate(
          ConvertChecked(
            Parameter(
              x
              type: System.Boolean
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Boolean,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Boolean, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      Convert(
        Negate(
          Convert(
            Parameter(
              x
              type: System.Boolean
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Boolean,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- Boolean -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      Convert(
        Negate(
          Convert(
            Parameter(
              x
              type: System.Boolean
            )
            type: System.Int32
          )
          type: System.Int32
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Boolean,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(Boolean, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      Negate(
        ConvertChecked(
          Parameter(
            x
            type: System.Boolean
          )
          type: System.Int64
        )
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Boolean,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- Boolean -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Negate(
          ConvertChecked(
            Parameter(
              x
              type: System.Boolean
            )
            type: System.Int64
          )
          type: System.Int64
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Boolean,System.Nullable`1[E_Long]]
)

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

-=-=-=-=-=-=-=-=- Boolean -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    Convert(
      Negate(
        Convert(
          Parameter(
            x
            type: System.Boolean
          )
          type: System.Single
        )
        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`2[System.Boolean,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(Boolean, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    Convert(
      Negate(
        Convert(
          Parameter(
            x
            type: System.Boolean
          )
          type: System.Double
        )
        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`2[System.Boolean,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- Boolean -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Boolean
        )
        method: System.Decimal ToDecimal(Boolean) in Microsoft.VisualBasic.CompilerServices.Conversions
        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`2[System.Boolean,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- Boolean -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Boolean
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Boolean
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Boolean,System.Object]
)

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

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

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

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

-=-=-=-=-=-=-=-=- CType(Boolean?, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Boolean]
  )
  body {
    Negate(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Boolean]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Nullable`1[System.Boolean],System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- Boolean? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Boolean]
  )
  body {
    ConvertChecked(
      Negate(
        ConvertChecked(
          Parameter(
            x
            type: System.Nullable`1[System.Boolean]
          )
          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`2[System.Nullable`1[System.Boolean],System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Boolean?, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Boolean]
  )
  body {
    Convert(
      Negate(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[System.Boolean]
          )
          Lifted
          type: System.Int16
        )
        type: System.Int16
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Nullable`1[System.Boolean],System.Nullable`1[System.UInt16]]
)

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

-=-=-=-=-=-=-=-=- CType(Boolean?, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Boolean]
  )
  body {
    Negate(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Boolean]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Nullable`1[System.Boolean],System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- Boolean? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Boolean]
  )
  body {
    ConvertChecked(
      Negate(
        ConvertChecked(
          Parameter(
            x
            type: System.Nullable`1[System.Boolean]
          )
          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`2[System.Nullable`1[System.Boolean],System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Boolean?, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Boolean]
  )
  body {
    Convert(
      Negate(
        Convert(
          Parameter(
            x
            type: System.Nullable`1[System.Boolean]
          )
          Lifted
          type: System.Int32
        )
        type: System.Int32
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Nullable`1[System.Boolean],System.Nullable`1[System.UInt32]]
)

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

-=-=-=-=-=-=-=-=- CType(Boolean?, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Boolean]
  )
  body {
    Negate(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Boolean]
        )
        Lifted
        LiftedToNull
        type: System.Nullable`1[System.Int64]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Nullable`1[System.Boolean],System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- Boolean? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Boolean]
  )
  body {
    ConvertChecked(
      Negate(
        ConvertChecked(
          Parameter(
            x
            type: System.Nullable`1[System.Boolean]
          )
          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`2[System.Nullable`1[System.Boolean],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(Boolean?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Boolean]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[System.Boolean],System.Nullable`1[System.Boolean]]
)

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

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

-=-=-=-=-=-=-=-=- Boolean? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Boolean]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Boolean]
      )
      Lifted
      LiftedToNull
      method: System.Decimal ToDecimal(Boolean) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[System.Boolean],System.Nullable`1[System.Decimal]]
)

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

-=-=-=-=-=-=-=-=- CType(Single, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Single
        )
        method: SByte ToSByte(Single) in System.Convert
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Single,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Single -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Single
          )
          method: SByte ToSByte(Single) in System.Convert
          type: System.SByte
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Single,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Single, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Single
        )
        method: Byte ToByte(Single) in System.Convert
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Single,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- Single -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Single
          )
          method: Byte ToByte(Single) in System.Convert
          type: System.Byte
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Single,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(Single, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Single
        )
        method: Int16 ToInt16(Single) in System.Convert
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Single,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- Single -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Single
          )
          method: Int16 ToInt16(Single) in System.Convert
          type: System.Int16
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Single,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Single, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Single
        )
        method: UInt16 ToUInt16(Single) in System.Convert
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Single,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- Single -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Single
          )
          method: UInt16 ToUInt16(Single) in System.Convert
          type: System.UInt16
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Single,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(Single, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Single
        )
        method: Int32 ToInt32(Single) in System.Convert
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Single,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- Single -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Single
          )
          method: Int32 ToInt32(Single) in System.Convert
          type: System.Int32
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Single,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Single, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Single
        )
        method: UInt32 ToUInt32(Single) in System.Convert
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Single,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- Single -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Single
          )
          method: UInt32 ToUInt32(Single) in System.Convert
          type: System.UInt32
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Single,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(Single, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Single,System.Nullable`1[System.Int64]]
)

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

-=-=-=-=-=-=-=-=- CType(Single, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Single
        )
        method: Boolean ToBoolean(Single) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Single,System.Nullable`1[System.Boolean]]
)

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

-=-=-=-=-=-=-=-=- CType(Single, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Single
        )
        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`2[System.Single,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- Single -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Single
        )
        method: System.Decimal op_Explicit(Single) 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`2[System.Single,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- Single -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Single
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Single,System.Object]
)

-=-=-=-=-=-=-=-=- CType(Single?, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Single]
      )
      Lifted
      LiftedToNull
      method: SByte ToSByte(Single) in System.Convert
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Single? -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Single]
        )
        Lifted
        LiftedToNull
        method: SByte ToSByte(Single) in System.Convert
        type: System.Nullable`1[System.SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Single?, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Single]
      )
      Lifted
      LiftedToNull
      method: Byte ToByte(Single) in System.Convert
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- Single? -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Single]
        )
        Lifted
        LiftedToNull
        method: Byte ToByte(Single) in System.Convert
        type: System.Nullable`1[System.Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(Single?, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Single]
      )
      Lifted
      LiftedToNull
      method: Int16 ToInt16(Single) in System.Convert
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- Single? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Single]
        )
        Lifted
        LiftedToNull
        method: Int16 ToInt16(Single) in System.Convert
        type: System.Nullable`1[System.Int16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Single?, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Single]
      )
      Lifted
      LiftedToNull
      method: UInt16 ToUInt16(Single) in System.Convert
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- Single? -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Single]
        )
        Lifted
        LiftedToNull
        method: UInt16 ToUInt16(Single) in System.Convert
        type: System.Nullable`1[System.UInt16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(Single?, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Single]
      )
      Lifted
      LiftedToNull
      method: Int32 ToInt32(Single) in System.Convert
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- Single? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Single]
        )
        Lifted
        LiftedToNull
        method: Int32 ToInt32(Single) in System.Convert
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Single?, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Single]
      )
      Lifted
      LiftedToNull
      method: UInt32 ToUInt32(Single) in System.Convert
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- Single? -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Single]
        )
        Lifted
        LiftedToNull
        method: UInt32 ToUInt32(Single) in System.Convert
        type: System.Nullable`1[System.UInt32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[E_UInteger]]
)

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

-=-=-=-=-=-=-=-=- Single? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          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[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(Single?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Single]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Single) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- Single? -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[System.Single]
    )
  }
  return type: System.Nullable`1[System.Single]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(Single?, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Single]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Double]
    )
  }
  return type: System.Nullable`1[System.Double]
  type: System.Func`2[System.Nullable`1[System.Single],System.Nullable`1[System.Double]]
)

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

-=-=-=-=-=-=-=-=- Single? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Single]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Single]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[System.Single],System.Object]
)

-=-=-=-=-=-=-=-=- CType(Double, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Double
        )
        method: SByte ToSByte(Double) in System.Convert
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Double,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Double -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Double
          )
          method: SByte ToSByte(Double) in System.Convert
          type: System.SByte
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Double,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Double, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Double
        )
        method: Byte ToByte(Double) in System.Convert
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Double,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- Double -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Double
          )
          method: Byte ToByte(Double) in System.Convert
          type: System.Byte
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Double,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(Double, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Double
        )
        method: Int16 ToInt16(Double) in System.Convert
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Double,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- Double -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Double
          )
          method: Int16 ToInt16(Double) in System.Convert
          type: System.Int16
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Double,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Double, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Double
        )
        method: UInt16 ToUInt16(Double) in System.Convert
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Double,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- Double -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Double
          )
          method: UInt16 ToUInt16(Double) in System.Convert
          type: System.UInt16
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Double,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(Double, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Double
        )
        method: Int32 ToInt32(Double) in System.Convert
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Double,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- Double -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Double
          )
          method: Int32 ToInt32(Double) in System.Convert
          type: System.Int32
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Double,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Double, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Double
        )
        method: UInt32 ToUInt32(Double) in System.Convert
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Double,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- Double -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Double
          )
          method: UInt32 ToUInt32(Double) in System.Convert
          type: System.UInt32
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Double,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(Double, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Double,System.Nullable`1[System.Int64]]
)

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

-=-=-=-=-=-=-=-=- CType(Double, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Double
        )
        method: Boolean ToBoolean(Double) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Double,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- Double -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Double
        )
        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`2[System.Double,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(Double, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Double
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Double]
    )
  }
  return type: System.Nullable`1[System.Double]
  type: System.Func`2[System.Double,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- Double -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Double
        )
        method: System.Decimal op_Explicit(Double) 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`2[System.Double,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- Double -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Double
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Double,System.Object]
)

-=-=-=-=-=-=-=-=- CType(Double?, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Double]
      )
      Lifted
      LiftedToNull
      method: SByte ToSByte(Double) in System.Convert
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Double? -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Double]
        )
        Lifted
        LiftedToNull
        method: SByte ToSByte(Double) in System.Convert
        type: System.Nullable`1[System.SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Double?, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Double]
      )
      Lifted
      LiftedToNull
      method: Byte ToByte(Double) in System.Convert
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- Double? -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Double]
        )
        Lifted
        LiftedToNull
        method: Byte ToByte(Double) in System.Convert
        type: System.Nullable`1[System.Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(Double?, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Double]
      )
      Lifted
      LiftedToNull
      method: Int16 ToInt16(Double) in System.Convert
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- Double? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Double]
        )
        Lifted
        LiftedToNull
        method: Int16 ToInt16(Double) in System.Convert
        type: System.Nullable`1[System.Int16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Double?, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Double]
      )
      Lifted
      LiftedToNull
      method: UInt16 ToUInt16(Double) in System.Convert
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- Double? -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Double]
        )
        Lifted
        LiftedToNull
        method: UInt16 ToUInt16(Double) in System.Convert
        type: System.Nullable`1[System.UInt16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(Double?, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Double]
      )
      Lifted
      LiftedToNull
      method: Int32 ToInt32(Double) in System.Convert
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- Double? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Double]
        )
        Lifted
        LiftedToNull
        method: Int32 ToInt32(Double) in System.Convert
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Double?, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Double]
      )
      Lifted
      LiftedToNull
      method: UInt32 ToUInt32(Double) in System.Convert
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- Double? -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Double]
        )
        Lifted
        LiftedToNull
        method: UInt32 ToUInt32(Double) in System.Convert
        type: System.Nullable`1[System.UInt32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[E_UInteger]]
)

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

-=-=-=-=-=-=-=-=- Double? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          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[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(Double?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Double]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(Double) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- Double? -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Double]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[System.Single]
    )
  }
  return type: System.Nullable`1[System.Single]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(Double?, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[System.Double]
    )
  }
  return type: System.Nullable`1[System.Double]
  type: System.Func`2[System.Nullable`1[System.Double],System.Nullable`1[System.Double]]
)

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

-=-=-=-=-=-=-=-=- Double? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Double]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Double]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[System.Double],System.Object]
)

-=-=-=-=-=-=-=-=- CType(Decimal, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Decimal
        )
        method: SByte op_Explicit(System.Decimal) in System.Decimal
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Decimal,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Decimal -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Decimal
          )
          method: SByte op_Explicit(System.Decimal) in System.Decimal
          type: System.SByte
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Decimal,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Decimal, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Decimal
        )
        method: Byte op_Explicit(System.Decimal) in System.Decimal
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Decimal,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- Decimal -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Decimal
          )
          method: Byte op_Explicit(System.Decimal) in System.Decimal
          type: System.Byte
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Decimal,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(Decimal, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Decimal
        )
        method: Int16 op_Explicit(System.Decimal) in System.Decimal
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Decimal,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- Decimal -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Decimal
          )
          method: Int16 op_Explicit(System.Decimal) in System.Decimal
          type: System.Int16
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Decimal,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Decimal, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Decimal
        )
        method: UInt16 op_Explicit(System.Decimal) in System.Decimal
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Decimal,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- Decimal -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Decimal
          )
          method: UInt16 op_Explicit(System.Decimal) in System.Decimal
          type: System.UInt16
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Decimal,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(Decimal, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Decimal
        )
        method: Int32 op_Explicit(System.Decimal) in System.Decimal
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Decimal,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- Decimal -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Decimal
          )
          method: Int32 op_Explicit(System.Decimal) in System.Decimal
          type: System.Int32
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Decimal,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Decimal, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Decimal
        )
        method: UInt32 op_Explicit(System.Decimal) in System.Decimal
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Decimal,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- Decimal -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.Decimal
          )
          method: UInt32 op_Explicit(System.Decimal) in System.Decimal
          type: System.UInt32
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Decimal,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(Decimal, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Decimal,System.Nullable`1[System.Int64]]
)

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

-=-=-=-=-=-=-=-=- CType(Decimal, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Decimal
        )
        method: Boolean ToBoolean(System.Decimal) in System.Convert
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Decimal,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- Decimal -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Decimal
        )
        method: Single op_Explicit(System.Decimal) in System.Decimal
        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`2[System.Decimal,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(Decimal, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Decimal
        )
        method: Double op_Explicit(System.Decimal) in System.Decimal
        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`2[System.Decimal,System.Nullable`1[System.Double]]
)

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

-=-=-=-=-=-=-=-=- Decimal -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Decimal
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Decimal,System.Object]
)

-=-=-=-=-=-=-=-=- CType(Decimal?, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Decimal]
      )
      Lifted
      LiftedToNull
      method: SByte op_Explicit(System.Decimal) in System.Decimal
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Decimal? -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Decimal]
        )
        Lifted
        LiftedToNull
        method: SByte op_Explicit(System.Decimal) in System.Decimal
        type: System.Nullable`1[System.SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Decimal?, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Decimal]
      )
      Lifted
      LiftedToNull
      method: Byte op_Explicit(System.Decimal) in System.Decimal
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- Decimal? -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Decimal]
        )
        Lifted
        LiftedToNull
        method: Byte op_Explicit(System.Decimal) in System.Decimal
        type: System.Nullable`1[System.Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(Decimal?, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Decimal]
      )
      Lifted
      LiftedToNull
      method: Int16 op_Explicit(System.Decimal) in System.Decimal
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- Decimal? -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Decimal]
        )
        Lifted
        LiftedToNull
        method: Int16 op_Explicit(System.Decimal) in System.Decimal
        type: System.Nullable`1[System.Int16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Decimal?, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Decimal]
      )
      Lifted
      LiftedToNull
      method: UInt16 op_Explicit(System.Decimal) in System.Decimal
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- Decimal? -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Decimal]
        )
        Lifted
        LiftedToNull
        method: UInt16 op_Explicit(System.Decimal) in System.Decimal
        type: System.Nullable`1[System.UInt16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(Decimal?, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Decimal]
      )
      Lifted
      LiftedToNull
      method: Int32 op_Explicit(System.Decimal) in System.Decimal
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- Decimal? -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Decimal]
        )
        Lifted
        LiftedToNull
        method: Int32 op_Explicit(System.Decimal) in System.Decimal
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Decimal?, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Nullable`1[System.Decimal]
      )
      Lifted
      LiftedToNull
      method: UInt32 op_Explicit(System.Decimal) in System.Decimal
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- Decimal? -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Nullable`1[System.Decimal]
        )
        Lifted
        LiftedToNull
        method: UInt32 op_Explicit(System.Decimal) in System.Decimal
        type: System.Nullable`1[System.UInt32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(Decimal?, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      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]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- Decimal? -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(Decimal?, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Decimal]
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(System.Decimal) in System.Convert
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[System.Boolean]]
)

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

-=-=-=-=-=-=-=-=- CType(Decimal?, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Decimal]
      )
      Lifted
      LiftedToNull
      method: Double op_Explicit(System.Decimal) in System.Decimal
      type: System.Nullable`1[System.Double]
    )
  }
  return type: System.Nullable`1[System.Double]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- Decimal? -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- Decimal? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Decimal]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.Decimal]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[System.Decimal],System.Object]
)

-=-=-=-=-=-=-=-=- Date -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.DateTime
  )
  body {
    Convert(
      Parameter(
        x
        type: System.DateTime
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.DateTime,System.Object]
)

-=-=-=-=-=-=-=-=- CType(Date?, Date?) -> Date? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.DateTime]
  )
  body {
    Parameter(
      x
      type: System.Nullable`1[System.DateTime]
    )
  }
  return type: System.Nullable`1[System.DateTime]
  type: System.Func`2[System.Nullable`1[System.DateTime],System.Nullable`1[System.DateTime]]
)

-=-=-=-=-=-=-=-=- Date? -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.DateTime]
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Nullable`1[System.DateTime]
      )
      Lifted
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Nullable`1[System.DateTime],System.Object]
)

-=-=-=-=-=-=-=-=- CType(String, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.String
        )
        method: SByte ToSByte(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.SByte
      )
      method: System.Nullable`1[System.SByte] op_Implicit(SByte) in System.Nullable`1[System.SByte]
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.String,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- String -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.String
          )
          method: SByte ToSByte(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.SByte
        )
        type: E_SByte
      )
      method: System.Nullable`1[E_SByte] op_Implicit(E_SByte) in System.Nullable`1[E_SByte]
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.String,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(String, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.String
        )
        method: Byte ToByte(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.Byte
      )
      method: System.Nullable`1[System.Byte] op_Implicit(Byte) in System.Nullable`1[System.Byte]
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.String,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- String -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.String
          )
          method: Byte ToByte(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.Byte
        )
        type: E_Byte
      )
      method: System.Nullable`1[E_Byte] op_Implicit(E_Byte) in System.Nullable`1[E_Byte]
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.String,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(String, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.String
        )
        method: Int16 ToShort(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.Int16
      )
      method: System.Nullable`1[System.Int16] op_Implicit(Int16) in System.Nullable`1[System.Int16]
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.String,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- String -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.String
          )
          method: Int16 ToShort(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.Int16
        )
        type: E_Short
      )
      method: System.Nullable`1[E_Short] op_Implicit(E_Short) in System.Nullable`1[E_Short]
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.String,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(String, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.String
        )
        method: UInt16 ToUShort(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.UInt16
      )
      method: System.Nullable`1[System.UInt16] op_Implicit(UInt16) in System.Nullable`1[System.UInt16]
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.String,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- String -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.String
          )
          method: UInt16 ToUShort(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.UInt16
        )
        type: E_UShort
      )
      method: System.Nullable`1[E_UShort] op_Implicit(E_UShort) in System.Nullable`1[E_UShort]
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.String,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(String, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.String
        )
        method: Int32 ToInteger(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.Int32
      )
      method: System.Nullable`1[System.Int32] op_Implicit(Int32) in System.Nullable`1[System.Int32]
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.String,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- String -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.String
          )
          method: Int32 ToInteger(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.Int32
        )
        type: E_Integer
      )
      method: System.Nullable`1[E_Integer] op_Implicit(E_Integer) in System.Nullable`1[E_Integer]
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.String,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(String, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.String
        )
        method: UInt32 ToUInteger(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.UInt32
      )
      method: System.Nullable`1[System.UInt32] op_Implicit(UInt32) in System.Nullable`1[System.UInt32]
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.String,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- String -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.String
          )
          method: UInt32 ToUInteger(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.UInt32
        )
        type: E_UInteger
      )
      method: System.Nullable`1[E_UInteger] op_Implicit(E_UInteger) in System.Nullable`1[E_UInteger]
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.String,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(String, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.String
        )
        method: Int64 ToLong(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.Int64
      )
      method: System.Nullable`1[System.Int64] op_Implicit(Int64) in System.Nullable`1[System.Int64]
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.String,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- String -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      ConvertChecked(
        ConvertChecked(
          Parameter(
            x
            type: System.String
          )
          method: Int64 ToLong(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
          type: System.Int64
        )
        type: E_Long
      )
      method: System.Nullable`1[E_Long] op_Implicit(E_Long) in System.Nullable`1[E_Long]
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.String,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(String, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.String
        )
        method: Boolean ToBoolean(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.Boolean
      )
      method: System.Nullable`1[System.Boolean] op_Implicit(Boolean) in System.Nullable`1[System.Boolean]
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.String,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- String -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.String
        )
        method: Single ToSingle(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
        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`2[System.String,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(String, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.String
        )
        method: Double ToDouble(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
        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`2[System.String,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- String -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.String
        )
        method: System.Decimal ToDecimal(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
        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`2[System.String,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- CType(String, Date?) -> Date? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.String
        )
        method: System.DateTime ToDate(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.DateTime
      )
      method: System.Nullable`1[System.DateTime] op_Implicit(System.DateTime) in System.Nullable`1[System.DateTime]
      type: System.Nullable`1[System.DateTime]
    )
  }
  return type: System.Nullable`1[System.DateTime]
  type: System.Func`2[System.String,System.Nullable`1[System.DateTime]]
)

-=-=-=-=-=-=-=-=- String -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    Convert(
      Parameter(
        x
        type: System.String
      )
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.String,System.Object]
)

-=-=-=-=-=-=-=-=- CType(Object, SByte?) -> SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Object
      )
      Lifted
      LiftedToNull
      method: SByte ToSByte(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.SByte]
    )
  }
  return type: System.Nullable`1[System.SByte]
  type: System.Func`2[System.Object,System.Nullable`1[System.SByte]]
)

-=-=-=-=-=-=-=-=- Object -> E_SByte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Object
        )
        Lifted
        LiftedToNull
        method: SByte ToSByte(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.Nullable`1[System.SByte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_SByte]
    )
  }
  return type: System.Nullable`1[E_SByte]
  type: System.Func`2[System.Object,System.Nullable`1[E_SByte]]
)

-=-=-=-=-=-=-=-=- CType(Object, Byte?) -> Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Object
      )
      Lifted
      LiftedToNull
      method: Byte ToByte(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.Byte]
    )
  }
  return type: System.Nullable`1[System.Byte]
  type: System.Func`2[System.Object,System.Nullable`1[System.Byte]]
)

-=-=-=-=-=-=-=-=- Object -> E_Byte? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Object
        )
        Lifted
        LiftedToNull
        method: Byte ToByte(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.Nullable`1[System.Byte]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Byte]
    )
  }
  return type: System.Nullable`1[E_Byte]
  type: System.Func`2[System.Object,System.Nullable`1[E_Byte]]
)

-=-=-=-=-=-=-=-=- CType(Object, Short?) -> Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Object
      )
      Lifted
      LiftedToNull
      method: Int16 ToShort(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.Int16]
    )
  }
  return type: System.Nullable`1[System.Int16]
  type: System.Func`2[System.Object,System.Nullable`1[System.Int16]]
)

-=-=-=-=-=-=-=-=- Object -> E_Short? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Object
        )
        Lifted
        LiftedToNull
        method: Int16 ToShort(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.Nullable`1[System.Int16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Short]
    )
  }
  return type: System.Nullable`1[E_Short]
  type: System.Func`2[System.Object,System.Nullable`1[E_Short]]
)

-=-=-=-=-=-=-=-=- CType(Object, UShort?) -> UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Object
      )
      Lifted
      LiftedToNull
      method: UInt16 ToUShort(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.UInt16]
    )
  }
  return type: System.Nullable`1[System.UInt16]
  type: System.Func`2[System.Object,System.Nullable`1[System.UInt16]]
)

-=-=-=-=-=-=-=-=- Object -> E_UShort? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Object
        )
        Lifted
        LiftedToNull
        method: UInt16 ToUShort(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.Nullable`1[System.UInt16]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UShort]
    )
  }
  return type: System.Nullable`1[E_UShort]
  type: System.Func`2[System.Object,System.Nullable`1[E_UShort]]
)

-=-=-=-=-=-=-=-=- CType(Object, Integer?) -> Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Object
      )
      Lifted
      LiftedToNull
      method: Int32 ToInteger(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.Int32]
    )
  }
  return type: System.Nullable`1[System.Int32]
  type: System.Func`2[System.Object,System.Nullable`1[System.Int32]]
)

-=-=-=-=-=-=-=-=- Object -> E_Integer? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Object
        )
        Lifted
        LiftedToNull
        method: Int32 ToInteger(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.Nullable`1[System.Int32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Integer]
    )
  }
  return type: System.Nullable`1[E_Integer]
  type: System.Func`2[System.Object,System.Nullable`1[E_Integer]]
)

-=-=-=-=-=-=-=-=- CType(Object, UInteger?) -> UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Object
      )
      Lifted
      LiftedToNull
      method: UInt32 ToUInteger(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.UInt32]
    )
  }
  return type: System.Nullable`1[System.UInt32]
  type: System.Func`2[System.Object,System.Nullable`1[System.UInt32]]
)

-=-=-=-=-=-=-=-=- Object -> E_UInteger? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Object
        )
        Lifted
        LiftedToNull
        method: UInt32 ToUInteger(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.Nullable`1[System.UInt32]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_UInteger]
    )
  }
  return type: System.Nullable`1[E_UInteger]
  type: System.Func`2[System.Object,System.Nullable`1[E_UInteger]]
)

-=-=-=-=-=-=-=-=- CType(Object, Long?) -> Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      Parameter(
        x
        type: System.Object
      )
      Lifted
      LiftedToNull
      method: Int64 ToLong(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.Int64]
    )
  }
  return type: System.Nullable`1[System.Int64]
  type: System.Func`2[System.Object,System.Nullable`1[System.Int64]]
)

-=-=-=-=-=-=-=-=- Object -> E_Long? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      ConvertChecked(
        Parameter(
          x
          type: System.Object
        )
        Lifted
        LiftedToNull
        method: Int64 ToLong(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
        type: System.Nullable`1[System.Int64]
      )
      Lifted
      LiftedToNull
      type: System.Nullable`1[E_Long]
    )
  }
  return type: System.Nullable`1[E_Long]
  type: System.Func`2[System.Object,System.Nullable`1[E_Long]]
)

-=-=-=-=-=-=-=-=- CType(Object, Boolean?) -> Boolean? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Object
      )
      Lifted
      LiftedToNull
      method: Boolean ToBoolean(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.Boolean]
    )
  }
  return type: System.Nullable`1[System.Boolean]
  type: System.Func`2[System.Object,System.Nullable`1[System.Boolean]]
)

-=-=-=-=-=-=-=-=- Object -> Single? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Object
      )
      Lifted
      LiftedToNull
      method: Single ToSingle(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.Single]
    )
  }
  return type: System.Nullable`1[System.Single]
  type: System.Func`2[System.Object,System.Nullable`1[System.Single]]
)

-=-=-=-=-=-=-=-=- CType(Object, Double?) -> Double? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Object
      )
      Lifted
      LiftedToNull
      method: Double ToDouble(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.Double]
    )
  }
  return type: System.Nullable`1[System.Double]
  type: System.Func`2[System.Object,System.Nullable`1[System.Double]]
)

-=-=-=-=-=-=-=-=- Object -> Decimal? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Object
      )
      Lifted
      LiftedToNull
      method: System.Decimal ToDecimal(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.Decimal]
    )
  }
  return type: System.Nullable`1[System.Decimal]
  type: System.Func`2[System.Object,System.Nullable`1[System.Decimal]]
)

-=-=-=-=-=-=-=-=- CType(Object, Date?) -> Date? -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Object
      )
      Lifted
      LiftedToNull
      method: System.DateTime ToDate(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Nullable`1[System.DateTime]
    )
  }
  return type: System.Nullable`1[System.DateTime]
  type: System.Func`2[System.Object,System.Nullable`1[System.DateTime]]
)

-=-=-=-=-=-=-=-=- Object -> Object -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    Parameter(
      x
      type: System.Object
    )
  }
  return type: System.Object
  type: System.Func`2[System.Object,System.Object]
)