-=-=-=-=-=-=-=-=- DirectCast(SByte, 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]
)

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

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

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

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

-=-=-=-=-=-=-=-=- CBool(SByte) -> Boolean -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(SByte) -> Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CStr(SByte) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.SByte
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

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

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

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

-=-=-=-=-=-=-=-=- CByte(SByte?) -> Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CShort(SByte?) -> Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CInt(SByte?) -> Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CLng(SByte?) -> Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.SByte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(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]
)

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

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

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

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

-=-=-=-=-=-=-=-=- CBool(E_SByte) -> Boolean -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(E_SByte) -> Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CStr(E_SByte) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_SByte
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

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

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

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

-=-=-=-=-=-=-=-=- CByte(E_SByte?) -> Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CShort(E_SByte?) -> Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CInt(E_SByte?) -> Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CLng(E_SByte?) -> Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_SByte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(Byte, 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]
)

-=-=-=-=-=-=-=-=- CByte(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]
)

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

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

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

-=-=-=-=-=-=-=-=- CBool(Byte) -> Boolean -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(Byte) -> Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Byte
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CStr(Byte) -> 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]
)

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

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

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

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

-=-=-=-=-=-=-=-=- CShort(Byte?) -> Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CInt(Byte?) -> Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CLng(Byte?) -> Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[System.Byte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(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]
)

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

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

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

-=-=-=-=-=-=-=-=- CBool(E_Byte) -> Boolean -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(E_Byte) -> Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CStr(E_Byte) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Byte
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

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

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

-=-=-=-=-=-=-=-=- CByte(E_Byte?) -> Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

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

-=-=-=-=-=-=-=-=- CShort(E_Byte?) -> Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CInt(E_Byte?) -> Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CLng(E_Byte?) -> Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_Byte]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(Short, 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]
)

-=-=-=-=-=-=-=-=- CShort(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]
)

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

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

-=-=-=-=-=-=-=-=- CBool(Short) -> Boolean -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(Short) -> Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CStr(Short) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Int16
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(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]
)

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

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

-=-=-=-=-=-=-=-=- CBool(E_Short) -> Boolean -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(E_Short) -> Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CStr(E_Short) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Short
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(UShort, 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]
)

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

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

-=-=-=-=-=-=-=-=- CBool(UShort) -> Boolean -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(UShort) -> Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CStr(UShort) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.UInt16
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(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]
)

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

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

-=-=-=-=-=-=-=-=- CBool(E_UShort) -> Boolean -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(E_UShort) -> Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CStr(E_UShort) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UShort
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

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

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

-=-=-=-=-=-=-=-=- CByte(E_UShort?) -> Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CShort(E_UShort?) -> Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

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

-=-=-=-=-=-=-=-=- CInt(E_UShort?) -> Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CLng(E_UShort?) -> Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UShort]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(Integer, 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]
)

-=-=-=-=-=-=-=-=- CInt(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]
)

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

-=-=-=-=-=-=-=-=- CBool(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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(Integer) -> 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]
)

-=-=-=-=-=-=-=-=- CStr(Integer) -> 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]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(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]
)

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

-=-=-=-=-=-=-=-=- CBool(E_Integer) -> Boolean -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(E_Integer) -> Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CStr(E_Integer) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Integer
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(UInteger, 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]
)

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

-=-=-=-=-=-=-=-=- CBool(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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(UInteger) -> 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]
)

-=-=-=-=-=-=-=-=- CStr(UInteger) -> 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]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(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]
)

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

-=-=-=-=-=-=-=-=- CBool(E_UInteger) -> Boolean -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(E_UInteger) -> Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CStr(E_UInteger) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_UInteger
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

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

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

-=-=-=-=-=-=-=-=- CByte(E_UInteger?) -> Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CShort(E_UInteger?) -> Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CInt(E_UInteger?) -> Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

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

