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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(SByte, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.SByte
        )
        type: System.Int32
      )
      method: System.String ToString(Int32) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[System.SByte,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(E_SByte, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_SByte
        )
        type: System.Int32
      )
      method: System.String ToString(Int32) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[E_SByte,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(Byte, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Byte
      )
      method: System.String ToString(Byte) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[System.Byte,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(E_Byte, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_Byte
        )
        type: System.Byte
      )
      method: System.String ToString(Byte) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[E_Byte,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(Short, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.Int16
        )
        type: System.Int32
      )
      method: System.String ToString(Int32) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[System.Int16,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(E_Short, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_Short
        )
        type: System.Int32
      )
      method: System.String ToString(Int32) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[E_Short,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(UShort, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: System.UInt16
        )
        type: System.UInt32
      )
      method: System.String ToString(UInt32) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[System.UInt16,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(E_UShort, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_UShort
        )
        type: System.UInt32
      )
      method: System.String ToString(UInt32) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[E_UShort,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(E_Integer, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_Integer
        )
        type: System.Int32
      )
      method: System.String ToString(Int32) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[E_Integer,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(E_UInteger, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    Convert(
      Convert(
        Parameter(
          x
          type: E_UInteger
        )
        type: System.UInt32
      )
      method: System.String ToString(UInt32) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[E_UInteger,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(Single, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Single
      )
      method: System.String ToString(Single) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[System.Single,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(Double, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Double
      )
      method: System.String ToString(Double) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[System.Double,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(Decimal, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Decimal
      )
      method: System.String ToString(System.Decimal) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[System.Decimal,System.String]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(String, Single) -> Single -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    Convert(
      Parameter(
        x
        type: System.String
      )
      method: Single ToSingle(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Single
    )
  }
  return type: System.Single
  type: System.Func`2[System.String,System.Single]
)

-=-=-=-=-=-=-=-=- String -> Double -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    Convert(
      Parameter(
        x
        type: System.String
      )
      method: Double ToDouble(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Double
    )
  }
  return type: System.Double
  type: System.Func`2[System.String,System.Double]
)

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

-=-=-=-=-=-=-=-=- CType(String, Decimal) -> Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    Convert(
      Parameter(
        x
        type: System.String
      )
      method: System.Decimal ToDecimal(System.String) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Decimal
    )
  }
  return type: System.Decimal
  type: System.Func`2[System.String,System.Decimal]
)

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

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

-=-=-=-=-=-=-=-=- Object -> SByte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Object
      )
      method: SByte ToSByte(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.SByte
    )
  }
  return type: System.SByte
  type: System.Func`2[System.Object,System.SByte]
)

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

-=-=-=-=-=-=-=-=- Object -> Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Object
      )
      method: Byte ToByte(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.Byte
    )
  }
  return type: System.Byte
  type: System.Func`2[System.Object,System.Byte]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CType(Object, String) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    Convert(
      Parameter(
        x
        type: System.Object
      )
      method: System.String ToString(System.Object) in Microsoft.VisualBasic.CompilerServices.Conversions
      type: System.String
    )
  }
  return type: System.String
  type: System.Func`2[System.Object,System.String]
)