-=-=-=-=-=-=-=-=- CLng(E_UInteger?) -> Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Nullable`1[E_UInteger]
  )
  body {
    ConvertChecked(
      ConvertChecked(
        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]
)

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(Long, 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]
)

-=-=-=-=-=-=-=-=- CLng(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]
)

-=-=-=-=-=-=-=-=- CBool(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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(Long) -> 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]
)

-=-=-=-=-=-=-=-=- CStr(Long) -> 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]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(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]
)

-=-=-=-=-=-=-=-=- CBool(E_Long) -> Boolean -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(E_Long) -> Decimal -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

-=-=-=-=-=-=-=-=- CStr(E_Long) -> String -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: E_Long
  )
  body {
    Convert(
      ConvertChecked(
        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]
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CByte(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]
)

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

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

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

-=-=-=-=-=-=-=-=- DirectCast(Boolean, 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]
)

-=-=-=-=-=-=-=-=- CBool(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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(Boolean) -> 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]
)

-=-=-=-=-=-=-=-=- CStr(Boolean) -> 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]
)

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

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

-=-=-=-=-=-=-=-=- CByte(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]
)

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

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

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

-=-=-=-=-=-=-=-=- CBool(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]
)

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

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(Boolean?) -> 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]
)

-=-=-=-=-=-=-=-=- CStr(Boolean?) -> 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]
)

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

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

-=-=-=-=-=-=-=-=- CByte(Single) -> Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CShort(Single) -> Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CInt(Single) -> Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CLng(Single) -> Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Single
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CBool(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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(Single) -> 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]
)

-=-=-=-=-=-=-=-=- CStr(Single) -> 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]
)

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CBool(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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

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

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(Single?) -> 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]
)

-=-=-=-=-=-=-=-=- CStr(Single?) -> 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]
)

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

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

-=-=-=-=-=-=-=-=- CByte(Double) -> Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CShort(Double) -> Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CInt(Double) -> Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CLng(Double) -> Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Double
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CBool(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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(Double) -> 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]
)

-=-=-=-=-=-=-=-=- CStr(Double) -> 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]
)

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CBool(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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

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

-=-=-=-=-=-=-=-=- CDec(Double?) -> 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]
)

-=-=-=-=-=-=-=-=- CStr(Double?) -> 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]
)

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

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

-=-=-=-=-=-=-=-=- CByte(Decimal) -> Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CShort(Decimal) -> Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CInt(Decimal) -> Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CLng(Decimal) -> Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Decimal
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CBool(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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- DirectCast(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]
)

-=-=-=-=-=-=-=-=- CDec(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]
)

-=-=-=-=-=-=-=-=- CStr(Decimal) -> 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]
)

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CBool(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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(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]
)

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

-=-=-=-=-=-=-=-=- CStr(Decimal?) -> 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]
)

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

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

-=-=-=-=-=-=-=-=- DirectCast(Date, 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]
)

-=-=-=-=-=-=-=-=- CStr(Date) -> 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]
)

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

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

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

-=-=-=-=-=-=-=-=- CStr(Date?) -> 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]
)

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

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

-=-=-=-=-=-=-=-=- CByte(String) -> Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CShort(String) -> Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CInt(String) -> Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CLng(String) -> Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.String
  )
  body {
    ConvertChecked(
      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]
)

-=-=-=-=-=-=-=-=- CBool(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]
)

-=-=-=-=-=-=-=-=- CSng(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]
)

-=-=-=-=-=-=-=-=- CDbl(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]
)

-=-=-=-=-=-=-=-=- CDec(String) -> 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]
)

-=-=-=-=-=-=-=-=- CDate(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]
)

-=-=-=-=-=-=-=-=- DirectCast(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]
)

-=-=-=-=-=-=-=-=- CStr(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]
)

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CByte(Object) -> Byte -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      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]
)

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

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

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

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

-=-=-=-=-=-=-=-=- CShort(Object) -> Short -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      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]
)

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CInt(Object) -> Integer -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      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]
)

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

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

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

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

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

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

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

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

-=-=-=-=-=-=-=-=- CLng(Object) -> Long -=-=-=-=-=-=-=-=-
Lambda(
  Parameter(
    x
    type: System.Object
  )
  body {
    ConvertChecked(
      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]
)

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

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

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

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

-=-=-=-=-=-=-=-=- CBool(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]
)

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

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

-=-=-=-=-=-=-=-=- CSng(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]
)

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

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

-=-=-=-=-=-=-=-=- CDbl(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]
)

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

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

-=-=-=-=-=-=-=-=- CDec(Object) -> 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]
)

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

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

-=-=-=-=-=-=-=-=- CDate(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]
)

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

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

-=-=-=-=-=-=-=-=- CStr(Object) -> 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]
)

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

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

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