
' This file was auto-generated with uCalc Transform 3.0 using uCalcVb.uc on 12/31/18 at 20:42 PM







Imports System
Imports System.Runtime.InteropServices
Imports System.Collections.Generic




Public Module uCalcSoftware




   Public Delegate Sub uCalcDelegate(ByVal Expr As IntPtr)

#If PLATFORM = "x64" Then
   Const uCalcDLL As String = "uCalc64.dll"
#Else
   Const uCalcDLL As String = "uCalc32.dll"
#End If

   '''  <summary> Data types that come with uCalc</summary>
   '''   <remarks>
   '''  <para>These are built-in data types that come with uCalc +++ Use scoped enum w/ class; or insert enum in class for uCalc::member access</para>
   '''  </remarks>
   Public Enum BuiltInTypesEnum As Int32
      Type_Unspecified
      Type_Auto
      '''  <summary> Boolean</summary>
      Type_Boolean
      '''  <summary> Int8 +++ Rename these to things like Type_Int8</summary>
      Type_Integer_8
      '''  <summary> Byte</summary>
      Type_Integer_8u
      '''  <summary> Int16</summary>
      Type_Integer_16
      '''  <summary> Int16u</summary>
      Type_Integer_16u
      '''  <summary> Int32</summary>
      Type_Integer_32
      '''  <summary> Int32u</summary>
      Type_Integer_32u
      '''  <summary> Int64</summary>
      Type_Integer_64
      '''  <summary> Int64u</summary>
      Type_Integer_64u
      '''  <summary> Int128</summary>
      Type_Integer_128
      '''  <summary> Int128u</summary>
      Type_Integer_128u
      '''  <summary> Single</summary>
      Type_Float_Single
      '''  <summary> Double</summary>
      Type_Float_Double
      '''  <summary> Extended</summary>
      Type_Float_Extended
      Type_Size_t
      Type_Complex
      Type_Decimal
      Type_BigNum
      Type_Date
      Type_String
      Type_StringView
      '''  <summary> LPCSTR</summary>
      Type_String_LPCSTR
      '''  <summary> FixedStr</summary>
      Type_String_Fixed
      '''  <summary> WideStr</summary>
      Type_String_Wide
      '''  <summary> StackList</summary>
      Type_List_Stack
      '''  <summary> TableList</summary>
      Type_List_Table
      '''  <summary> SortedList</summary>
      Type_List_Sorted
      Type_Null
      Type_Void
      Type_Any
      Type_Pointer
      Type_Omni
      Type_UserDefined
      Type_DataType
      Type_Namespace
      Type_IntPtr
      Type_ADDR
      Type_uCalcPtr
      Type_Item
      Type_ParsedExpr
      Type_uCalcCallback
      Type_Object
      Type_Intrinsic
   End Enum

   '''  <summary> Data type constructors</summary>
   Public Enum DataTypeConstruction As Int32
      TypeConstr_ByteSize
      TypeConstr_AllocArray
      TypeConstr_AllocScalar
      TypeConstr_AllocByPtr
      TypeConstr_ReleaseArray
      TypeConstr_ReleaseScalar
      TypeConstr_ResetScalar
      TypeConstr_ResetArray
      TypeConstr_SetArrayValue
      TypeConstr_SetScalarValue
      TypeConstr_SwapScalarValues
   End Enum

   '''  <summary> Error hander responses</summary>
   Public Enum ErrorHandlerResponseEnum As Int32
      '''  <summary> Immediately stops parsing</summary>
      ErrorAbort
      '''  <summary> Continues parsing (after the error is resolved)</summary>
      ErrorResume
      '''  <summary> Raises the same error again for the next error handler to take care of</summary>
      ErrorReRaise
   End Enum

   '''  <summary> Error numbers that uCalc may return</summary>
   Public Enum ErrorNumberEnum As Int32
      '''  <summary> No error</summary>
      Err_None
      '''  <summary> Inexact result</summary>
      Err_FloatInexact = 1
      '''  <summary> Floating point underflow</summary>
      Err_FloatUnderflow = 2
      '''  <summary> Floating point overflow</summary>
      Err_FloatOverflow = 4
      '''  <summary> Division by 0</summary>
      Err_FloatDivisionByZero = 8
      '''  <summary> Invalid floating point value</summary>
      Err_FloatInvalid = 16
      '''  <summary> Dynamically defined user error</summary>
      Err_Dynamically_Defined
      '''  <summary> Syntax error</summary>
      Err_Syntax_Error
      '''  <summary> Undefined identifier</summary>
      Err_Undefined_Identifier
      '''  <summary> File not found</summary>
      Err_FileNotFound
      '''  <summary> Unrecognized token</summary>
      Err_Unrecognized_Token
      '''  <summary> Unrecognized command</summary>
      Err_Unrecognized_Command
      '''  <summary> Data type mismatch</summary>
      Err_Datatype_Mismatch
      '''  <summary> Invalid number of arguments</summary>
      Err_Invalid_Argument_Count
      '''  <summary> Invalid definition</summary>
      Err_Invalid_Definition
      '''  <summary> Bracket delimiter error</summary>
      Err_Bracket_Error
      '''  <summary> Undefined callback</summary>
      Err_Undefined_Callback
      '''  <summary> Error message already defined</summary>
      Err_ErrorMessageAlreadyDefined
      '''  <summary> This item cannot be modified</summary>
      Err_ItemCannotBeModified
      '''  <summary> Unrecognized class member</summary>
      Err_Unrecognized_Class_Member
      '''  <summary> Unrecognized namespace member</summary>
      Err_Unrecognized_Namespace_Member
      '''  <summary> Unbalanced quote</summary>
      Err_Unbalanced_Quote
      '''  <summary> Value cannot be assigned here</summary>
      Err_ValueCannotBeAssigned
      '''  <summary> Reparsing has passed the specified limit</summary>
      Err_ReParseOverflow
      '''  <summary> Array or list bound exceeded</summary>
      Err_Array_Bounds_Exceeded
      Err_Customized1 = 100
      Err_Customized2
      Err_Customized3
      Err_Customized4
      Err_Customized5
      Err_Customized6
      Err_Customized7
      Err_Customized8
      Err_Customized9
      Err_Customized10
      Err_Customized11
      Err_Customized12
      Err_Customized13
      Err_Customized14
      Err_Customized15
      Err_Customized16
      Err_Customized17
      Err_Customized18
      Err_Customized19
      Err_Customized20
   End Enum

   '''  <summary> Operator grouping associativity</summary>
   Public Enum GroupingEnum As Int32
      GroupLeftToRight
      GroupRightToLeft
   End Enum

   '''  <summary> Properties that a uCalc item may have</summary>
   '''   <remarks>
   '''  <para>
   '''  Items defined with uCalc typically have a combination of properties.  A variable defined
   '''  with DefineVariable for instance will have the ItemIsEnum.Variable property set.  An operator
   '''  will have the ItemIsEnum.Operator property set.  If it's an infix operator in addition to
   '''  having the ItemIsEnum.Operator property set ItemIsEnum.Infix will also be set.
   '''  property will also be set.</para>
   '''  <para>The IsProperty function can determine if a given uCalc.Item has a certain property.</para>
   '''  <para>You can use the GetItemOfProperty function to cycle through the list of all items that share
   '''  certain properties or to disambiguate between items that share the same name but have
   '''  different roperties (for instance the + operator with the Prefix property vs another one
   '''  with the Infix property).</para>
   '''  <para>Some members are keywords in VB.NET.  To avoid naming conflict the following members have been
   '''  renamed in the VB.NET header: Function_ Operator_ Optional_ ByVal_ ByRef_ Class_ and NameSpace_.
   '''  </para>
   '''  </remarks>
   Public Enum ItemIsEnum As Int32
      SelectAny
      SelectAll
      RightToLeft_
      DataType__
      Array
      Class_
      Namespace_
      Variable
      Function_
      Operator_
      FunctionOrOperator
      Prefix
      Infix
      Postfix
      '''  <summary> +++ Use MemoryIndex instead</summary>
      AddressOwner
      ByVal_
      ByRef_
      ByCopy
      ByExpr
      ByHandle
      IntPtr
      Optional_
      VariableNumberOfArgs
      Alias_
      LiteralItem
      Locked
      '''  <summary> +++ May need to rename; Purpose of Exclude: cause match to fail if this search item is found</summary>
      Exclude
      '''  <summary> +++ Remove underscore after reorganization</summary>
      Transform_
      Search
      '''  <summary> +++ Remove this; not used (for now)</summary>
      SubSearch
      FinishedSearch
      ReturnSelf
      ErrorHandler
      ApiCall
      CaseSensitive_
      QuotedText
      '''  <summary> +++ RewindOnModify RewindOnUpdate RewindOnAlter RewindOnRevise RewindOnRevision RewindOnRewriteRewindOnEdit other?</summary>
      RewindOnChange_
      TransformArg
      '''  <summary> +++ Alternative name: Enabled</summary>
      Active_
      '''  <summary> +++ Maybe rename WhiteSpaceSensitive</summary>
      WhiteSpaceCounts
      IgnoreQuote
      IgnoreStatementSep
      IgnoreBracket
      SkipEvalTransform
      ExprUnit
      EagerArg
      SkipPatternMatching
      SkipOver_
      Modified
      UpdatePending
      ParentUpdatePending
      UpToEndOrSeparator
      UpToCompleted
      SkipReduce
      PatternCheck
      EvalStrOutput
      SkipOutput
      NotFound
      ListReturned
      '''  <summary> +++ Temp solution</summary>
      DisconnectedParent
      MiscItem
   End Enum

   '''  <summary> Licensing options for uCalc products</summary>
   Public Enum LicenseTypeEnum As Int32
      License_Demo
      License_FMP_Free
      License_FMP_Standard_32
      License_FMP_Standard_64
      License_FMP_32_and_64
      License_LanguageBuilder
      License_GeneralParser
      License_Interpreter
      License_ConsoleCalc
      License_WindowsCalc
      License_StringLib
      License_Transform
      License_TransformLib
      License_Search
      License_SearchLib
      License_Library1
      License_Library2
      License_Beta
      License_Debugger
      License_uCalc_All
      License_Developer
      License_EndUser
   End Enum

   '''  <summary> Types of tokens</summary>
   Public Enum TokenEnum As Int32
      None
      '''  <summary> A token defined without any specified property is generic (default)</summary>
      Generic
      '''  <summary> Represents the absence of any character (token not found)</summary>
      Empty
      '''  <summary> A token that behaves as alphanuric (works with word boundaries)</summary>
      AlphaNumeric
      '''  <summary> A token that serves as argument separator (typically a comma)</summary>
      ArgSeparator
      '''  <summary> A token that starts a bracketed group; typically strings like { [ or (</summary>
      Bracket
      '''  <summary> The closing token that matches a Bracket token. Ex: } ] or )</summary>
      BracketMatch_
      '''  <summary> A token that separates an object from its member typically a . (a dot)</summary>
      MemberAccess
      '''  <summary> A token that represents a literal value typically a quoted string or number</summary>
      Literal
      '''  <summary> A token that represents a statement separator typically a ; (semicolon)</summary>
      StatementSep
      '''  <summary> A token that represents whitespace typically tab or space characters</summary>
      WhiteSpace
      '''  <summary> A token that is not delimited by word boundaries (+ - * etc) consecutive characters are reduced until they match a value that exists in the symbol table or until 1 character</summary>
      Reducible
      '''  <summary> Non-character that represents the end of a stream of text</summary>
      Eof
      CurrentThread
      LocalVar
      StaticVar
      '''  <summary> Item in parenthesis (or quotes) following this token will be defined while the expression is parsed</summary>
      DefineNow = StaticVar
      TempDef
      '''  <summary> The expression in parathesis (or quotes) following the token is evaluated and inserted in place of the token in the string</summary>
      EvalInsert
      EvalDuringParse
      '''  <summary> Works like EvalInsert except the expression is transformed instead of evaluated  +++ Is it used?</summary>
      TransformInsert
      '''  <summary> The contents of the quoted file name following this token is inserted into the string</summary>
      FileInclude
      CurrentSpace
      DefSpace
      EvalSpace
      TokenTransform
   End Enum

   '''  <summary> RegEx grammar option for defining tokens; based on C++ regex flags</summary>
   Public Enum RegExGrammarEnum As Int32
      '''  <summary> Default grammar; ECMAScript is default unless reconfigured with +++</summary>
      RegEx_Default
      '''  <summary> JavaScript-like regex grammar</summary>
      RegEx_ECMAScript
      '''  <summary> Basic POSIX grammar (BRE)</summary>
      RegEx_basic
      '''  <summary> Extended POSIX grammar (ERE)</summary>
      RegEx_extended
      '''  <summary> awk POSIX grammar</summary>
      RegEx_awk
      '''  <summary> grep POSIX grammar</summary>
      RegEx_grep
      '''  <summary> egrep POXIX grammar</summary>
      RegEx_egrep
   End Enum

   '''  <summary> Transform reset options</summary>
   '''   <remarks>
   '''  <para>Use these options with Transform Reset.  The Default is Reset_All</para>
   '''  </remarks>
   Public Enum TransformResetEnum As Int32
      '''  <summary> Resets all (Input Tokens Rules)</summary>
      Reset_All
      '''  <summary> Resets the input to an empty string</summary>
      Reset_Input
      '''  <summary> Resets token definitions</summary>
      Reset_Tokens
      '''  <summary> Resets the FromTo rules</summary>
      Reset_Rules
      '''  <summary> Resets transform results</summary>
      Reset_Results
      '''  <summary> Removes passes</summary>
      Reset_Passes
   End Enum

   '''  <summary> Options for Transform Pass</summary>
   Public Enum PassEnum As Int32
      '''  <summary> Creates a pass with new token definitions that are separate from those of the parent +++ and separate one for transforms</summary>
      Pass_Independent
      '''  <summary> Creates a pass that inherits a separate copy of the token list from the parent</summary>
      Pass_InheritCopy
      '''  <summary> Creates a pass with that shares the same tokens as the parent</summary>
      Pass_InheritShare
   End Enum

   '''  <summary> Options for transform steps</summary>
   Public Enum StepsEnum As Int32
      Steps_None
      Steps_All
      Steps_Passes
   End Enum

   '''  <summary> Transform Properties</summary>
   Public Enum TransformPropertiesEnum As Int32
      NoTransformProperties
      '''  <summary> Save snapshots of entire text for each change</summary>
      Snapshot_EachChange = 1
      '''  <summary> Save snapshots of entire text for each pass</summary>
      Snapshot_EachPass = 2
      '''  <summary> Save snapshots of each local change</summary>
      Snapshot_LocalChange = 4
      '''  <summary> Save snapshots of local text before each change</summary>
      Archive_LocalOriginals = 5
      '''  <summary> Count number of modifications made by each rule</summary>
      CountChanges = 8
   End Enum

   Public Enum uCalcCompareEnum As Int32
      uc_LessThan = -1
      uc_Equal = 0
      uc_Greater = 1
   End Enum

   Public Enum ChildStringOptionEnum As Int32
      ClearAllOnNewObj
      ClearOverlapOnRead
      ClearOverlapOnWrite
      '''  <summary> +++ Split Detach in 2; add to string IntPtr vs add to ucalc IntPtr(/summary) 
      DetachAllOnNewObj
      DetachOverlapOnRead
      DetachOverlapOnWrite
   End Enum

   Public Enum uCalcList As Int32
      '''  <summary> +++ Rethink uCalcList</summary>
      List_None
      Chars
      Tokens_
      Elments
      Statements
      Lines
      Matches
   End Enum

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Name_1")>
   Private Function Name_1(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Text_2")>
   Private Function Text_2(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="IsProperty_3")>
   Private Function IsProperty_3(ByVal Handle As IntPtr, ByVal ItemProperty As ItemIsEnum) As Int32
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="IsProperty_4")>
   Private Sub IsProperty_4(ByVal Handle As IntPtr, ByVal ItemProperty As ItemIsEnum , ByVal TrueOrFalse As Int32)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="NextOverload_5")>
   Private Function NextOverload_5(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Comment_6")>
   Private Function Comment_6(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Comment_7")>
   Private Function Comment_7(ByVal Handle As IntPtr, ByVal CommentStr As String, ByVal CommentStr_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DataType_8")>
   Private Function DataType_8(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DataType_9")>
   Private Sub DataType_9(ByVal Handle As IntPtr, ByVal dType As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="uCalc_10")>
   Private Function uCalc_10(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Count_11")>
   Private Function Count_11(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="FunctionAddress_12")>
   Private Function FunctionAddress_12(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Precedence_13")>
   Private Function Precedence_13(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Precedence_14")>
   Private Sub Precedence_14(ByVal Handle As IntPtr, ByVal Level As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Rename_15")>
   Private Function Rename_15(ByVal Handle As IntPtr, ByVal NewName As String, ByVal NewName_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Value_16")>
   Private Function Value_16(ByVal Handle As IntPtr) As Double
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Value_17")>
   Private Sub Value_17(ByVal Handle As IntPtr, ByVal Value As Double)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Value_18")>
   Private Sub Value_18(ByVal Handle As IntPtr, ByVal Value As String, ByVal Value_Size As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueBool_19")>
   Private Function ValueBool_19(ByVal Handle As IntPtr) As Int32
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueBool_20")>
   Private Sub ValueBool_20(ByVal Handle As IntPtr, ByVal Value As Int32)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueByte_21")>
   Private Function ValueByte_21(ByVal Handle As IntPtr) As Byte
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueByte_22")>
   Private Sub ValueByte_22(ByVal Handle As IntPtr, ByVal Value As Byte)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueInt16_23")>
   Private Function ValueInt16_23(ByVal Handle As IntPtr) As Int16
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueInt16_24")>
   Private Sub ValueInt16_24(ByVal Handle As IntPtr, ByVal Value As Int16)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueInt32_25")>
   Private Function ValueInt32_25(ByVal Handle As IntPtr) As Int32
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueInt32_26")>
   Private Sub ValueInt32_26(ByVal Handle As IntPtr, ByVal Value As Int32)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueInt64_27")>
   Private Function ValueInt64_27(ByVal Handle As IntPtr) As Int64
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueInt64_28")>
   Private Sub ValueInt64_28(ByVal Handle As IntPtr, ByVal Value As Int64)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueSng_29")>
   Private Function ValueSng_29(ByVal Handle As IntPtr) As Single
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueSng_30")>
   Private Sub ValueSng_30(ByVal Handle As IntPtr, ByVal Value As Single)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueDbl_31")>
   Private Function ValueDbl_31(ByVal Handle As IntPtr) As Double
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueDbl_32")>
   Private Sub ValueDbl_32(ByVal Handle As IntPtr, ByVal Value As Double)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueStr_33")>
   Private Function ValueStr_33(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueStr_34")>
   Private Sub ValueStr_34(ByVal Handle As IntPtr, ByVal Value As String, ByVal Value_Size As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValuePtr_35")>
   Private Function ValuePtr_35(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValuePtr_36")>
   Private Sub ValuePtr_36(ByVal Handle As IntPtr, ByVal Value As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueByPtr_37")>
   Private Sub ValueByPtr_37(ByVal Handle As IntPtr, ByVal Value As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueAddr_38")>
   Private Function ValueAddr_38(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Handle_39")>
   Private Function Handle_39(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Release_40")>
   Private Sub Release_40(ByVal Handle As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Evaluate_41")>
   Private Function Evaluate_41(ByVal Handle As IntPtr) As Double
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="EvaluateDbl_42")>
   Private Function EvaluateDbl_42(ByVal Handle As IntPtr) As Double
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="EvaluateInt32_43")>
   Private Function EvaluateInt32_43(ByVal Handle As IntPtr) As Int32
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="EvaluateBool_44")>
   Private Function EvaluateBool_44(ByVal Handle As IntPtr) As Int32
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="EvaluateStr_45")>
   Private Function EvaluateStr_45(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="EvaluateVoid_46")>
   Private Function EvaluateVoid_46(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Execute_47")>
   Private Sub Execute_47(ByVal Handle As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DataType_48")>
   Private Function DataType_48(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Handle_49")>
   Private Function Handle_49(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Release_50")>
   Private Sub Release_50(ByVal Handle As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Arg_51")>
   Private Function Arg_51(ByVal Handle As IntPtr, ByVal Index As IntPtr) As Double
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ArgDbl_52")>
   Private Function ArgDbl_52(ByVal Handle As IntPtr, ByVal Index As IntPtr) As Double
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Arg1_53")>
   Private Function Arg1_53(ByVal Handle As IntPtr) As Double
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Arg2_54")>
   Private Function Arg2_54(ByVal Handle As IntPtr) As Double
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ArgBool_55")>
   Private Function ArgBool_55(ByVal Handle As IntPtr, ByVal Index As IntPtr) As Int32
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ArgCount_56")>
   Private Function ArgCount_56(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ArgObj_57")>
   Private Function ArgObj_57(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ArgAddr_58")>
   Private Function ArgAddr_58(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ArgExpr_59")>
   Private Function ArgExpr_59(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ArgInt32_60")>
   Private Function ArgInt32_60(ByVal Handle As IntPtr, ByVal Index As IntPtr) As Int32
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ArgInt64_61")>
   Private Function ArgInt64_61(ByVal Handle As IntPtr, ByVal Index As IntPtr) As Int64
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ArgPtr_62")>
   Private Function ArgPtr_62(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ArgStr_63")>
   Private Function ArgStr_63(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Return_64")>
   Private Sub Return_64(ByVal Handle As IntPtr, ByVal Value As Double)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ReturnDbl_65")>
   Private Sub ReturnDbl_65(ByVal Handle As IntPtr, ByVal Value As Double)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ReturnBool_66")>
   Private Sub ReturnBool_66(ByVal Handle As IntPtr, ByVal Value As Int32)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ReturnInt32_67")>
   Private Sub ReturnInt32_67(ByVal Handle As IntPtr, ByVal Value As Int32)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ReturnInt64_68")>
   Private Sub ReturnInt64_68(ByVal Handle As IntPtr, ByVal Value As Int64)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ReturnPtr_69")>
   Private Sub ReturnPtr_69(ByVal Handle As IntPtr, ByVal Value As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ReturnStr_70")>
   Private Sub ReturnStr_70(ByVal Handle As IntPtr, ByVal Value As String, ByVal Value_Size As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ErrorSet_71")>
   Private Sub ErrorSet_71(ByVal Handle As IntPtr, ByVal ErrNumber As ErrorNumberEnum)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ErrorRaise_72")>
   Private Function ErrorRaise_72(ByVal Handle As IntPtr, ByVal ErrNumber As ErrorNumberEnum) As ErrorHandlerResponseEnum
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ErrorRaiseMessage_73")>
   Private Function ErrorRaiseMessage_73(ByVal Handle As IntPtr, ByVal ErrMessage As String, ByVal ErrMessage_Size As IntPtr) As ErrorHandlerResponseEnum
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="uCalc_74")>
   Private Function uCalc_74(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Item_75")>
   Private Function Item_75(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Handle_76")>
   Private Function Handle_76(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Release_77")>
   Private Sub Release_77(ByVal Handle As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ByteSize_78")>
   Private Function ByteSize_78(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Index_79")>
   Private Function Index_79(ByVal Handle As IntPtr) As BuiltInTypesEnum
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Item_80")>
   Private Function Item_80(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Name_81")>
   Private Function Name_81(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Reset_82")>
   Private Sub Reset_82(ByVal Handle As IntPtr, ByVal ValuePtr As IntPtr , ByVal Size As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Reset_83")>
   Private Sub Reset_83(ByVal Handle As IntPtr, ByVal ValuePtr As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="SetArray_84")>
   Private Sub SetArray_84(ByVal Handle As IntPtr, ByVal Destination As IntPtr , ByVal Source As IntPtr , ByVal Index As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="SetScalar_85")>
   Private Sub SetScalar_85(ByVal Handle As IntPtr, ByVal Destination As IntPtr , ByVal Source As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="SwapScalarValues_86")>
   Private Sub SwapScalarValues_86(ByVal Handle As IntPtr, ByVal ValuePtrA As IntPtr , ByVal ValuePtrB As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ToString_87")>
   Private Function ToString_87(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr, ByVal ValuePtr As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ToString_88")>
   Private Function ToString_88(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr, ByVal Value As String, ByVal Value_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Handle_89")>
   Private Function Handle_89(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Release_90")>
   Private Sub Release_90(ByVal Handle As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DefineRule_91")>
   Private Function DefineRule_91(ByVal Handle As IntPtr, ByVal Comment As String, ByVal Comment_Size As IntPtr , ByVal FindStr As String, ByVal FindStr_Size As IntPtr , ByVal ToStr As String, ByVal ToStr_Size As IntPtr , ByVal Min As IntPtr , ByVal Max As IntPtr , ByVal MinHard As IntPtr , ByVal MaxHard As IntPtr , ByVal Precedence As IntPtr , ByVal StartAfter As IntPtr , ByVal StopAfter As IntPtr , ByVal SkipOver As Int32 , ByVal RewindOnChange As Int32 , ByVal CaseSensitive As Int32 , ByVal BracketSensitive As Int32 , ByVal QuoteSensitive As Int32 , ByVal RightToLeft As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DefineToken_92")>
   Private Function DefineToken_92(ByVal Handle As IntPtr, ByVal TokenDef As String, ByVal TokenDef_Size As IntPtr , ByVal TokenType As TokenEnum, ByVal CloseBracket As String, ByVal CloseBracket_Size As IntPtr, ByVal SubMatch As IntPtr, ByVal RegExGrammar As RegExGrammarEnum) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="RemoveToken_93")>
   Private Sub RemoveToken_93(ByVal Handle As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Tokens_94")>
   Private Function Tokens_94(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="FromTo_95")>
   Private Function FromTo_95(ByVal Handle As IntPtr, ByVal FromStr As String, ByVal FromStr_Size As IntPtr , ByVal ToStr As String, ByVal ToStr_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="uCalc_96")>
   Private Function uCalc_96(ByVal Handle As IntPtr, ByVal uCalcHandle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="NewPass_97")>
   Private Function NewPass_97(ByVal Handle As IntPtr, ByVal Share As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Pass_98")>
   Private Function Pass_98(ByVal Handle As IntPtr, ByVal Index As IntPtr , ByVal Share As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Reset_99")>
   Private Function Reset_99(ByVal Handle As IntPtr, ByVal ResetOption As TransformResetEnum) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Transform_100")>
   Private Function Transform_100(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Transform_101")>
   Private Function Transform_101(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr, ByVal expression As String, ByVal expression_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="TransformWithSteps_102")>
   Private Function TransformWithSteps_102(ByVal Handle As IntPtr, ByVal expression As String, ByVal expression_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Str_103")>
   Private Function Str_103(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Str_104")>
   Private Function Str_104(ByVal Handle As IntPtr, ByVal InputStr As String, ByVal InputStr_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="StrData_105")>
   Private Function StrData_105(ByVal Handle As IntPtr) As String
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="StrLength_106")>
   Private Function StrLength_106(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="IndexBase_107")>
   Private Function IndexBase_107(ByVal Handle As IntPtr, ByVal BaseValue As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="IndexBase_108")>
   Private Function IndexBase_108(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="WasModified_109")>
   Private Function WasModified_109(ByVal Handle As IntPtr) As Int32
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="RulesDefault_110")>
   Private Function RulesDefault_110(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="RulesOverall_111")>
   Private Function RulesOverall_111(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Rule_112")>
   Private Function Rule_112(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Handle_113")>
   Private Function Handle_113(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Release_114")>
   Private Sub Release_114(ByVal Handle As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Active_115")>
   Private Function Active_115(ByVal Handle As IntPtr, ByVal TrueFalse As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="FindPart_116")>
   Private Function FindPart_116(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="FindPart_117")>
   Private Function FindPart_117(ByVal Handle As IntPtr, ByVal Pattern As String, ByVal Pattern_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="FromPart_118")>
   Private Function FromPart_118(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="FromPart_119")>
   Private Function FromPart_119(ByVal Handle As IntPtr, ByVal Pattern As String, ByVal Pattern_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ToPart_120")>
   Private Function ToPart_120(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ToPart_121")>
   Private Function ToPart_121(ByVal Handle As IntPtr, ByVal Pattern As String, ByVal Pattern_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="CaseSensitive_122")>
   Private Function CaseSensitive_122(ByVal Handle As IntPtr, ByVal TrueFalse As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="IgnoreInnerPatterns_123")>
   Private Function IgnoreInnerPatterns_123(ByVal Handle As IntPtr, ByVal TrueFalse As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="WhitespaceSensitive_124")>
   Private Function WhitespaceSensitive_124(ByVal Handle As IntPtr, ByVal TrueFalse As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="BracketSensitive_125")>
   Private Function BracketSensitive_125(ByVal Handle As IntPtr, ByVal TrueFalse As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="LocalTransform_126")>
   Private Function LocalTransform_126(ByVal Handle As IntPtr, ByVal t As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Maximum_127")>
   Private Function Maximum_127(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Maximum_128")>
   Private Function Maximum_128(ByVal Handle As IntPtr, ByVal Value As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="MaximumHard_129")>
   Private Function MaximumHard_129(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="MaximumHard_130")>
   Private Function MaximumHard_130(ByVal Handle As IntPtr, ByVal Value As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Minimum_131")>
   Private Function Minimum_131(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Minimum_132")>
   Private Function Minimum_132(ByVal Handle As IntPtr, ByVal Value As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="MinimumHard_133")>
   Private Function MinimumHard_133(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="MinimumHard_134")>
   Private Function MinimumHard_134(ByVal Handle As IntPtr, ByVal Value As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Precedence_135")>
   Private Function Precedence_135(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Precedence_136")>
   Private Function Precedence_136(ByVal Handle As IntPtr, ByVal Value As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Property_137")>
   Private Function Property_137(ByVal Handle As IntPtr, ByVal SelectedProperty As ItemIsEnum , ByVal TrueFalse As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="QuoteSensitive_138")>
   Private Function QuoteSensitive_138(ByVal Handle As IntPtr, ByVal TrueFalse As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ReplacementText_139")>
   Private Function ReplacementText_139(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="StartAfter_140")>
   Private Function StartAfter_140(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="StartAfter_141")>
   Private Function StartAfter_141(ByVal Handle As IntPtr, ByVal Value As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="StopAfter_142")>
   Private Function StopAfter_142(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="StopAfter_143")>
   Private Function StopAfter_143(ByVal Handle As IntPtr, ByVal Value As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="SkipOver_144")>
   Private Function SkipOver_144(ByVal Handle As IntPtr, ByVal TrueFalse As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="RewindOnChange_145")>
   Private Function RewindOnChange_145(ByVal Handle As IntPtr, ByVal TrueFalse As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="RightToLeft_146")>
   Private Function RightToLeft_146(ByVal Handle As IntPtr, ByVal TrueFalse As Int32) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Handle_147")>
   Private Function Handle_147(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Release_148")>
   Private Sub Release_148(ByVal Handle As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Import_149")>
   Private Function Import_149(ByVal Handle As IntPtr, ByVal FromTokenList As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Define_150")>
   Private Function Define_150(ByVal Handle As IntPtr, ByVal TokenDef As String, ByVal TokenDef_Size As IntPtr , ByVal TokenType As TokenEnum, ByVal CloseBracket As String, ByVal CloseBracket_Size As IntPtr, ByVal SubMatch As IntPtr, ByVal RegExGrammar As RegExGrammarEnum) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Handle_151")>
   Private Function Handle_151(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Release_152")>
   Private Sub Release_152(ByVal Handle As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="TokenCharLen_153")>
   Private Function TokenCharLen_153(ByVal Handle As IntPtr, ByVal StartIndex As IntPtr , ByVal Count As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="TokenCount_154")>
   Private Function TokenCount_154(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="TokenType_155")>
   Private Function TokenType_155(ByVal Handle As IntPtr, ByVal Index As IntPtr) As TokenEnum
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Compare_156")>
   Private Function Compare_156(ByVal Handle As IntPtr, ByVal OtherString As String, ByVal OtherString_Size As IntPtr , ByVal IndexA As IntPtr, ByVal IndexB As IntPtr, ByVal Length As IntPtr) As uCalcCompareEnum
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="TokenIndexAtChar_157")>
   Private Function TokenIndexAtChar_157(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Apply_158")>
   Private Function Apply_158(ByVal Handle As IntPtr, ByVal expression As String, ByVal expression_Size As IntPtr , ByVal Variable As String, ByVal Variable_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="At_159")>
   Private Function At_159(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="AtChar_160")>
   Private Function AtChar_160(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="AtToken_161")>
   Private Function AtToken_161(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="BracketMatch_162")>
   Private Function BracketMatch_162(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="BracketedText_163")>
   Private Function BracketedText_163(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="BracketedTextInside_164")>
   Private Function BracketedTextInside_164(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="BracketMatchTokenIndex_165")>
   Private Function BracketMatchTokenIndex_165(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="CharPos_166")>
   Private Function CharPos_166(ByVal Handle As IntPtr, ByVal Nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="CharCount_167")>
   Private Function CharCount_167(ByVal Handle As IntPtr, ByVal Nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="TokenPos_168")>
   Private Function TokenPos_168(ByVal Handle As IntPtr, ByVal Nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="TokenCharPos_169")>
   Private Function TokenCharPos_169(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Str_170")>
   Private Function Str_170(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr, ByVal Nth As IntPtr, ByVal TokenCount As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Str_171")>
   Private Function Str_171(ByVal Handle As IntPtr, ByVal StringValue As String, ByVal StringValue_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Find_172")>
   Private Function Find_172(ByVal Handle As IntPtr, ByVal Pattern As String, ByVal Pattern_Size As IntPtr , ByVal Nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="FindOtherThan_173")>
   Private Function FindOtherThan_173(ByVal Handle As IntPtr, ByVal Pattern As String, ByVal Pattern_Size As IntPtr , ByVal Nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Parent_174")>
   Private Function Parent_174(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Root_175")>
   Private Function Root_175(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="IndexBase_176")>
   Private Function IndexBase_176(ByVal Handle As IntPtr, ByVal BaseValue As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="IndexBase_177")>
   Private Function IndexBase_177(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="UpTo_178")>
   Private Function UpTo_178(ByVal Handle As IntPtr, ByVal Pattern As String, ByVal Pattern_Size As IntPtr , ByVal Nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="StartingFrom_179")>
   Private Function StartingFrom_179(ByVal Handle As IntPtr, ByVal Pattern As String, ByVal Pattern_Size As IntPtr , ByVal Nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="StartingFromEndingWith_180")>
   Private Function StartingFromEndingWith_180(ByVal Handle As IntPtr, ByVal StartPattern As String, ByVal StartPattern_Size As IntPtr , ByVal EndPattern As String, ByVal EndPattern_Size As IntPtr , ByVal StartNth As IntPtr, ByVal EndNth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Before_181")>
   Private Function Before_181(ByVal Handle As IntPtr, ByVal Pattern As String, ByVal Pattern_Size As IntPtr , ByVal Nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="After_182")>
   Private Function After_182(ByVal Handle As IntPtr, ByVal Pattern As String, ByVal Pattern_Size As IntPtr , ByVal Nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Between_183")>
   Private Function Between_183(ByVal Handle As IntPtr, ByVal StartPattern As String, ByVal StartPattern_Size As IntPtr , ByVal StopPattern As String, ByVal StopPattern_Size As IntPtr , ByVal StartNth As IntPtr, ByVal StopNth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ListOfTokens_184")>
   Private Function ListOfTokens_184(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ListOfChars_185")>
   Private Function ListOfChars_185(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="SubString_186")>
   Private Function SubString_186(ByVal Handle As IntPtr, ByVal StartPos As IntPtr , ByVal Length As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ChildStringOption_187")>
   Private Function ChildStringOption_187(ByVal Handle As IntPtr, ByVal Option_ As ChildStringOptionEnum) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ChildStringOption_188")>
   Private Function ChildStringOption_188(ByVal Handle As IntPtr) As ChildStringOptionEnum
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ClearDerivedStrings_189")>
   Private Function ClearDerivedStrings_189(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Remove_190")>
   Private Function Remove_190(ByVal Handle As IntPtr, ByVal From_ As String, ByVal From__Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Replace_191")>
   Private Function Replace_191(ByVal Handle As IntPtr, ByVal From_ As String, ByVal From__Size As IntPtr , ByVal To_ As String, ByVal To__Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Skip_192")>
   Private Function Skip_192(ByVal Handle As IntPtr, ByVal Pattern As String, ByVal Pattern_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ToUpper_193")>
   Private Function ToUpper_193(ByVal Handle As IntPtr, ByVal Pattern As String, ByVal Pattern_Size As IntPtr, ByVal Nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ToLower_194")>
   Private Function ToLower_194(ByVal Handle As IntPtr, ByVal Pattern As String, ByVal Pattern_Size As IntPtr, ByVal Nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="List_195")>
   Private Function List_195(ByVal Handle As IntPtr, ByVal ListType As uCalcList) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ListFormat_196")>
   Private Function ListFormat_196(ByVal Handle As IntPtr, ByVal Separator As String, ByVal Separator_Size As IntPtr , ByVal Prefix As String, ByVal Prefix_Size As IntPtr, ByVal Postfix As String, ByVal Postfix_Size As IntPtr, ByVal UserFunc As String, ByVal UserFunc_Size As IntPtr, ByVal Element As String, ByVal Element_Size As IntPtr, ByVal Index As String, ByVal Index_Size As IntPtr, ByVal Count As String, ByVal Count_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ListSeparator_197")>
   Private Function ListSeparator_197(ByVal Handle As IntPtr, ByVal Separator As String, ByVal Separator_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ListPrefix_198")>
   Private Function ListPrefix_198(ByVal Handle As IntPtr, ByVal Prefix As String, ByVal Prefix_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ListPostfix_199")>
   Private Function ListPostfix_199(ByVal Handle As IntPtr, ByVal Postfix As String, ByVal Postfix_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ListFunction_200")>
   Private Function ListFunction_200(ByVal Handle As IntPtr, ByVal UserFunc As String, ByVal UserFunc_Size As IntPtr , ByVal Element As String, ByVal Element_Size As IntPtr, ByVal Index As String, ByVal Index_Size As IntPtr, ByVal MatchCount As String, ByVal MatchCount_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Populate_201")>
   Private Function Populate_201(ByVal Handle As IntPtr, ByVal first As Double , ByVal last As Double , ByVal expression As String, ByVal expression_Size As IntPtr , ByVal Step_ As Double, ByVal Condition As String, ByVal Condition_Size As IntPtr, ByVal VarIndex As String, ByVal VarIndex_Size As IntPtr, ByVal VarFirst As String, ByVal VarFirst_Size As IntPtr, ByVal VarLast As String, ByVal VarLast_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Match_202")>
   Private Function Match_202(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="MatchIndexAtChar_203")>
   Private Function MatchIndexAtChar_203(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="MatchIndexAtToken_204")>
   Private Function MatchIndexAtToken_204(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="NonMatches_205")>
   Private Function NonMatches_205(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="SubMatch_206")>
   Private Function SubMatch_206(ByVal Handle As IntPtr, ByVal Index As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="MatchCount_207")>
   Private Function MatchCount_207(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Transform_208")>
   Private Function Transform_208(ByVal Handle As IntPtr, ByVal tt As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Handle_209")>
   Private Function Handle_209(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Release_210")>
   Private Sub Release_210(ByVal Handle As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="AddErrorHandler_211")>
   Private Function AddErrorHandler_211(ByVal Handle As IntPtr, ByVal ErrorHandlerAddress As uCalcDelegate , ByVal Position As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Create_212")>
   Private Function Create_212(ByVal Handle As IntPtr, ByVal BasedOn As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="CreateTempDefault_213")>
   Private Function CreateTempDefault_213(ByVal Handle As IntPtr, ByVal BasedOn As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ReleaseTempDefault_214")>
   Private Function ReleaseTempDefault_214(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Alias_215")>
   Private Function Alias_215(ByVal Handle As IntPtr, ByVal NewSymbol As String, ByVal NewSymbol_Size As IntPtr , ByVal ExistingSymbol As String, ByVal ExistingSymbol_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Alias_216")>
   Private Function Alias_216(ByVal Handle As IntPtr, ByVal NewSymbol As String, ByVal NewSymbol_Size As IntPtr , ByVal ExistingItem As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="AliasForDefine_217")>
   Private Sub AliasForDefine_217(ByVal Handle As IntPtr, ByVal NewCommandName As String, ByVal NewCommandName_Size As IntPtr , ByVal ExistingCommandName As String, ByVal ExistingCommandName_Size As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DataTypeOf_218")>
   Private Function DataTypeOf_218(ByVal Handle As IntPtr, ByVal expression As String, ByVal expression_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DataTypeOf_219")>
   Private Function DataTypeOf_219(ByVal Handle As IntPtr, ByVal Index As BuiltInTypesEnum) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Define_220")>
   Private Function Define_220(ByVal Handle As IntPtr, ByVal expression As String, ByVal expression_Size As IntPtr , ByVal Address As IntPtr, ByVal dType As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DefineConstant_221")>
   Private Function DefineConstant_221(ByVal Handle As IntPtr, ByVal Definition As String, ByVal Definition_Size As IntPtr , ByVal VariableAddress As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DefineFunction_222")>
   Private Function DefineFunction_222(ByVal Handle As IntPtr, ByVal Definition As String, ByVal Definition_Size As IntPtr , ByVal FunctionAddr As uCalcDelegate) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DefineOperator_223")>
   Private Function DefineOperator_223(ByVal Handle As IntPtr, ByVal Definition As String, ByVal Definition_Size As IntPtr , ByVal iPrecedence As IntPtr , ByVal Grouping As GroupingEnum, ByVal FunctionAddr As uCalcDelegate) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DefineVariable_224")>
   Private Function DefineVariable_224(ByVal Handle As IntPtr, ByVal Definition As String, ByVal Definition_Size As IntPtr , ByVal VariableAddress As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ErrorExpression_225")>
   Private Function ErrorExpression_225(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ErrorExpression_226")>
   Private Sub ErrorExpression_226(ByVal Handle As IntPtr, ByVal expression As String, ByVal expression_Size As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ErrorLocation_227")>
   Private Function ErrorLocation_227(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ErrorMessage_228")>
   Private Function ErrorMessage_228(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr, ByVal Index As ErrorNumberEnum) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ErrorNumber_229")>
   Private Function ErrorNumber_229(ByVal Handle As IntPtr) As ErrorNumberEnum
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ErrorResponse_230")>
   Private Sub ErrorResponse_230(ByVal Handle As IntPtr, ByVal Response As ErrorHandlerResponseEnum)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ErrorSymbol_231")>
   Private Function ErrorSymbol_231(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Eval_232")>
   Private Function Eval_232(ByVal Handle As IntPtr, ByVal expression As String, ByVal expression_Size As IntPtr) As Double
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="EvalStr_233")>
   Private Function EvalStr_233(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr, ByVal expression As String, ByVal expression_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="RaiseErrorOnDivideByZero_234")>
   Private Sub RaiseErrorOnDivideByZero_234(ByVal Handle As IntPtr, ByVal TrueOrFalse As Int32)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="RaiseErrorOnInexact_235")>
   Private Sub RaiseErrorOnInexact_235(ByVal Handle As IntPtr, ByVal TrueOrFalse As Int32)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="RaiseErrorOnUnderflow_236")>
   Private Sub RaiseErrorOnUnderflow_236(ByVal Handle As IntPtr, ByVal TrueOrFalse As Int32)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="RaiseErrorOnOverflow_237")>
   Private Sub RaiseErrorOnOverflow_237(ByVal Handle As IntPtr, ByVal TrueOrFalse As Int32)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="RaiseErrorOnInvalid_238")>
   Private Sub RaiseErrorOnInvalid_238(ByVal Handle As IntPtr, ByVal TrueOrFalse As Int32)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="FloatingPointErrorsToCatch_239")>
   Private Function FloatingPointErrorsToCatch_239(ByVal Handle As IntPtr, ByVal Value As Int32) As Int32
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ItemOf_240")>
   Private Function ItemOf_240(ByVal Handle As IntPtr, ByVal ItemName As String, ByVal ItemName_Size As IntPtr , ByVal Properties As Int64) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ItemOf_241")>
   Private Function ItemOf_241(ByVal Handle As IntPtr, ByVal Property_ As ItemIsEnum , ByVal nth As IntPtr , ByVal DataTypeName As String, ByVal DataTypeName_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="NamespaceChild_242")>
   Private Function NamespaceChild_242(ByVal Handle As IntPtr, ByVal nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="NamespaceChildCount_243")>
   Private Function NamespaceChildCount_243(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="NamespaceParent_244")>
   Private Function NamespaceParent_244(ByVal Handle As IntPtr, ByVal Level As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="NamespaceSymbol_245")>
   Private Function NamespaceSymbol_245(ByVal Handle As IntPtr, ByVal nth As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="NamespaceSymbolCount_246")>
   Private Function NamespaceSymbolCount_246(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="NewString_247")>
   Private Function NewString_247(ByVal Handle As IntPtr, ByVal InitialString As String, ByVal InitialString_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="NewTransform_248")>
   Private Function NewTransform_248(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ExpressionTransforms_249")>
   Private Function ExpressionTransforms_249(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Parse_250")>
   Private Function Parse_250(ByVal Handle As IntPtr, ByVal expression As String, ByVal expression_Size As IntPtr , ByVal DataType As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Parse_251")>
   Private Function Parse_251(ByVal Handle As IntPtr, ByVal expression As String, ByVal expression_Size As IntPtr , ByVal DataType As String, ByVal DataType_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Parse_252")>
   Private Function Parse_252(ByVal Handle As IntPtr, ByVal expression As String, ByVal expression_Size As IntPtr , ByVal DataTypeIndex As BuiltInTypesEnum) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Precedence_253")>
   Private Function Precedence_253(ByVal Handle As IntPtr, ByVal Operator1 As String, ByVal Operator1_Size As IntPtr , ByVal Operator2 As String, ByVal Operator2_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Properties_254")>
   Private Function Properties_254(ByVal Handle As IntPtr, ByVal p1 As ItemIsEnum , ByVal p2 As ItemIsEnum, ByVal p3 As ItemIsEnum, ByVal p4 As ItemIsEnum) As Int64
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DefaultItem_255")>
   Private Function DefaultItem_255(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DefaultDataType_256")>
   Private Function DefaultDataType_256(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DefaultDataType_257")>
   Private Sub DefaultDataType_257(ByVal Handle As IntPtr, ByVal dType As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DefaultDataType_258")>
   Private Sub DefaultDataType_258(ByVal Handle As IntPtr, ByVal DataTypeIndex As BuiltInTypesEnum)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="DefaultDataType_259")>
   Private Sub DefaultDataType_259(ByVal Handle As IntPtr, ByVal dTypeStr As String, ByVal dTypeStr_Size As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="IsDefault_260")>
   Private Function IsDefault_260(ByVal Handle As IntPtr) As Int32
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="IsDefault_261")>
   Private Sub IsDefault_261(ByVal Handle As IntPtr, ByVal Condition As Int32)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Default_262")>
   Private Function Default_262(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Default_263")>
   Private Sub Default_263(ByVal Handle As IntPtr, ByVal uCalcObj As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Format_264")>
   Private Function Format_264(ByVal Handle As IntPtr, ByVal FunctionAddr As uCalcDelegate , ByVal Properties As String, ByVal Properties_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Format_265")>
   Private Function Format_265(ByVal Handle As IntPtr, ByVal FunctionAddr As uCalcDelegate , ByVal dType As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Format_266")>
   Private Function Format_266(ByVal Handle As IntPtr, ByVal Definition As String, ByVal Definition_Size As IntPtr , ByVal dType As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="FormatRemove_267")>
   Private Sub FormatRemove_267(ByVal Handle As IntPtr, ByVal dType As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueAt_268")>
   Private Function ValueAt_268(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr, ByVal ValuePtr As IntPtr , ByVal dType As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="ValueAt_269")>
   Private Function ValueAt_269(ByVal Handle As IntPtr, ByRef ReturnSize As IntPtr, ByVal ValuePtr As IntPtr , ByVal ValueDataType As String, ByVal ValueDataType_Size As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="License_270")>
   Private Sub License_270(ByVal Handle As IntPtr, ByVal LicenseType As LicenseTypeEnum , ByVal L1 As IntPtr, ByVal L2 As IntPtr, ByVal L3 As IntPtr, ByVal L4 As IntPtr, ByVal L5 As IntPtr)
   End Sub

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Handle_271")>
   Private Function Handle_271(ByVal Handle As IntPtr) As IntPtr
   End Function

   <DllImport(uCalcDLL, CharSet:=CharSet.Ansi, CallingConvention:=CallingConvention.StdCall, EntryPoint:="Release_272")>
   Private Sub Release_272(ByVal Handle As IntPtr)
   End Sub

   '''  <summary> uCalc main class</summary> 
   Public Class uCalc






      
      
      
      
      
      
      
      
      

      

      Public Class Base
         '''  <summary> Handle for Base Class</summary> 
         Public hb As IntPtr

         '''  <summary> Returns the name of the uCalc Item</summary> 
         '''  <remarks>
         '''  <para>Items such as functions, operators, variables, etc generally are given a name when they are defined.
         '''           That name can be retried with this function.</para>
         '''  </remarks> 
         Function Name() As String
            Dim ReturnStrSize As IntPtr
            Dim ReturnString = Name_1(hb, ReturnStrSize )
            Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
         End Function

         '''  <summary> Returns the text data associated with a uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Certain items may have a text property that can be retrieved with a call to this function.  The literal text
         '''           used to define an item is usually stored here.
         '''  </para>
         '''  </remarks> 
         Function Text() As String
            Dim ReturnStrSize As IntPtr
            Dim ReturnString = Text_2(hb, ReturnStrSize )
            Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
         End Function

         '''  <summary> Determines if a uCalc Item has the given properties</summary> 
         '''  <param name="ItemProperty"> The property you want to check for</param>
         '''  <returns> Returns True if the uCalc Item matches the given property, or False otherwise.</returns>
         '''  <remarks>
         '''  <para>This helps you determine whether the uCalc Item is a function, operator, variable, data type,
         '''             literal value, etc, or has certain other special properties.  Note: Some items may have multiple
         '''             properties.  For instance the Function property may be set to True for arrays.
         '''             +++ Maybe (or maybe not; Transform class has them) have complete set of Is functions.  For instance IsCaseSensitive(), IsFunction(), IsVariable(), etc...
         '''             and for some you can change the value like IsCaseSensitive(True) sets the property to True.
         '''  </para>
         '''  </remarks> 
         Function IsProperty( ByVal ItemProperty As ItemIsEnum) As Boolean
            Return IsProperty_3(hb, ItemProperty)
         End Function

         '''  <summary> Sets a given property</summary> 
         '''  <param name="ItemProperty"> The property you want to check for</param>
         '''  <param name="TrueOrFalse"> Value to set the property to</param>
         '''  <returns> Returns True if the uCalc Item matches the given property, or False otherwise.</returns>
         '''  <remarks>
         '''  <para>This helps you determine whether the uCalc Item is a function, operator, variable, data type,
         '''           literal value, etc, or has certain other special properties.  Note: Some items may have multiple
         '''           properties.  For instance the Function property may be set to True for arrays.
         '''           +++ Maybe (or maybe not; Transform class has them) have complete set of Is functions.  For instance IsCaseSensitive(), IsFunction(), IsVariable(), etc...
         '''           and for some you can change the value like IsCaseSensitive(True) sets the property to True.
         '''  </para>
         '''  </remarks> 
         Sub IsProperty( ByVal ItemProperty As ItemIsEnum , ByVal TrueOrFalse As Boolean)
            IsProperty_4(hb, ItemProperty ,  Convert.ToInt32(TrueOrFalse))
         End Sub

         '''  <summary> Returns next uCalc Item object that shares the same name</summary> 
         '''  <returns> Returns next uCalc Item object that shares the same name, or a NULL (or 0) if there is none</returns>
         '''  <remarks>
         '''  <para>If several functions, operators, parameters, etc are overloaded -- that is they are defined with different
         '''           parameters but share the same name --, or if they (or variables) overshadow each other, this function returns
         '''           the next uCalc.Item object that shares the same name.
         '''  </para>
         '''  </remarks> 
         Function NextOverload( ) As Item
            Return NextOverload_5(hb)
         End Function

         '''  <summary> Associates a comment with a rule</summary> 
         '''  <returns> The current rule object</returns>
         '''  <remarks>
         '''  <para>
         '''           Each rule can be assigned a comment.  This comment can later be used at your discretion, for instance in a help file system, or as a tool tip.
         '''  </para>
         '''  </remarks> 
         Function Comment() As String
            Dim ReturnStrSize As IntPtr
            Dim ReturnString = Comment_6(hb, ReturnStrSize )
            Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
         End Function

         '''  <summary> Associates a comment with a rule</summary> 
         '''  <param name="CommentStr"> Text of the comment</param>
         '''  <returns> The current rule object</returns>
         '''  <remarks>
         '''  <para>
         '''           Each rule can be assigned a comment.  This comment can later be used at your discretion, for instance in a help file system, or as a tool tip.
         '''  </para>
         '''  </remarks> 
         Function Comment( ByVal CommentStr As String) As Rule
            Return Comment_7(hb, CommentStr, CommentStr.Length())
         End Function

         '''  <summary> Returns the data type of a uCalc Item</summary> 
         '''  <remarks>
         '''  <para>The returned data type object can be used to determine the type name, size, etc.</para>
         '''  </remarks> 
         Function DataType( ) As DataType
            Return DataType_8(hb)
         End Function

         '''  <summary> Sets the data type of a uCalc Item +++ Might no longer be needed</summary> 
         '''  <param name="dType"> ...</param>
         '''  <remarks>
         '''  <para>Intended mainly for use with DefaultItem()</para>
         '''  </remarks> 
         Sub DataType( ByVal dType As  uCalc.DataType)
            DataType_9(hb, If(dType Is Nothing, Nothing, dType.h))
         End Sub

         '''  <summary> Returns the uCalc object that performs calculations related to the transform</summary> 
         '''  <returns> uCalc object associated with current transform</returns>
         '''  <remarks>
         '''  <para>If your transform inovlves calcuations, then they will be performed using the
         '''           uCalc object returned by this function.  Each uCalc object can have its own sets of
         '''           variables, functions, and other definitions.</para>
         '''  <para>         A uCalc.Item is defined in the context of a uCalc object.  You can later use this function to determine
         '''           the uCalc object the defined item belongs to.
         '''  </para>
         '''  </remarks> 
         Function uCalc( ) As uCalc
            Return uCalc_10(hb)
         End Function
      End Class

      '''  <summary> Class for handling uCalc items</summary> 
      Public Class Item 
         Inherits Base

         '''  <summary> Handle for a uCalc Item</summary> 
         Public h As IntPtr

         '''  <summary> Returns the number of elements in a uCalc Item</summary> 
         '''  <remarks>
         '''  <para>Depending on the kind of object, this may represent the number of elements in an array, the number of parameters in a function,
         '''           the number of operands in an operator, the number of parameters in a syntax construct, the number of parts in a transform,
         '''           the number of parts in a compound token, or the value explicitlely set in the Count property when calling Define.</para>
         '''  <para>         When determining the number of elements, optional parameters in a function count as an element.  If the function
         '''           has a variable number of arguments, then count is -1.</para>
         '''  <para>         The value returned for a syntax construct may not seem obvious, especially if it has optional and/or alternative
         '''           parts or some other complexity.</para>
         '''  <para>         +++ the number of symbols in a uCalc
         '''           instance,</para>
         '''  </remarks> 
         Function Count( ) As Int64
            Return Count_11(h)
         End Function

         '''  <summary> Returns the callback address of a defined function (or operator)</summary> 
         '''  <remarks>
         '''  <para>The returned value is the actual IntPtr address of the function as used by uCalc internally, and not
         '''           a delegate, even in .NET.  As such, in .NET this value can be used in the more general Define function but
         '''           not functions like DefineFunction or DefineneOperator.</para>
         '''  </remarks> 
         Function FunctionAddress( ) As IntPtr
            Return FunctionAddress_12(h)
         End Function

         '''  <summary> Returns the precedence level of the uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Operators, and some syntax constructs are defined with a precedence level.  When defining a new operator you
         '''           may sometimes want to give it the same level as a pre-existing operator.</para>
         '''  </remarks> 
         Function Precedence( ) As Int64
            Return Precedence_13(h)
         End Function

         '''  <summary> Sets the precedence level of the uCalc Item</summary> 
         '''  <param name="Level"> ...</param>
         '''  <remarks>
         '''  <para>Operators, and some syntax constructs are defined with a precedence level.  When defining a new operator you
         '''           may sometimes want to give it the same level as a pre-existing operator.
         '''           For use mainly with DefaultItem.
         '''  </para>
         '''  </remarks> 
         Sub Precedence( ByVal Level As Int64)
            Precedence_14(h, Level)
         End Sub

         '''  <summary> Renames an item</summary> 
         '''  <param name="NewName"> The new name of the item</param>
         '''  <remarks>
         '''  <para>
         '''  Any defined item that has a name (such as a variable, constant, function, operator, etc) can be renamed with this function.
         '''  </para>
         '''  </remarks> 
         Function Rename( ByVal NewName As String) As Item
            Return Rename_15(h, NewName, NewName.Length())
         End Function

         '''  <summary> Returns the value (default Double precision) associated with a uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Use this to retrieve the Double precision value associated with a variable.</para>
         '''  </remarks> 
         Function Value( ) As Double
            Return Value_16(h)
         End Function

         '''  <summary> Sets the value of a floating point variable</summary> 
         '''  <param name="Value"> Double precision floating point value that the variable will be set to</param>
         '''  <remarks>
         '''  <para>When a floating point variable is defined with DefineVariable, you can later set a value for this variable by passing an
         '''             argument to Value.  Note: If your compiler supports pointers, you can define a uCalc variable that is directly attached
         '''             to the address of a variable in your source code, and not have to use Value.
         '''  </para>
         '''  </remarks> 
         Sub Value( ByVal Value As Double)
            Value_17(h, Value)
         End Sub

         '''  <summary> Sets the value of a variable of any data type by passing a string</summary> 
         '''  <param name="Value"> String containing the value that will be converted and stored in the variable</param>
         '''  <remarks>
         '''  <para>This lets you set the value of a variable defined with DefineVariable (or Define) regardless of the variable's data type.
         '''           The value is passed as a string, and internally converted to the appropriate data type.  Note: Because a conversion takes
         '''           place with ValueAny, it is typically slower than calling Value for floating point, or one of the
         '''           other versions of Value specific to a data type.</para>
         '''  </remarks> 
         Sub Value( ByVal Value As String)
            Value_18(h, Value, Value.Length())
         End Sub

         '''  <summary> Returns the Boolean value associated with a uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Use this to retrieve the Boolean value associated with a variable.</para>
         '''  </remarks> 
         Function ValueBool( ) As Boolean
            Return ValueBool_19(h)
         End Function

         '''  <summary> Sets the value of a Boolean variable</summary> 
         '''  <param name="Value"> Boolean value that the variable will be set to</param>
         '''  <remarks>
         '''  <para>This lets you set the value of a Boolean variable defined with DefineVariable (or Define)</para>
         '''  </remarks> 
         Sub ValueBool( ByVal Value As Boolean)
            ValueBool_20(h,  Convert.ToInt32(Value))
         End Sub

         '''  <summary> Returns the byte value associated with a uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Use this to retrieve the Byte value associated with a variable.</para>
         '''  </remarks> 
         Function ValueByte( ) As Byte
            Return ValueByte_21(h)
         End Function

         '''  <summary> Sets the value of a Byte variable</summary> 
         '''  <param name="Value"> Byte value that the variable will be set to</param>
         '''  <remarks>
         '''  <para>This lets you set the value of a Byte variable defined with DefineVariable (or Define)</para>
         '''  </remarks> 
         Sub ValueByte( ByVal Value As Byte)
            ValueByte_22(h, Value)
         End Sub

         '''  <summary> Returns the 16-bit integer value associated with a uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Use this to retrieve the Int16 value associated with a variable.</para>
         '''  </remarks> 
         Function ValueInt16( ) As Int16
            Return ValueInt16_23(h)
         End Function

         '''  <summary> Sets the value of a 16-bit integer variable</summary> 
         '''  <param name="Value"> 16-bit integer value that the variable will be set to</param>
         '''  <remarks>
         '''  <para>This lets you set the value of a 16-bit integer variable defined with DefineVariable (or Define).  This works for
         '''           both signed and unsigned 16-bit integers.</para>
         '''  </remarks> 
         Sub ValueInt16( ByVal Value As Int16)
            ValueInt16_24(h, Value)
         End Sub

         '''  <summary> Returns the 32-bit integer value associated with a uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Use this to retrieve the Int32 value associated with a variable.</para>
         '''  </remarks> 
         Function ValueInt32( ) As Int32
            Return ValueInt32_25(h)
         End Function

         '''  <summary> Sets the value of a 32-bit integer variable</summary> 
         '''  <param name="Value"> 32-bit integer value that the variable will be set to</param>
         '''  <remarks>
         '''  <para>This lets you set the value of a 32-bit integer variable defined with DefineVariable (or Define).  This works for
         '''           both signed and unsigned 32-bit integers.</para>
         '''  </remarks> 
         Sub ValueInt32( ByVal Value As Int32)
            ValueInt32_26(h, Value)
         End Sub

         '''  <summary> Returns the 64-bit integer value associated with a uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Use this to retrieve the Int64 value associated with a variable.</para>
         '''  </remarks> 
         Function ValueInt64( ) As Int64
            Return ValueInt64_27(h)
         End Function

         '''  <summary> Sets the value of a 64-bit integer variable</summary> 
         '''  <param name="Value"> 64-bit integer value that the variable will be set to</param>
         '''  <remarks>
         '''  <para>This lets you set the value of a 64-bit integer variable defined with DefineVariable (or Define).  This works for
         '''           both signed and unsigned 64-bit integers.</para>
         '''  </remarks> 
         Sub ValueInt64( ByVal Value As Int64)
            ValueInt64_28(h, Value)
         End Sub

         '''  <summary> Returns the Double precision value associated with a uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Use this to retrieve the Single precision value associated with a variable.</para>
         '''  </remarks> 
         Function ValueSng( ) As Single
            Return ValueSng_29(h)
         End Function

         '''  <summary> Sets the value of a single precision floating point variable</summary> 
         '''  <param name="Value"> Single precision value that the variable will be set to</param>
         '''  <remarks>
         '''  <para>This lets you set the value of a single precision variable defined with DefineVariable (or Define).</para>
         '''  </remarks> 
         Sub ValueSng( ByVal Value As Single)
            ValueSng_30(h, Value)
         End Sub

         '''  <summary> Returns the Double precision value associated with a uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Synonymous with Value</para>
         '''  </remarks> 
         Function ValueDbl( ) As Double
            Return ValueDbl_31(h)
         End Function

         '''  <summary> Sets the value of a Double precision floating point variable</summary> 
         '''  <param name="Value"> Double precision floating point value that the variable will be set to</param>
         '''  <remarks>
         '''  <para>ValueDbl is synonymous with Value</para>
         '''  </remarks> 
         Sub ValueDbl( ByVal Value As Double)
            ValueDbl_32(h, Value)
         End Sub

         '''  <summary> Returns the String value associated with a uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Use this to retrieve the String value associated with a variable.</para>
         '''  <para>         ValueStr has a special property beyond the Value function for other data types in that it can return the value
         '''           of an item regardless of what data type it has.  The value is returned as a string.
         '''  </para>
         '''  </remarks> 
         Function ValueStr() As String
            Dim ReturnStrSize As IntPtr
            Dim ReturnString = ValueStr_33(h, ReturnStrSize )
            Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
         End Function

         '''  <summary> Sets the value of a string variable</summary> 
         '''  <param name="Value"> String value that the variable will be set to</param>
         '''  <remarks>
         '''  <para>This lets you set the value of a string variable defined with DefineVariable (or Define).</para>
         '''  </remarks> 
         Sub ValueStr( ByVal Value As String)
            ValueStr_34(h, Value, Value.Length())
         End Sub

         '''  <summary> Returns the IntPtr value associated with a uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Use this to retrieve the IntPtr value associated with a variable.
         '''           Note: If the uCalc.Item is a Variable of type IntPtr, then ValuePtr returns a IntPtr value
         '''           that is stored in that variable, whereas ValueAddr returns the IntPtr of the variable itself.  In other words
         '''           ValueAddr returns the address in memory of the current uCalc.Item value, while ValuePtr returns any value you may
         '''           have set as the address the variable points to.</para>
         '''  </remarks> 
         Function ValuePtr( ) As IntPtr
            Return ValuePtr_35(h)
         End Function

         '''  <summary> Sets the value of a IntPtr variable</summary> 
         '''  <param name="Value"> IntPtr that the variable will be set to</param>
         '''  <remarks>
         '''  <para>This lets you set the value of a IntPtr variable defined with DefineVariable (or Define).  Note: This does not
         '''           change the IntPtr of the variable.  It simply stores a IntPtr value in the variable.</para>
         '''  </remarks> 
         Sub ValuePtr( ByVal Value As IntPtr)
            ValuePtr_36(h, Value)
         End Sub

         '''  <summary> Sets the value of a variable to a value who's IntPtr is passed</summary> 
         '''  <param name="Value"> IntPtr to the value that the variable will be set to</param>
         '''  <remarks>
         '''  <para>This lets you set the value of a variable by passing the IntPtr to the value you want to set the variable to.</para>
         '''  </remarks> 
         Sub ValueByPtr( ByVal Value As IntPtr)
            ValueByPtr_37(h, Value)
         End Sub

         '''  <summary> Returns the IntPtr address of the value associated with a uCalc.Item</summary> 
         '''  <remarks>
         '''  <para>Use this to retrieve the IntPtr address of the value associated with a variable (instead of
         '''           the value itself).  Note: If the uCalc.Item is a Variable of type IntPtr, then ValuePtr returns a IntPtr value
         '''           that is stored in that variable, whereas ValueAddr returns the IntPtr of the variable itself.  In other words
         '''           ValueAddr returns the address in memory of the current uCalc.Item value, while ValuePtr returns any given address
         '''           you may have stored as the value of the variable.</para>
         '''  </remarks> 
         Function ValueAddr( ) As IntPtr
            Return ValueAddr_38(h)
         End Function

         '''  <summary> ...</summary>
         '''   <remarks>
         '''  <para>
         '''           +++ check optimization
         '''           ... +++ Do this for other structs too
         '''  </para>
         '''  </remarks>

         '''  <summary> ...</summary>
         '''   <remarks>
         '''  <para>
         '''           ...
         '''  </para>
         '''  </remarks>


         
         Public Sub New()
            h = 0
         End Sub

         Public Sub New(ByVal Definition As String)
            h = Default_().Define(Definition).h
         End Sub

         '''  <summary> Returns the handle of an object</summary> 
         '''  <remarks>
         '''  <para>Mostly for internal use.  However, if you are iterating through a series of objects with NextOverload
         '''     (when applicable), you may check Handle() to see when it becomes NULL (or 0) to know when to stop.</para>
         '''  </remarks> 
         Function Handle( ) As IntPtr
            Return Handle_39(h)
         End Function

         '''  <summary> +++ comment for each</summary> 
         Sub Release()
            If h <> 0 Then
               Release_40(h)
               h = 0
            End If
         End Sub

         Public Shared Widening Operator CType(ByVal o As IntPtr) As Item
         Return New Item(o)
      End Operator

      Public Sub New(ByVal PassedHandle As IntPtr)
         h = PassedHandle
         hb = h
      End Sub
   End Class

   '''  <summary> Class for evaluating an already parsed expression or executing parsed code</summary> 
   Public Class Expression

      '''  <summary> Handle for a uCalc expression</summary> 
      Public h As IntPtr

      '''  <summary> Rapidly evaluates a floating point expression that was parsed with Parse or passed By Expression</summary> 
      '''  <returns> The result of the evaluated expression returned as a floating point number</returns>
      '''  <remarks>
      '''  <para>Evaluate can be used instead of Eval for faster results in time-critical loops where the same expression
      '''           is repeatedly re-evaluated, with the only change in each iteration typically being the value(s) of one or
      '''           more variables.  Evaluate works in pair with Parse, the relatively slower part, which is called first before
      '''           going into the time-critical loop.  The Expression object returned by Parse is what calls the Evaluate function.</para>
      '''  <para>         
      '''           
      '''           
      '''           
      '''           
      '''           
      '''           
      '''           
      '''  <para>         Evaluate can also be called by a Expression object that was passed to a callback By Expression.</para>
      '''  <para>         If the expression evaluates to something other than Double precision floating point (such as various integers, complex,
      '''           single precision, etc), the value is converted before being returned.  In some cases (such as string, complex, etc), the
      '''           return result may or may not have a meaningful value.  However, an error is not raised.
      '''  </para>
      '''  </remarks> 
      Function Evaluate( ) As Double
         Return Evaluate_41(h)
      End Function

      '''  <summary> Rapidly evaluates a floating point expression that was parsed with Parse or passed By Expression</summary> 
      '''  <returns> The result of the evaluated floating point expression</returns>
      '''  <remarks>
      '''  <para>EvaluateDbl is similar to Evaluate, but is intended strictly for expressions that return a Double
      '''           precision value (determined by the operators used in the expression).  It will not work with Integers
      '''           or Single precision expressions for instance.</para>
      '''  <para>         If the expression evaluates
      '''           to a non-numeric value (such as a string) or non-scalar numeric value (such as a complex number), or if a numeric
      '''           type other than the default was explicitely specified with Parse, the value returned will be invalid.  However,
      '''           an error will not be raised.
      '''  </para>
      '''  </remarks> 
      Function EvaluateDbl( ) As Double
         Return EvaluateDbl_42(h)
      End Function

      '''  <summary> Rapidly evaluates expression that was parsed as integer with Parse or passed By Expression</summary> 
      '''  <returns> The result of the evaluated integer expression</returns>
      '''  <remarks>
      '''  <para>
      '''           This is similar to Evaluate, but applies only to expressions that return a 32-bit integer.
      '''  </para>
      '''  </remarks> 
      Function EvaluateInt32( ) As Int32
         Return EvaluateInt32_43(h)
      End Function

      '''  <summary> Rapidly evaluates expression that was parsed as Boolean with Parse or passed By Expression</summary> 
      '''  <returns> The result of the evaluated Boolean expression</returns>
      '''  <remarks>
      '''  <para>
      '''           This is similar to Evaluate, but applies only to expressions that return a Boolean.
      '''           Certain operators, such as comparison operators like <, >, ==, etc. return a Boolean.  If the final operation of an
      '''           expression is Boolean, for instance in Parse("x + 1 > 3"), then you can use EvaluateBool.  In earlier versions
      '''           Evaluate could not be used for types other than floating point, unless Double was specified in Parse so that a
      '''           conversion can take place (from Boolean in this case) to Double before being returned.  Now you can either use
      '''           EvaluateBool (slightly more efficient) or else Evaluate as a catch all for any type including Boolean.
      '''  </para>
      '''  </remarks> 
      Function EvaluateBool( ) As Boolean
         Return EvaluateBool_44(h)
      End Function

      '''  <summary> Rapidly evaluates an expression of any data type that was parsed with Parse or passed By Expression returning a string</summary> 
      '''  <returns> The result of an evaluated expression of any data type, returned as a string</returns>
      '''  <remarks>
      '''  <para>EvaluateStr is similar to Evaluate.  However, EvaluateStr returns a value as a string.  Unlike Evaluate, which can only
      '''           return a floating point value, EvaluateStr can return a value of any data type.  Non-string values are converted to a string
      '''           before being returned.
      '''  </para>
      '''  </remarks> 
      Function EvaluateStr() As String
         Dim ReturnStrSize As IntPtr
         Dim ReturnString = EvaluateStr_45(h, ReturnStrSize )
         Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
      End Function

      '''  <summary> Rapidly evaluates an expression that was parsed with Parse or passed By Expression and returns a IntPtr to the result</summary> 
      '''  <returns> Returns a IntPtr to the result instead of the result itself</returns>
      '''  <remarks>
      '''  <para>Use this when you are interested in a IntPtr to the result instead of the result itself.  For instance, given an integer
      '''           result, you might use a IntPtr in order to retrieve the hi byte and lo byte values.
      '''  </para>
      '''  </remarks> 
      Function EvaluateVoid( ) As IntPtr
         Return EvaluateVoid_46(h)
      End Function

      '''  <summary> Rapidly executes code that was parsed with Parse or passed By Expression for which a result is not required</summary> 
      '''  <remarks>
      '''  <para>This can be used in cases where the reutrn value is not needed, such as statements that represent code to be executed
      '''           rather than a math expression.
      '''  </para>
      '''  </remarks> 
      Sub Execute( )
         Execute_47(h)
      End Sub

      '''  <summary> Returns the data type of a parsed expression</summary> 
      '''  <remarks>
      '''  <para>
      '''           ...
      '''  </para>
      '''  </remarks> 
      Function DataType( ) As DataType
         Return DataType_48(h)
      End Function

      '''  <summary> ...</summary>
      '''   <remarks>
      '''  <para>
      '''           +++ check optimization
      '''           ...
      '''  </para>
      '''  </remarks>

      '''  <summary> ...</summary>
      '''   <remarks>
      '''  <para>
      '''           ...
      '''  </para>
      '''  </remarks>
      '''  <summary> Returns the handle of an object</summary> 
      '''  <remarks>
      '''  <para>Mostly for internal use.  However, if you are iterating through a series of objects with NextOverload
      '''     (when applicable), you may check Handle() to see when it becomes NULL (or 0) to know when to stop.</para>
      '''  </remarks> 
      Function Handle( ) As IntPtr
         Return Handle_49(h)
      End Function

      '''  <summary> +++ comment for each</summary> 
      Sub Release()
         If h <> 0 Then
            Release_50(h)
            h = 0
         End If
      End Sub

      Public Shared Widening Operator CType(ByVal o As IntPtr) As Expression
      Return New Expression(o)
   End Operator

   Public Sub New(ByVal PassedHandle As IntPtr)
      h = PassedHandle
   End Sub
End Class

'''  <summary> Class for retrieving arguments passed to a callback, returning a value, and more</summary> 
Public Class Callback

   '''  <summary> Handle of the expression part the current callback instance is refering to</summary> 
   Public h As IntPtr

   '''  <summary> Returns the value of an argument passed to a uCalc.Callback function</summary> 
   '''  <param name="Index"> Index of the given argument.  Note that Index is 1-based; the Index for the first arg is 1 (not 0)</param>
   '''  <remarks>
   '''  <para>When the name of a callback function is specified in DefineFunction or DefineOperator, that
   '''           callback function will receive arguments uCalc passes to it through the Arg.  Arg handles values
   '''           of the default Double floating point data type.  For other data types, ArgInt32, ArgStr, etc instead.</para>
   '''  <para>         Note that Index is 1-based.  So if there are 3 arguments, the Index of the first will be
   '''           1 (not 0), and the second and third will be 2 and 3 respectively.</para>
   '''  <para>         If you are defining a binary operator, 1 is the index for the left operand, and 2 for the right operand.
   '''           For a unary operator, the index is 1.
   '''  </para>
   '''  </remarks> 
   Function Arg( ByVal Index As Int64) As Double
      Return Arg_51(h, Index)
   End Function

   '''  <summary> Returns the value of an argument passed to a uCalc.Callback function</summary> 
   '''  <param name="Index"> Index of the given argument.  Note that Index is 1-based; the Index for the first arg is 1 (not 0)</param>
   '''  <remarks>
   '''  <para>When the name of a callback function is specified in DefineFunction or DefineOperator, that
   '''           callback function will receive arguments uCalc passes to it through the Arg.  Arg handles values
   '''           of the default Double floating point data type.  For other data types, ArgInt32, ArgStr, etc instead.</para>
   '''  <para>         Note that Index is 1-based.  So if there are 3 arguments, the Index of the first will be
   '''           1 (not 0), and the second and third will be 2 and 3 respectively.</para>
   '''  <para>         If you are defining a binary operator, 1 is the index for the left operand, and 2 for the right operand.
   '''           For a unary operator, the index is 1.
   '''  </para>
   '''  </remarks> 
   Function ArgDbl( ByVal Index As Int64) As Double
      Return ArgDbl_52(h, Index)
   End Function

   '''  <summary> ...</summary> 
   '''  <remarks>
   '''  <para>
   '''           ...
   '''  </para>
   '''  </remarks> 
   Function Arg1( ) As Double
      Return Arg1_53(h)
   End Function

   '''  <summary> ...</summary> 
   '''  <remarks>
   '''  <para>
   '''           ...
   '''  </para>
   '''  </remarks> 
   Function Arg2( ) As Double
      Return Arg2_54(h)
   End Function

   '''  <summary> Returns the Boolean integer argument passed to a uCalc.Callback function</summary> 
   '''  <param name="Index"> Index of the given argument.  Note that Index is 1-based; the Index for the first arg is 1 (not 0)</param>
   '''  <remarks>
   '''  <para>If a function parameter (or operator operand) was explicitely defined as Int32, then the callback function can
   '''           recieve it through ArgBool.  If the argument is of a different but compatible numeric type, a conversion takes
   '''           place first before being passed.</para>
   '''  </remarks> 
   Function ArgBool( ByVal Index As Int64) As Boolean
      Return ArgBool_55(h, Index)
   End Function

   '''  <summary> Returns the number of arguments being passed to a uCalc.Callback function</summary> 
   '''  <returns> 0 if no arg is passed; or a positive integer representing the number of args being passed.</returns>
   '''  <remarks>
   '''  <para>This is useful for functions that have a variable number of arguments</para>
   '''  </remarks> 
   Function ArgCount( ) As Int64
      Return ArgCount_56(h)
   End Function

   '''  <summary> Returns an object instance of the argument being passed to a uCalc.Callback function</summary> 
   '''  <param name="Index"> Index of the given argument.  Note that Index is 1-based; the Index for the first arg is 1 (not 0)</param>
   '''  <returns> The returned object can be used (where relevent) just like any other uCalc.Item</returns>
   '''  <remarks>
   '''  <para>Each argument is a uCalc.Item, just like anything else defined with Define.  With this object,
   '''           you can do such things as determine the argument's data type, determine which instance of uCalc
   '''           it belongs to, retrieve the IntPtr of the value of the argument, etc.</para>
   '''  </remarks> 
   Function ArgObj( ByVal Index As Int64) As Item
      Return ArgObj_57(h, Index)
   End Function

   '''  <summary> Returns the address of the argument value that is being passed</summary> 
   '''  <param name="Index"> Index of the given argument.  Note that Index is 1-based; the Index for the first arg is 1 (not 0)</param>
   '''  <remarks>
   '''  <para>In addition to Arg which returns arguments that are of the default Double floating point numeric type, there
   '''           are specialized functions for other datatypes such as ArgInt32, ArgInt64, etc.  However, if the argument is of
   '''           a data type that does not have a specialized function, you can retrieve the address of the argument value as
   '''           a IntPtr, and use that to retrieve the value.</para>
   '''  </remarks> 
   Function ArgAddr( ByVal Index As Int64) As IntPtr
      Return ArgAddr_58(h, Index)
   End Function

   '''  <summary> Returns the object instance of the expression that's passed as an argument to a uCalc.Callback function+++Example</summary> 
   '''  <param name="Index"> Index of the given argument.  Note that Index is 1-based; the Index for the first arg is 1 (not 0)</param>
   '''  <returns> Returns parsed expression object with which you can call functions like Evaluate or Execute</returns>
   '''  <remarks>
   '''  <para>uCalc allows you to not only pass arguments by value or by reference.  But it also lets you pass an argument
   '''           by expression.  When an expression is passed By Expression, the expresison is not evaluated before being passed.
   '''           Instead a handle to the parsed expression is passed, allowing the callback to perform the evaluation.</para>
   '''  </remarks> 
   Function ArgExpr( ByVal Index As Int64) As Expression
      Return ArgExpr_59(h, Index)
   End Function

   '''  <summary> Returns the Int32 integer argument passed to a uCalc.Callback function</summary> 
   '''  <param name="Index"> Index of the given argument.  Note that Index is 1-based; the Index for the first arg is 1 (not 0)</param>
   '''  <remarks>
   '''  <para>If a function parameter (or operator operand) was explicitely defined as Int32, then the callback function can
   '''           recieve it through ArgInt32.  If the argument is of a different but compatible numeric type, a conversion takes
   '''           place first before being passed.</para>
   '''  </remarks> 
   Function ArgInt32( ByVal Index As Int64) As Int32
      Return ArgInt32_60(h, Index)
   End Function

   '''  <summary> Returns the Int64 integer argument being passed to a uCalc.Callback function</summary> 
   '''  <param name="Index"> Index of the given argument.  Note that Index is 1-based; the Index for the first arg is 1 (not 0)</param>
   '''  <remarks>
   '''  <para>If a function parameter (or operator operand) was explicitely defined as Int64, then the callback function can
   '''           recieve it through ArgInt64.  If the argument is of a different but compatible numeric type, a conversion takes
   '''           place first before being passed.</para>
   '''  </remarks> 
   Function ArgInt64( ByVal Index As Int64) As Int64
      Return ArgInt64_61(h, Index)
   End Function

   '''  <summary> Returns a IntPtr value being passed as an argument to a uCalc.Callback function</summary> 
   '''  <param name="Index"> Index of the given argument.  Note that Index is 1-based; the Index for the first arg is 1 (not 0)</param>
   '''  <remarks>
   '''  <para>If a function parameter (or operator operand) was explicitely defined as a IntPtr, then the callback function can
   '''           recieve it through ArgPtr.  Note that ArgPtr returns any address value that is being sent, whereas ArgAddr returns the
   '''           address of the value being passed.</para>
   '''  </remarks> 
   Function ArgPtr( ByVal Index As Int64) As IntPtr
      Return ArgPtr_62(h, Index)
   End Function

   '''  <summary> Returns the value being passed as argument in to a uCalc.Callback function in form of a string</summary> 
   '''  <param name="Index"> Index of the given argument.  Note that Index is 1-based; the Index for the first arg is 1 (not 0)</param>
   '''  <remarks>
   '''  <para>Returns data of any type to a string.
   '''           In addition to returning an argument that was passed as a string, ArgStr has the special property of returning an argument that
   '''           was passed as any data type.  If the argument was not a string, ArgStr converts it to a string before returning its value.</para>
   '''  </remarks> 
   Function ArgStr(ByVal Index As Int64) As String
      Dim ReturnStrSize As IntPtr
      Dim ReturnString = ArgStr_63(h, ReturnStrSize , Index)
      Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
   End Function

   '''  <summary> Sets the return value (default floating point) of a uCalc.Callback function</summary> 
   '''  <param name="Value"> Floating point value that your callback returns</param>
   '''  <remarks>
   '''  <para>When you define a callback function with DefineFunction and you want to return a floating point number,
   '''           do it with Return.</para>
   '''  <para>         Note: For compilers in which Return is a reserved keyword, use ReturnDbl instead.
   '''  </para>
   '''  </remarks> 
   Sub Return_( ByVal Value As Double)
      Return_64(h, Value)
   End Sub

   '''  <summary> Sets the return value (default floating point) of a uCalc.Callback function</summary> 
   '''  <param name="Value"> Floating point value that your callback returns</param>
   '''  <remarks>
   '''  <para>When you define a callback function with DefineFunction and you want to return a floating point number,
   '''           do it with Return.</para>
   '''  <para>         Note: For compilers in which Return is a reserved keyword, use ReturnDbl instead.
   '''  </para>
   '''  </remarks> 
   Sub ReturnDbl( ByVal Value As Double)
      ReturnDbl_65(h, Value)
   End Sub

   '''  <summary> Sets the return value of a uCalc.Callback function as an Boolean integer</summary> 
   '''  <param name="Value"> Boolean that your callback returns</param>
   '''  <remarks>
   '''  <para>When you define a callback function with DefineFunction and you want to return a Boolean,
   '''           do it with ReturnBool.</para>
   '''  </remarks> 
   Sub ReturnBool( ByVal Value As Boolean)
      ReturnBool_66(h,  Convert.ToInt32(Value))
   End Sub

   '''  <summary> Sets the return value of a uCalc.Callback function as an Int32 integer</summary> 
   '''  <param name="Value"> Integer (32-bit) that your callback returns</param>
   '''  <remarks>
   '''  <para>When you define a callback function with DefineFunction and you want to return a Int32,
   '''           do it with ReturnInt32.</para>
   '''  </remarks> 
   Sub ReturnInt32( ByVal Value As Int32)
      ReturnInt32_67(h, Value)
   End Sub

   '''  <summary> Sets the return value of a uCalc.Callback function as an Int64 integer</summary> 
   '''  <param name="Value"> Integer (64-bit) that your callback returns</param>
   '''  <remarks>
   '''  <para>When you define a callback function with DefineFunction and you want to return a Int64,
   '''           do it with ReturnInt64.</para>
   '''  </remarks> 
   Sub ReturnInt64( ByVal Value As Int64)
      ReturnInt64_68(h, Value)
   End Sub

   '''  <summary> Sets the return value of a uCalc.Callback function as a IntPtr</summary> 
   '''  <param name="Value"> IntPtr value that your callback returns</param>
   '''  <remarks>
   '''  <para>When you define a callback function with DefineFunction that returns a IntPtr value,
   '''           do it with ReturnPtr.</para>
   '''  </remarks> 
   Sub ReturnPtr( ByVal Value As IntPtr)
      ReturnPtr_69(h, Value)
   End Sub

   '''  <summary> Sets the return value of a uCalc.Callback function as a String</summary> 
   '''  <param name="Value"> String value that your callback returns</param>
   '''  <remarks>
   '''  <para>When you define a callback function with DefineFunction that returns a string,
   '''           do it with ReturnStr.</para>
   '''  </remarks> 
   Sub ReturnStr( ByVal Value As String)
      ReturnStr_70(h, Value, Value.Length())
   End Sub

   '''  <summary> ...</summary> 
   '''  <param name="ErrNumber"> Index number of error to raise</param>
   '''  <remarks>
   '''  <para>
   '''           ...
   '''  </para>
   '''  </remarks> 
   Sub ErrorSet( ByVal ErrNumber As ErrorNumberEnum)
      ErrorSet_71(h, ErrNumber)
   End Sub

   '''  <summary> Raises an error in a uCalc.Callback function</summary> 
   '''  <param name="ErrNumber"> Index number of error to raise</param>
   '''  <returns> Returns ErrorAbort, ErrorResume, or ErrorReRaise.</returns>
   '''  <remarks>
   '''  <para>Your callback can raise an error by calling this funciton with one of the values of the
   '''           ErrorNumberEnum enumerator.  End-user function definitions can also raise an error by calling Error().
   '''           The return value is determined by error handlers that you may have added.  ErrorAbort (value of 0)
   '''           is returned by default if there are no error handlers.</para>
   '''  </remarks> 
   Function ErrorRaise( ByVal ErrNumber As ErrorNumberEnum) As ErrorHandlerResponseEnum
      Return ErrorRaise_72(h, ErrNumber)
   End Function

   '''  <summary> Raises an error with a user-defined message in a uCalc.Callback function</summary> 
   '''  <param name="ErrMessage"> Text of custom error message to return</param>
   '''  <returns> Returns ErrorAbort, ErrorResume, or ErrorReRaise.</returns>
   '''  <remarks>
   '''  <para>Your callback can raise a custom error message (one not listed as a ErrorNumberEnum enumerator)
   '''           by simply passing the text of the message to this function.</para>
   '''  </remarks> 
   Function ErrorRaiseMessage( ByVal ErrMessage As String) As ErrorHandlerResponseEnum
      Return ErrorRaiseMessage_73(h, ErrMessage, ErrMessage.Length())
   End Function

   '''  <summary> Returns the uCalc instance the current expression part belongs to</summary> 
   '''  <remarks>
   '''  <para>A callback is designed to work with all instances of uCalc.  However, at times you may need to know
   '''           which particular instance of uCalc the expression part being passed belongs to.</para>
   '''  </remarks> 
   Function uCalc( ) As uCalc
      Return uCalc_74(h)
   End Function

   '''  <summary> Returns the function or operator Item of the current expression part</summary> 
   '''  <remarks>
   '''  <para>If several functions and/or operators are mapped to the same callback function, you can use this to
   '''           let you determine which one is currently being called, based on properties you can check.</para>
   '''  </remarks> 
   Function Item( ) As Item
      Return Item_75(h)
   End Function

   '''  <summary> Returns the handle of an object</summary> 
   '''  <remarks>
   '''  <para>Mostly for internal use.  However, if you are iterating through a series of objects with NextOverload
   '''     (when applicable), you may check Handle() to see when it becomes NULL (or 0) to know when to stop.</para>
   '''  </remarks> 
   Function Handle( ) As IntPtr
      Return Handle_76(h)
   End Function

   '''  <summary> +++ comment for each</summary> 
   Sub Release()
      If h <> 0 Then
         Release_77(h)
         h = 0
      End If
   End Sub

   Public Shared Widening Operator CType(ByVal o As IntPtr) As Callback
   Return New Callback(o)
End Operator

Public Sub New(ByVal PassedHandle As IntPtr)
   h = PassedHandle
End Sub
End Class 

'''  <summary> Class for working with uCalc data types</summary> 
Public Class DataType

   '''  <summary> Handle for uCalc Data Type</summary> 
   Public h As IntPtr

   '''  <summary> Returns the size (in bytes) of one unit of data for this data type</summary> 
   Function ByteSize( ) As Int64
      Return ByteSize_78(h)
   End Function

   '''  <summary> Returns the index of the data type</summary> 
   '''  <remarks>
   '''  <para>The return value is a BuiltInTypesEnum enumerator value that represents the data type of the
   '''           current object.  For instance, if the data type is a string, the return value would be Type_String.
   '''  </para>
   '''  </remarks> 
   Function Index( ) As BuiltInTypesEnum
      Return Index_79(h)
   End Function

   '''  <summary> Returns the uCalc.Item handle of the data type</summary> 
   '''  <remarks>
   '''  <para>Each data type object can also be represented as a uCalc object by using this return value.</para>
   '''  </remarks> 
   Function Item( ) As Item
      Return Item_80(h)
   End Function

   '''  <summary> Returns the name of the data type</summary> 
   Function Name() As String
      Dim ReturnStrSize As IntPtr
      Dim ReturnString = Name_81(h, ReturnStrSize )
      Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
   End Function

   '''  <summary> Resets the value of data that was allocated with SetScalar to the default value of the given data type</summary> 
   '''  <param name="ValuePtr"> IntPtr of the uCalc array to be reset</param>
   '''  <param name="Size"> Number of elements to reset</param>
   '''  <remarks>
   '''  <para>Resets all the elements of the array to the default value for the given data type.  This should only
   '''           be used for arrays that were explicitly allocated with uCalc's AllocArray.
   '''           +++ Test this
   '''  </para>
   '''  </remarks> 
   Sub Reset( ByVal ValuePtr As IntPtr , ByVal Size As Int64)
      Reset_82(h, ValuePtr , Size)
   End Sub

   '''  <summary> Resets the value of data that was allocated with SetScalar to the default value of the given data type</summary> 
   '''  <param name="ValuePtr"> IntPtr of the uCalc scalar to be reset</param>
   '''  <remarks>
   '''  <para>
   '''            +++ Test this
   '''  </para>
   '''  </remarks> 
   Sub Reset( ByVal ValuePtr As IntPtr)
      Reset_83(h, ValuePtr)
   End Sub

   '''  <summary> Sets the value of an array at a given memory location that was allocated by AllocArray</summary> 
   '''  <param name="Destination"> IntPtr of array (base address) of which the element value is to be set</param>
   '''  <param name="Source"> IntPtr to a value of the same data type that will be copied to the element</param>
   '''  <param name="Index"> Index of the array element who's value needs to be set</param>
   '''  <remarks>
   '''  <para>
   '''           +++ Test this or remove
   '''  </para>
   '''  </remarks> 
   Sub SetArray( ByVal Destination As IntPtr , ByVal Source As IntPtr , ByVal Index As Int64)
      SetArray_84(h, Destination , Source , Index)
   End Sub

   '''  <summary> Sets the value of a scalar at a given memory location that was allocated by AllocScalar</summary> 
   '''  <param name="Destination"> IntPtr of scalar who's value is to be set</param>
   '''  <param name="Source"> IntPtr to a value of the same data type that will be copied to the element</param>
   '''  <remarks>
   '''  <para>
   '''           +++ Test this or remove
   '''  </para>
   '''  </remarks> 
   Sub SetScalar( ByVal Destination As IntPtr , ByVal Source As IntPtr)
      SetScalar_85(h, Destination , Source)
   End Sub

   '''  <summary> swaps the pointers of two variables that were allocated with AllocScalar or AllocArray</summary> 
   '''  <param name="ValuePtrA"> IntPtr of variable 1</param>
   '''  <param name="ValuePtrB"> IntPtr of variable 2</param>
   Sub SwapScalarValues( ByVal ValuePtrA As IntPtr , ByVal ValuePtrB As IntPtr)
      SwapScalarValues_86(h, ValuePtrA , ValuePtrB)
   End Sub

   '''  <summary> Retuns a string representing the value at the given address formatted for the given data type</summary> 
   '''  <param name="ValuePtr"> IntPtr of the data containing the value you want to display</param>
   '''  <remarks>
   '''  <para>If you have a IntPtr to data of the given type, you can display this data as a string with this function.  Special formatting
   '''           associated with a data type is used, if such formatting was defined.  For instance, if you're dealing with a Boolean, then
   '''           you might get: True, Yes, On, etc, depending on how the formatting was configured with Format.</para>
   '''  </remarks> 
   Shadows Function ToString(ByVal ValuePtr As IntPtr) As String
      Dim ReturnStrSize As IntPtr
      Dim ReturnString = ToString_87(h, ReturnStrSize , ValuePtr)
      Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
   End Function

   '''  <summary> Retuns a formatted string of the given data type representing the value that was passed as text</summary> 
   '''  <param name="Value"> String representing data of any type that is to be represented as data of the given type</param>
   '''  <remarks>
   '''  <para>If you pass a string, it will be converted to the given data type, and return using the formatting
   '''           for that data type.</para>
   '''  </remarks> 
   Shadows Function ToString(ByVal Value As String) As String
      Dim ReturnStrSize As IntPtr
      Dim ReturnString = ToString_88(h, ReturnStrSize , Value, Value.Length())
      Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
   End Function

   '''  <summary> ... +++ check optimization</summary>
   '''   <remarks>
   '''  <para>
   '''           ...
   '''  </para>
   '''  </remarks>

   '''  <summary> Returns the handle of an object</summary> 
   '''  <remarks>
   '''  <para>Mostly for internal use.  However, if you are iterating through a series of objects with NextOverload
   '''     (when applicable), you may check Handle() to see when it becomes NULL (or 0) to know when to stop.</para>
   '''  </remarks> 
   Function Handle( ) As IntPtr
      Return Handle_89(h)
   End Function

   '''  <summary> +++ comment for each</summary> 
   Sub Release()
      If h <> 0 Then
         Release_90(h)
         h = 0
      End If
   End Sub

   Public Shared Widening Operator CType(ByVal o As IntPtr) As DataType
   Return New DataType(o)
End Operator

Public Sub New(ByVal PassedHandle As IntPtr)
   h = PassedHandle
End Sub
End Class 

'''  <summary> uCalc transform class</summary> 
Public Class Transforms 
   Inherits Base

   '''  <summary> Handle for uCalc Transform instance</summary> 
   Public h As IntPtr

   '''  <summary> Defines a rule (for search, transform, or filter)</summary> 
   '''  <param name="Comment"> Documentation/help/comment/tooltip type info associated with the rule. See Comment.</param>
   '''  <param name="FindStr"> Pattern of text you want to match (The Find pattern in a search, or the From part in FromTo).</param>
   '''  <param name="ToStr"> Replacement string (text that the From part should be changed to)</param>
   '''  <param name="Min"> Soft minimum number of matches required.  See Min.</param>
   '''  <param name="Max"> Soft maximum number of matches allowed.  See Max.</param>
   '''  <param name="MinHard"> Hard minimum number of matches required. See MinHard</param>
   '''  <param name="MaxHard"> Hard maximum number of matches allowed.  See MaxHard</param>
   '''  <param name="Precedence"> Precedence level.  See Precedence.</param>
   '''  <param name="StartAfter"> Number of matches to skip before matches start counting. See StartAfter.</param>
   '''  <param name="StopAfter"> Number of matches to stop counting after.  See StopAfter.</param>
   '''  <param name="SkipOver"> Makes it skip over text that is a match.  See SkipOver.</param>
   '''  <param name="RewindOnChange"> Determines whether to rewind to the beginning of modified text and parse again</param>
   '''  <param name="CaseSensitive"> Case sensitivity.  See CaseSensitive.</param>
   '''  <param name="BracketSensitive"> Sets bracket sensitivity.  See BracketSensitive.</param>
   '''  <param name="QuoteSensitive"> Sets quote sensitivity.  See QuoteSensitive.</param>
   '''  <param name="RightToLeft"> Right to left</param>
   '''  <returns> Rule object that has just been defined</returns>
   '''  <remarks>
   '''  <para>
   '''     Defines a rule that contains a pattern used for finding text, along with a replacement string, and all the other properties.
   '''     This function represents an alternative way of defining a rule, by supplying all the properties in this one function call.  These
   '''     same properties can be called individually with separate functions.  Additional details for each property can be found in separate
   '''     topics for function calls related to each property.</para>
   '''  <para></para>
   '''  </remarks> 
   Function DefineRule( ByVal Comment As String , ByVal FindStr As String , ByVal ToStr As String , ByVal Min As Int64 , ByVal Max As Int64 , ByVal MinHard As Int64 , ByVal MaxHard As Int64 , ByVal Precedence As Int64 , ByVal StartAfter As Int64 , ByVal StopAfter As Int64 , ByVal SkipOver As Boolean , ByVal RewindOnChange As Boolean , ByVal CaseSensitive As Boolean , ByVal BracketSensitive As Boolean , ByVal QuoteSensitive As Boolean , ByVal RightToLeft As Boolean) As Rule
      Return DefineRule_91(h, Comment, Comment.Length() , FindStr, FindStr.Length() , ToStr, ToStr.Length() , Min , Max , MinHard , MaxHard , Precedence , StartAfter , StopAfter ,  Convert.ToInt32(SkipOver) ,  Convert.ToInt32(RewindOnChange) ,  Convert.ToInt32(CaseSensitive) ,  Convert.ToInt32(BracketSensitive) ,  Convert.ToInt32(QuoteSensitive) ,  Convert.ToInt32(RightToLeft))
   End Function

   '''  <summary> Defines a new token</summary> 
   '''  <param name="TokenDef"> Token definition</param>
   '''  <param name="TokenType"> The type of token</param>
   '''  <param name="CloseBracket"> String representing closing bracket, such as "}", ")", "]", etc.</param>
   '''  <param name="SubMatch"> Submatch</param>
   '''  <param name="RegExGrammar"> Type of RegEx grammar</param>
   '''  <returns> Token item</returns>
   '''  <remarks>
   '''  <para>
   '''     For details see Define (Transforms)
   '''  </para>
   '''  </remarks> 
   Function DefineToken( ByVal TokenDef As String , Optional ByVal TokenType As TokenEnum = TokenEnum.Generic, Optional ByVal CloseBracket As String = "", Optional ByVal SubMatch As Int64 = 0, Optional ByVal RegExGrammar As RegExGrammarEnum = RegExGrammarEnum.RegEx_Default) As Item
      Return DefineToken_92(h, TokenDef, TokenDef.Length() , TokenType, CloseBracket, CloseBracket.Length(), SubMatch, RegExGrammar)
   End Function

   '''  <summary> +++ Remove this</summary> 
   Sub RemoveToken( )
      RemoveToken_93(h)
   End Sub

   '''  <summary> Returns the Tokens object for the current transform</summary> 
   '''  <returns> Token list object</returns>
   '''  <remarks>
   '''  <para>
   '''     Returns the Tokens object, which consists of a list of tokens for the current transform.
   '''     You can use this to add, modify, delete, or reset the tokens.
   '''  </para>
   '''  </remarks> 
   Function Tokens( ) As Tokens
      Return Tokens_94(h)
   End Function

   '''  <summary> Defines a transform rule</summary> 
   '''  <param name="FromStr"> Pattern that describes the text to match</param>
   '''  <param name="ToStr"> New text that the match should be changed to</param>
   '''  <returns> Object for rule being defined</returns>
   '''  <remarks>
   '''  <para>Whenever a piece of text matches the pattern described in FromStr, it is replaced with the text
   '''     found in ToStr.
   '''  </para>
   '''  </remarks> 
   Function FromTo( ByVal FromStr As String , Optional ByVal ToStr As String = "") As Rule
      Return FromTo_95(h, FromStr, FromStr.Length() , ToStr, ToStr.Length())
   End Function

   '''  <summary> Sets the uCalc object that performs calculations related to the transform</summary> 
   '''  <param name="uCalcHandle"> Handle of a uCalc object 
   '''  <returns> uCalc object associated with current transform</returns>
   '''  <remarks>
   '''  <para>If your transform inovlves calcuations, then they will be performed using the
   '''     uCalc object the transform was defined in.  However, yoiu can change the uCalc object with this function.
   '''     Each uCalc object can have its own sets of variables, functions, and other definitions.
   '''     For instance when {@Eval: ...} is used in the pattern or ~Eval() in the text.
   '''  </para>
   '''  </remarks> 
   Function uCalc( ByVal uCalcHandle As IntPtr) As Transforms
      Return uCalc_96(h, uCalcHandle)
   End Function

   '''  <summary> Returns a new Pass object</summary> 
   '''  <param name="Share"> Share</param>
   '''  <returns> Transform object</returns>
   '''  <remarks>
   '''  <para>
   '''     It is possible to create a transform with multiple passes.  Each pass can have a different set of rules.  The transform
   '''     of each pass is executed in sequential order.  Passes can later be referenced later by index.  Calling NewPass the first
   '''     time returns the same as Pass(0), the next call to NewPass refers to Pass(1), etc.
   '''  </para>
   '''  </remarks> 
   Function NewPass( Optional ByVal Share As Boolean = False) As Transforms
      Return NewPass_97(h,  Convert.ToInt32(Share))
   End Function

   '''  <summary> Returns a new Pass object</summary> 
   '''  <param name="Index"> Index of pass to select</param>
   '''  <param name="Share"> Share</param>
   '''  <returns> Transform object</returns>
   '''  <remarks>
   '''  <para>
   '''     It is possible to create a transform with multiple passes.  Each pass can have a different set of rules.  Each pass
   '''     is transformed in sequential order, starting with Pass(0).  A pass consists of a transform.
   '''  </para>
   '''  </remarks> 
   Function Pass( ByVal Index As Int64 , Optional ByVal Share As Boolean = False) As Transforms
      Return Pass_98(h, Index ,  Convert.ToInt32(Share))
   End Function

   '''  <summary> Resets the transform object</summary> 
   '''  <param name="ResetOption"> Reset option</param>
   '''  <returns> Current transform object</returns>
   '''  <remarks>
   '''  <para>This clears the input string, transform rules, token definitions, Results.  It also resets properties to default settings
   '''  </para>
   '''  </remarks> 
   Function Reset( Optional ByVal ResetOption As TransformResetEnum = TransformResetEnum.Reset_All) As Transforms
      Return Reset_99(h, ResetOption)
   End Function

   '''  <summary> Performs the transformation of text</summary> 
   '''  <returns> The current transform object</returns>
   '''  <remarks>
   '''  <para>Once all the rules and parameters are set, you can call this function in order to
   '''     perform the text transformation.</para>
   '''  <para>   Prior to calling Transform, you must set the text to be transformed, with Str
   '''  </para>
   '''  </remarks> 
   Function Transform( ) As Transforms
      Return Transform_100(h)
   End Function

   '''  <summary> Transforms an expression in one quick step</summary> 
   '''  <param name="expression"> Expression to be transformed</param>
   '''  <returns> String result of transform</returns>
   '''  <remarks>
   '''  <para>
   '''     When you would like to set text to be transformed, and transform the text, and return a result, all in one step,
   '''     you can use this function, instead of calling Str, then Transform, then Str.
   '''  </para>
   '''  </remarks> 
   Function Transform(ByVal expression As String) As String
      Dim ReturnStrSize As IntPtr
      Dim ReturnString = Transform_101(h, ReturnStrSize , expression, expression.Length())
      Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
   End Function

   '''  <summary> Returns each step leading to an expression expansion</summary> 
   '''  <param name="expression"> Expression to be transformed +++ See Transform_</param>
   '''  <returns> String list containg steps leading up to transform result</returns>
   '''  <remarks>
   '''  <para>
   '''     Transforms an expression and returns intermediate steps
   '''  </para>
   '''  </remarks> 
   Function TransformWithSteps( ByVal expression As String) As String_
      Return TransformWithSteps_102(h, expression, expression.Length())
   End Function

   '''  <summary> Returns string result of transformed text</summary> 
   '''  <returns> String result of transformed text</returns>
   '''  <remarks>
   '''  <para>After performing a text transformation, you may obtain the transformed result with this
   '''     function
   '''  </para>
   '''  </remarks> 
   Function Str() As String
      Dim ReturnStrSize As IntPtr
      Dim ReturnString = Str_103(h, ReturnStrSize )
      Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
   End Function

   '''  <summary> Sets the text input that is to be transformed</summary> 
   '''  <param name="InputStr"> Text that mast be parsed and modified</param>
   '''  <returns> Current transform object</returns>
   '''  <remarks>
   '''  <para>The text that you want to transform should be passed to this function.
   '''  </para>
   '''  </remarks> 
   Function Str( ByVal InputStr As String) As Transforms
      Return Str_104(h, InputStr, InputStr.Length())
   End Function

   '''  <summary> Returns actual char porsing of data</summary> 
   '''  <returns> ... +++ test this; maybe with null-imbedded string</returns>
   '''  <remarks>
   '''  <para>
   '''     ... 
   '''  </para>
   '''  </remarks> 
   Function StrData( ) As String
      Return StrData_105(h)
   End Function

   '''  <summary> ...</summary> 
   '''  <returns> ...</returns>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function StrLength( ) As Int64
      Return StrLength_106(h)
   End Function

   '''  <summary> Sets the index base used in various functions+++</summary> 
   '''  <param name="BaseValue"> value representing index of 1st element</param>
   '''  <remarks>
   '''  <para>
   '''     By default, uCalc String Library functions use a 0-based index.  So the first element is 0 (not 1), followed by 2, 3, 4 etc.
   '''     Use this if you prefer to start by 1 or another non-zero value.  This value is passed on to string objects derived from a parent string.
   '''     Each string may have a different index base.
   '''  </para>
   '''  </remarks> 
   Function IndexBase( ByVal BaseValue As Int64) As Transforms
      Return IndexBase_107(h, BaseValue)
   End Function

   '''  <summary> Gets the index base used in various functions+++</summary> 
   '''  <remarks>
   '''  <para>
   '''     By default, uCalc String Library functions use a 0-based index.  So the first element is 0 (not 1), followed by 2, 3, 4 etc.
   '''     Use this to check to see which base is being used.
   '''  </para>
   '''  </remarks> 
   Function IndexBase( ) As Int64
      Return IndexBase_108(h)
   End Function

   '''  <summary> Indicates whether text was modified in the most recent Transform operation</summary> 
   '''  <returns> True if text was modified in the most recent transformation operation or False otherwise</returns>
   '''  <remarks>
   '''  <para>
   '''     +++ Maybe rename IsModified; and have one that Sets the value; or maybe IsProperty for this & others.
   '''     If text was modified after a call to Transform, then this function returns True.  When transforming large amounts of text,
   '''     transferring strings back and forth with ReturnStr() can be expensive.  Checking this property allows you to skip unnecessary
   '''     steps when text has not been modified.
   '''  </para>
   '''  </remarks> 
   Function WasModified( ) As Boolean
      Return WasModified_109(h)
   End Function

   '''  <summary> Returns the defaults settings for rules</summary> 
   '''  <returns> Default rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     Each FromTo or Find rule has many configurable properties that can be set.  Instead of excplicitely setting all of these many properties
   '''     with each rule definition, you may define default settings that will automatically be assigned to new rules.  Any of these default settings
   '''     can be overridden by explicitely setting the desired property for a given rule.
   '''  </para>
   '''  </remarks> 
   Function RulesDefault( ) As Rule
      Return RulesDefault_110(h)
   End Function

   '''  <summary> Returns the overall settings for a transform</summary> 
   '''  <returns> Overall rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This returns an object containing the properties for a transform or search object.  This object is a Rules object, and conatains the
   '''     same properties listed for individual rules, but works in a slightly different context.  For instance, if you set the StopAfter property
   '''     of FromTo("a", "b") to 5, then it will only change the first five occurences of "a" to "b", whereas if you set the RulesOverall StopAfter
   '''     property to 5, and you have rules FromTo("a", "b") and FromTo("x", "y") then it will stop changing any occurence of either rule, after the
   '''     combined total of changes reaches 5; "a" might change to "b" 2 times and "x" to "y" 3 times, or whichever combination does not total more
   '''     than 5.  You might set QuoteSensitive to "true" overall, while you may set it to False within a given rule.  In certain combinations,
   '''     overall rules may clash with individual rules.  Although all combinations are allowed, not all combinations make sense.  When setting
   '''     the case sensitivity property of individual rules differently from the overall property, keep in mind that if the overall case sensitivity
   '''     is False, then all symbols are stored in the symbol table in all upper case.
   '''  </para>
   '''  </remarks> 
   Function RulesOverall( ) As Rule
      Return RulesOverall_111(h)
   End Function

   '''  <summary> Returns a rule object from a transform</summary> 
   '''  <param name="Index"> Index of rule</param>
   '''  <returns> Rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     The default rule is located at index -1.  All subsequent rules inherent properties from the default rule.</para>
   '''  <para>   If no argument is passed, then Rule returns the next empty new rule in the list.
   '''  </para>
   '''  </remarks> 
   Function Rule( Optional ByVal Index As Int64 = 0) As Rule
      Return Rule_112(h, Index)
   End Function

   '''  <summary> Returns the handle of an object</summary> 
   '''  <remarks>
   '''  <para>Mostly for internal use.  However, if you are iterating through a series of objects with NextOverload
   '''     (when applicable), you may check Handle() to see when it becomes NULL (or 0) to know when to stop.</para>
   '''  </remarks> 
   Function Handle( ) As IntPtr
      Return Handle_113(h)
   End Function

   '''  <summary> +++ comment for each</summary> 
   Sub Release()
      If h <> 0 Then
         Release_114(h)
         h = 0
      End If
   End Sub

   Public Shared Widening Operator CType(ByVal o As IntPtr) As Transforms
   Return New Transforms(o)
End Operator

Public Sub New(ByVal PassedHandle As IntPtr)
   h = PassedHandle
   hb = h
End Sub
End Class 

'''  <summary> Class for rules</summary> 
Public Class Rule 
   Inherits Base

   '''  <summary> Handle for Rule</summary> 
   Public h As IntPtr

   '''  <summary> Sets whether a rule is active</summary> 
   '''  <param name="TrueFalse"> Value that determines case is active</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets whether a rule is active or not.
   '''     When you no longer need a rule, you can release it entirely from memory with Release().  However, at times you may
   '''     want to only temporarily deactivate a transform, and then later reactivate it for further use.  That is when you use
   '''     this function.
   '''  </para>
   '''  </remarks> 
   Function Active( ByVal TrueFalse As Boolean) As Rule
      Return Active_115(h,  Convert.ToInt32(TrueFalse))
   End Function

   '''  <summary> Sets Find part of a rule in a search</summary> 
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets the Find part of a rule in a search.
   '''  </para>
   '''  </remarks> 
   Function FindPart() As String
      Dim ReturnStrSize As IntPtr
      Dim ReturnString = FindPart_116(h, ReturnStrSize )
      Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
   End Function

   '''  <summary> Sets Find part of a rule in a search</summary> 
   '''  <param name="Pattern"> Pattern for the Find part of a rule</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets the Find part of a rule in a search.
   '''  </para>
   '''  </remarks> 
   Function FindPart( ByVal Pattern As String) As Rule
      Return FindPart_117(h, Pattern, Pattern.Length())
   End Function

   '''  <summary> Sets Find part of a rule in a search</summary> 
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets the Find part of a rule in a search.
   '''  </para>
   '''  </remarks> 
   Function FromPart() As String
      Dim ReturnStrSize As IntPtr
      Dim ReturnString = FromPart_118(h, ReturnStrSize )
      Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
   End Function

   '''  <summary> Sets From part of a rule</summary> 
   '''  <param name="Pattern"> Pattern for the From part of a rule</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets the From part of a rule.
   '''  </para>
   '''  </remarks> 
   Function FromPart( ByVal Pattern As String) As Rule
      Return FromPart_119(h, Pattern, Pattern.Length())
   End Function

   '''  <summary> Sets To part of a rule</summary> 
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets the To part of a rule.
   '''  </para>
   '''  </remarks> 
   Function ToPart() As String
      Dim ReturnStrSize As IntPtr
      Dim ReturnString = ToPart_120(h, ReturnStrSize )
      Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
   End Function

   '''  <summary> Sets To part of a rule</summary> 
   '''  <param name="Pattern"> Pattern for the From part of a rule</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets the To part of a rule.
   '''  </para>
   '''  </remarks> 
   Function ToPart( ByVal Pattern As String) As Rule
      Return ToPart_121(h, Pattern, Pattern.Length())
   End Function

   '''  <summary> Sets whether a rule is case-sensitive</summary> 
   '''  <param name="TrueFalse"> Value that determines case sensitivity</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>This sets whether a rule is case-sensitive or not.
   '''     +++ Maybe IsProperty() for this and others
   '''  </para>
   '''  </remarks> 
   Function CaseSensitive( ByVal TrueFalse As Boolean) As Rule
      Return CaseSensitive_122(h,  Convert.ToInt32(TrueFalse))
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="TrueFalse"> ...</param>
   '''  <returns> ...</returns>
   '''  <remarks>
   '''  <para>...
   '''  </para>
   '''  </remarks> 
   Function IgnoreInnerPatterns( ByVal TrueFalse As Boolean) As Rule
      Return IgnoreInnerPatterns_123(h,  Convert.ToInt32(TrueFalse))
   End Function

   '''  <summary> Sets whether a rule is whitespace-sensitive</summary> 
   '''  <param name="TrueFalse"> Value that determines whitespace sensitivity</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>This sets whether a rule is whitespace-sensitive or not.
   '''  </para>
   '''  </remarks> 
   Function WhitespaceSensitive( ByVal TrueFalse As Boolean) As Rule
      Return WhitespaceSensitive_124(h,  Convert.ToInt32(TrueFalse))
   End Function

   '''  <summary> Sets bracket sensitivity</summary> 
   '''  <param name="TrueFalse"> Value that determines bracket sensitivity</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>This sets whether a rule is bracket sensitive or not.  When set to True, a pattern will not match if it crosses the boundaries of
   '''     a bracket grouping.</para>
   '''  <para>   If set to False, then clode block delimiters are treated as ordinary generic tokens, with no special property as delimiters.</para>
   '''  <para>   A bracketed group is a pattern enclosed between tokens defined as a bracket pair.  By default square brackets, [],
   '''     parenthesis, (), and curly braces, {}, are defined as bracket pairs.  However, any string pairs can be defined as
   '''     bracket tokens.</para>
   '''  <para>   So, if you define a pattern "a {etc} b", it will match "a x y z b c", "a (x y z) b c", "a (x) (y z) b c", but not "a x y z (b c)",
   '''     because the bracket grouping (b c) crosses the boundary of the "a {etc} b" pattern; the opening parenthesis is found in the would-be match,
   '''     but the closing parenthesis is beyond it, whereas in the other examples, the both opening and closing parenthesis (when present) are
   '''     fully within "a {etc} b".</para>
   '''  <para>   Note: Brackets used in pattern definitions take precedence over bracket token pairs.  Therefore you may define a pattern that gives
   '''     brackets a different behavior than the default.
   '''  </para>
   '''  </remarks> 
   Function BracketSensitive( ByVal TrueFalse As Boolean) As Rule
      Return BracketSensitive_125(h,  Convert.ToInt32(TrueFalse))
   End Function

   '''  <summary> Returns a local transform object</summary> 
   '''  <param name="t"> ...</param>
   '''  <returns> Local transform object</returns>
   '''  <remarks>
   '''  <para>
   '''     When a pattern is matched, you can zoom into the text and perform a local search just within the matched text, independantly
   '''     from the rest of the text outside of the match.  Among various possible uses, it's ideal for parsing escape characters within quotes.
   '''     Such characters are treated differently within the quote than outside the quote.
   '''  </para>
   '''  </remarks> 
   Function LocalTransform( Optional ByVal t As Transforms = Nothing) As Transforms
      Return LocalTransform_126(h, If(t Is Nothing, Nothing, t.h))
   End Function

   '''  <summary> ...</summary> 
   '''  <returns> ...</returns>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function Maximum( ) As Int64
      Return Maximum_127(h)
   End Function

   '''  <summary> Sets the soft maximum number of matches of this rule allowed</summary> 
   '''  <param name="Value"> Maximum number of matches of this rule allowed</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets the soft maximum number of individual matches that this rule should find in order for any matches
   '''     of this rule to count.  If more than this number of matches are found in the text, then none of the
   '''     matches in this rule will count.  For instance if a rule searches for matches of "a" in "a a r d v a r k",
   '''     and the maximum is set to 2, then no matches of "a" will be counted at all, because there are more than
   '''     2 occurences of "a" in the text.  On the other hand, if Max is set to 3 or 4 or any larger value, then
   '''     all the matches would count.</para>
   '''  <para>   The default Maximum value is -1, which is the equivalent of no maximum limit.</para>
   '''  <para>   If you want to stop counting after a given number of matches of a rule, without invalidating the matches
   '''     that were already found, use StopAfter instead.
   '''  </para>
   '''  </remarks> 
   Function Maximum( ByVal Value As Int64) As Rule
      Return Maximum_128(h, Value)
   End Function

   '''  <summary> Sets the hard maximum number of matches of this rule allowed</summary> 
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function MaximumHard( ) As Int64
      Return MaximumHard_129(h)
   End Function

   '''  <summary> Sets the hard maximum number of matches of this rule allowed</summary> 
   '''  <param name="Value"> Maximum number of matches of this rule allowed</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets the maximum number of individual matches that this rule should find in order for any matches
   '''     of this rule to count.  If more than this number of matches are found in the text, then no matches from
   '''     any rule will count (whereas in a soft maximum, only matches from the current rule will be cancelled).
   '''     For instance if a rule searches for matches of "a" in "a a r d v a r k",
   '''     and the maximum is set to 2, then no matches of "a" will be counted at all, because there are more than
   '''     2 occurences of "a" in the text.  On the other hand, if Max is set to 3 or 4 or any larger value, then
   '''     all the matches would count.</para>
   '''  <para>   The default Maximum value is -1, which is the equivalent of no maximum limit.</para>
   '''  <para>   If you want to stop counting after a given number of matches of a rule, without invalidating the matches
   '''     that were already found, use StopAfter instead.
   '''  </para>
   '''  </remarks> 
   Function MaximumHard( ByVal Value As Int64) As Rule
      Return MaximumHard_130(h, Value)
   End Function

   '''  <summary> Sets the soft minimum number of matches that must be found in this rule</summary> 
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function Minimum( ) As Int64
      Return Minimum_131(h)
   End Function

   '''  <summary> Sets the soft minimum number of matches that must be found in this rule</summary> 
   '''  <param name="Value"> Minimum number of matches required of this rule</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets the soft minimum number of individual matches that this rule should find.</para>
   '''  <para>   A soft minum (this one) differs from a hard minum (MinimumHard) in that if the soft minimum is not
   '''     reached, then it is considered that there are no matches for this particular rule.  Other rules
   '''     are not affected.  Whereas in a hard minimum, if this rule does not reach the required minimum,
   '''     then the entire search or transform is invalidated, and it's considered that no match of any
   '''     kind is found.</para>
   '''  <para>   If less than this number of matches are found in the text, then none of the
   '''     matches in this rule will count.  For instance if a rule searches for matches of "a" in "a a r d v a r k",
   '''     and the minimum is set to 5, then no matches of "a" will be counted at all, because there are not at least
   '''     5 occurences of "a" in the text.  On the other hand, if Min is set to 3 or less, then all the matches count.</para>
   '''  <para>   Default: 0.
   '''  </para>
   '''  </remarks> 
   Function Minimum( ByVal Value As Int64) As Rule
      Return Minimum_132(h, Value)
   End Function

   '''  <summary> ...</summary> 
   '''  <returns> ...</returns>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function MinimumHard( ) As Int64
      Return MinimumHard_133(h)
   End Function

   '''  <summary> Sets the soft minimum number of matches that must be found in this rule</summary> 
   '''  <param name="Value"> Minimum number of matches required of this rule</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets the soft minimum number of individual matches that this rule should find.</para>
   '''  <para>   A soft minum (this one) differs from a hard minum (MinimumHard) in that if the soft minimum is not
   '''     reached, then it is considered that there are no matches for this particular rule.  Other rules
   '''     are not affected.  Whereas in a hard minimum, if this rule does not reach the required minimum,
   '''     then the entire search or transform is invalidated, and it's considered that no match of any
   '''     kind is found.</para>
   '''  <para>   If less than this number of matches are found in the text, then none of the
   '''     matches in this rule will count.  For instance if a rule searches for matches of "a" in "a a r d v a r k",
   '''     and the minimum is set to 5, then no matches of "a" will be counted at all, because there are not at least
   '''     5 occurences of "a" in the text.  On the other hand, if Min is set to 3 or less, then all the matches count.</para>
   '''  <para>   Default: 0.
   '''  </para>
   '''  </remarks> 
   Function MinimumHard( ByVal Value As Int64) As Rule
      Return MinimumHard_134(h, Value)
   End Function

   '''  <summary> Sets the precedence level for a pattern</summary> 
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function Precedence( ) As Int64
      Return Precedence_135(h)
   End Function

   '''  <summary> Sets the precedence level for a pattern</summary> 
   '''  <param name="Value"> Precedence level</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     Patterns that start (and/or end) with a pattern variable instead of a token or identifier can
   '''     (and probably should) be assigned a precedence level.  You can choose any arbitrary numerical
   '''     value.  The meaning of the precedence level depends on whether the value is greater, equal, or
   '''     less than adjacent patterns with a precedence level.  It works similarly to precedence levels for
   '''     operators.  For instance, if you define:</para>
   '''  <para>   FromTo("{a} + {b}", "({a} + {b})").Precedence(10);
   '''     FromTo("{a} * {b}", "({a} * {b})").Precedence(20);</para>
   '''  <para>   Then</para>
   '''  <para>   "1 + 2 * 3 + 4" transforms into "(1 + (2 * 3) + 4)"
   '''     "1 * 2 + 3 * 4" transforms into "(1 * 2) + (3 * 4)"
   '''  </para>
   '''  </remarks> 
   Function Precedence( ByVal Value As Int64) As Rule
      Return Precedence_136(h, Value)
   End Function

   '''  <param name="SelectedProperty"> ...</param>
   '''  <param name="TrueFalse"> ...</param>
   Function Property_( ByVal SelectedProperty As ItemIsEnum , ByVal TrueFalse As Boolean) As Rule
      Return Property_137(h, SelectedProperty ,  Convert.ToInt32(TrueFalse))
   End Function

   '''  <summary> Sets quote sensitivity</summary> 
   '''  <param name="TrueFalse"> Value that determines quote sensitivity</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>This sets whether a rule is quote sensitive or not.
   '''     Quote sensitivity is generally designed for use across all rules in a transform (or sub transform).  However,
   '''     it can also be set in for the context of an individual pattern.  [One exception is within text that matches a pattern variable.+++]</para>
   '''  <para>   When set to True, it means that a block of text within quotes is treated as one token.  As such patterns are not searched for
   '''     within the quotes.  The contents of the quotes are skipped over.  You may still get around this and parse within quotes when
   '''     necessary, by capturing the quote character itself, then parsing subsequent text.</para>
   '''  <para>   The actual character(s) used as quotes are configurable with DefineToken.
   '''  </para>
   '''  </remarks> 
   Function QuoteSensitive( ByVal TrueFalse As Boolean) As Rule
      Return QuoteSensitive_138(h,  Convert.ToInt32(TrueFalse))
   End Function

   '''  <summary> Returns the replacement text of a FromTo rule</summary> 
   '''  <returns> String representing the second argument that was used in FromTo</returns>
   '''  <remarks>
   '''  <para>This allows you to keep track of the replacement text of any given rule, even after it has been defined.</para>
   '''  </remarks> 
   Function ReplacementText() As String
      Dim ReturnStrSize As IntPtr
      Dim ReturnString = ReplacementText_139(h, ReturnStrSize )
      Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
   End Function

   '''  <summary> Sets the number of matches this rule must find before matches start counting</summary> 
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function StartAfter( ) As Int64
      Return StartAfter_140(h)
   End Function

   '''  <summary> Sets the number of matches this rule must find before matches start counting</summary> 
   '''  <param name="Value"> Number of matches that must be found before matches start counting</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets a number of individual matches that this rule should find first.  These first few matches are
   '''     not counted in the results.  Onlny matches starting after this number of initial matches are counted.
   '''     If less than this number of matches are found in the text, no match will count.  For instance if a rule
   '''     searches for matches of "a" in "a a r d v a r k", starting after 2, then only the 3rd "a" (the one between
   '''     "v" and "r") will count.  If StartAfter is set to 3, there will be no matches.  If StartAfter is 1, then
   '''     then the 2nd and 3rd occurences of "a" will count as matches.</para>
   '''  <para>   The default StartAfter value is 0.  This means all matches that are found will count.
   '''  </para>
   '''  </remarks> 
   Function StartAfter( ByVal Value As Int64) As Rule
      Return StartAfter_141(h, Value)
   End Function

   '''  <summary> Sets the number of matches after which this rule should stop finding matches</summary> 
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function StopAfter( ) As Int64
      Return StopAfter_142(h)
   End Function

   '''  <summary> Sets the number of matches after which this rule should stop finding matches</summary> 
   '''  <param name="Value"> Number of matches after which it should stop finding matches</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>
   '''     This sets a number of individual matches that this rule should find.  After this number of matches
   '''     are found, all other matches for this rule are ignored.  For instance if a rule searches for matches
   '''     of "a" in "a a r d v a r k", and stops after 2, then only the first two letters here wil match; the
   '''     third "a" (the one between "v" and "r") will not count as a match.</para>
   '''  <para>   The default StopAfter value is -1, which means it will not stop counting matches for this rule.</para>
   '''  <para>   This function has some similarities with Max.  However, with Max, if the maximum value is not attained,
   '''     none of the matches will count.
   '''  </para>
   '''  </remarks> 
   Function StopAfter( ByVal Value As Int64) As Rule
      Return StopAfter_143(h, Value)
   End Function

   '''  <summary> Determines whether a given match is skipped over</summary> 
   '''  <param name="TrueFalse"> Value that determines with match is skipped over</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>If SkipOver is set to True, then text that matches this pattern will be skipped over.
   '''     This is useful for preventing uCalc from searching for matches of any other rules within
   '''     certain text you want to skip over.</para>
   '''  <para>   For instance if you skip over "({etc})", then everything in parenthesis will be skipped over.
   '''     So if you want to find occurences of "a" in "a b c (a b c a b c) a b c", it will find all occurences
   '''     of "a", except those within parenthesis, because everything in parenthesis is being skipped over.</para>
   '''  <para>   Default: False
   '''  </para>
   '''  </remarks> 
   Function SkipOver( ByVal TrueFalse As Boolean) As Rule
      Return SkipOver_144(h,  Convert.ToInt32(TrueFalse))
   End Function

   '''  <summary> Determines whether to rewind back to the start of modified text for further parsing</summary> 
   '''  <param name="TrueFalse"> Value that determines if parser should rewind and parse again after a change</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>After text is modified with the replacement text of a rule, if this value is False (default),
   '''     then uCalc will continue parsing from the position just after the insertion of the modified text.
   '''     If this property is set to True, then the parser will rewind to the location where the match was
   '''     found, and parse again, which will allow it to potentially find additional matches (of any rule,
   '''     not just the current one) within the already modified text.</para>
   '''  <para>   This property can be extremely useful in many situations.  However, special care should be taken
   '''     so that an infinite reparsing session doesn't take place.  For instance, if a rule changes A to B,
   '''     and another rule changes B to A, and this property is set ot True, and a Maximum value is not set,
   '''     and there is an occurence of A, then A will change to B.  B will be parsed again and changed to A.
   '''     The cycle will repeat itself indefinitely.</para>
   '''  <para>   Default: False
   '''  </para>
   '''  </remarks> 
   Function RewindOnChange( ByVal TrueFalse As Boolean) As Rule
      Return RewindOnChange_145(h,  Convert.ToInt32(TrueFalse))
   End Function

   '''  <summary> Sets whether a rule is case-sensitive</summary> 
   '''  <param name="TrueFalse"> Value that determines case sensitivity</param>
   '''  <returns> The current rule object</returns>
   '''  <remarks>
   '''  <para>This sets whether a rule is case sensitive or not.
   '''  </para>
   '''  </remarks> 
   Function RightToLeft( ByVal TrueFalse As Boolean) As Rule
      Return RightToLeft_146(h,  Convert.ToInt32(TrueFalse))
   End Function

   '''  <summary> Returns the handle of an object</summary> 
   '''  <remarks>
   '''  <para>Mostly for internal use.  However, if you are iterating through a series of objects with NextOverload
   '''     (when applicable), you may check Handle() to see when it becomes NULL (or 0) to know when to stop.</para>
   '''  </remarks> 
   Function Handle( ) As IntPtr
      Return Handle_147(h)
   End Function

   '''  <summary> +++ comment for each</summary> 
   Sub Release()
      If h <> 0 Then
         Release_148(h)
         h = 0
      End If
   End Sub

   Public Shared Widening Operator CType(ByVal o As IntPtr) As Rule
   Return New Rule(o)
End Operator

Public Sub New(ByVal PassedHandle As IntPtr)
   h = PassedHandle
   hb = h
End Sub
End Class 

'''  <summary> Class for collection of tokens</summary> 
Public Class Tokens 
   Inherits Base

   '''  <summary> Handle for tokens</summary> 
   Public h As IntPtr

   '''  <summary> Imports tokens from another token list</summary> 
   '''  <param name="FromTokenList"> Token list to import +++ BYREF IntPtr(Tokens) ; +++ 2nd arg for Append</param>
   '''  <returns> Object containing list of tokens</returns>
   '''  <remarks>
   '''  <para>
   '''     Instead of defining a set of tokens each time, you may import a pre-existing token list.  This function imports from
   '''     another token list object.  To import from a file, use Import (File).
   '''  </para>
   '''  </remarks> 
   Function Import( ByVal FromTokenList As IntPtr) As Tokens
      Return Import_149(h, FromTokenList)
   End Function

   '''  <summary> Defines a new token</summary> 
   '''  <param name="TokenDef"> Token definition</param>
   '''  <param name="TokenType"> The type of token</param>
   '''  <param name="CloseBracket"> String representing closing bracket, such as "}", ")", "]", etc.</param>
   '''  <param name="SubMatch"> Submatch</param>
   '''  <param name="RegExGrammar"> Type of RegEx grammar</param>
   '''  <returns> Token item object</returns>
   '''  <remarks>
   '''  <para>
   '''     uCalc comes with a default set of tokens.  These are general tokens for things like numbers alphanumeric words, whitespace, quotes,
   '''     parenthesis, etc.  However you may define your own tokens to the exact specifications that you need.</para>
   '''  <para>   A token is defined using a Regular Expression.</para>
   '''  <para>   A token type can be any of those listed under TokenEnum (except for None).</para>
   '''  <para>   Bracket tokens (such as parenthesis, square brackets, or curly braces) are typically defined as pairs.  So if "(", ")"
   '''     are defined as a token pair, then CloseBracket would be ")".</para>
   '''  <para>   In cases where you want a submatch within the token, and not the whole token, use the SubMatch argument with a numerical
   '''     value represent the numerical index used in the regular expression.
   '''  </para>
   '''  </remarks> 
   Function Define( ByVal TokenDef As String , Optional ByVal TokenType As TokenEnum = TokenEnum.Generic, Optional ByVal CloseBracket As String = "", Optional ByVal SubMatch As Int64 = 0, Optional ByVal RegExGrammar As RegExGrammarEnum = RegExGrammarEnum.RegEx_Default) As Item
      Return Define_150(h, TokenDef, TokenDef.Length() , TokenType, CloseBracket, CloseBracket.Length(), SubMatch, RegExGrammar)
   End Function

   '''  <summary> Returns the handle of an object</summary> 
   '''  <remarks>
   '''  <para>Mostly for internal use.  However, if you are iterating through a series of objects with NextOverload
   '''     (when applicable), you may check Handle() to see when it becomes NULL (or 0) to know when to stop.</para>
   '''  </remarks> 
   Function Handle( ) As IntPtr
      Return Handle_151(h)
   End Function

   '''  <summary> +++ comment for each</summary> 
   Sub Release()
      If h <> 0 Then
         Release_152(h)
         h = 0
      End If
   End Sub

   Public Shared Widening Operator CType(ByVal o As IntPtr) As Tokens
   Return New Tokens(o)
End Operator

Public Sub New(ByVal PassedHandle As IntPtr)
   h = PassedHandle
   hb = h
End Sub
End Class 

'''  <summary> uCalc string library class</summary> 
Public Class String_

   '''  <summary> Handle for uCalc String Library instance</summary> 
   Public h As IntPtr

   '''  <summary> ...</summary> 
   '''  <param name="StartIndex"> ...</param>
   '''  <param name="Count"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function TokenCharLen( ByVal StartIndex As Int64 , Optional ByVal Count As Int64 = 1) As Int64
      Return TokenCharLen_153(h, StartIndex , Count)
   End Function

   '''  <summary> Returns the numbers of tokens in the string</summary> 
   '''  <param name="Index"> Index of match+++</param>
   '''  <remarks>
   '''  <para>
   '''     This returns the number of tokens that are found in the string;
   '''  </para>
   '''  </remarks> 
   Function TokenCount( Optional ByVal Index As Int64 = -1) As Int64
      Return TokenCount_154(h, Index)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Index"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function TokenType( ByVal Index As Int64) As TokenEnum
      Return TokenType_155(h, Index)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="OtherString"> ...</param>
   '''  <param name="IndexA"> ...</param>
   '''  <param name="IndexB"> ...</param>
   '''  <param name="Length"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function Compare( ByVal OtherString As String , Optional ByVal IndexA As Int64 = 0, Optional ByVal IndexB As Int64 = 0, Optional ByVal Length As Int64 = -1) As uCalcCompareEnum
      Return Compare_156(h, OtherString, OtherString.Length() , IndexA, IndexB, Length)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Index"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function TokenIndexAtChar( ByVal Index As Int64) As Int64
      Return TokenIndexAtChar_157(h, Index)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="expression"> ...</param>
   '''  <param name="Variable"> Name of variable</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function Apply( ByVal expression As String , Optional ByVal Variable As String = "") As String_
      Return Apply_158(h, expression, expression.Length() , Variable, Variable.Length())
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Index"> ..</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function At( ByVal Index As Int64) As String_
      Return At_159(h, Index)
   End Function

   '''  <summary> +++
   '''  <param name="Index"> Index of charactor location</param>
   '''  <returns> Object</returns>
   '''  <remarks>
   '''  <para>
   '''     ToDo
   '''  </para>
   '''  </remarks> 
   Function AtChar( ByVal Index As Int64) As String_
      Return AtChar_160(h, Index)
   End Function

   '''  <summary> +++</summary> 
   '''  <param name="Index"> Index of token location</param>
   '''  <returns> Object</returns>
   '''  <remarks>
   '''  <para>
   '''     ToDo
   '''  </para>
   '''  </remarks> 
   Function AtToken( ByVal Index As Int64) As String_
      Return AtToken_161(h, Index)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Index"> ..</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function BracketMatch( ByVal Index As Int64) As String_
      Return BracketMatch_162(h, Index)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Index"> ..</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function BracketedText( ByVal Index As Int64) As String_
      Return BracketedText_163(h, Index)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Index"> ..</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function BracketedTextInside( ByVal Index As Int64) As String_
      Return BracketedTextInside_164(h, Index)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Index"> ..</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function BracketMatchTokenIndex( ByVal Index As Int64) As Int64
      Return BracketMatchTokenIndex_165(h, Index)
   End Function

   '''  <summary>...</summary> 
   '''  <param name="Nth"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     +++
   '''  </para>
   '''  </remarks> 
   Function CharPos( Optional ByVal Nth As Int64 = -1) As Int64
      Return CharPos_166(h, Nth)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Nth"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function CharCount( Optional ByVal Nth As Int64 = -1) As Int64
      Return CharCount_167(h, Nth)
   End Function

   '''  <summary> Returns the numbers of tokens in the string</summary> 
   '''  <param name="Nth"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     This returns the number of tokens that are found in the string;
   '''  </para>
   '''  </remarks> 
   Function TokenPos( Optional ByVal Nth As Int64 = -1) As Int64
      Return TokenPos_168(h, Nth)
   End Function

   '''  <summary> Returns the character position of a token</summary> 
   '''  <param name="Index"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     This returns the number of tokens that are found in the string;
   '''  </para>
   '''  </remarks> 
   Function TokenCharPos( ByVal Index As Int64) As Int64
      Return TokenCharPos_169(h, Index)
   End Function

   '''  <summary> Retrieves the string value of a uCalc String object</summary> 
   '''  <param name="Nth"> Index of match</param>
   '''  <param name="TokenCount"> Number of tokens</param>
   '''  <returns> String value of the uCalc String object</returns>
   '''  <remarks>
   '''  <para>
   '''     This retrieves the string value associated with a uCalc String object.
   '''     +++ This is optional unless you are retrieving the index of a match.
   '''     Use Str(n) when you just want the string representation of a value.
   '''     Use Match(n) when you want uCalc String Object that you can manipulate further.
   '''  </para>
   '''  </remarks> 
   Function Str(Optional ByVal Nth As Int64 = -1, Optional ByVal TokenCount As Int64 = 1) As String
      Dim ReturnStrSize As IntPtr
      Dim ReturnString = Str_170(h, ReturnStrSize , Nth, TokenCount)
      Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
   End Function

   '''  <summary> Assigns a string value to the uCalc String object</summary> 
   '''  <param name="StringValue"> New string value +++ Should probably add Index arg</param>
   '''  <remarks>
   '''  <para>
   '''     This assigns a new string to the uCalc String object.
   '''  </para>
   '''  </remarks> 
   Function Str( ByVal StringValue As String) As String_
      Return Str_171(h, StringValue, StringValue.Length())
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Pattern"> Pattern</param>
   '''  <param name="Nth"> Nth match</param>
   '''  <remarks>
   '''  <para>
   '''       ...
   '''  </para>
   '''  </remarks> 
   Function Find( ByVal Pattern As String , Optional ByVal Nth As Int64 = 1) As String_
      Return Find_172(h, Pattern, Pattern.Length() , Nth)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Pattern"> Pattern</param>
   '''  <param name="Nth"> Nth match</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function FindOtherThan( ByVal Pattern As String , Optional ByVal Nth As Int64 = 1) As String_
      Return FindOtherThan_173(h, Pattern, Pattern.Length() , Nth)
   End Function

   '''  <summary> Returns the immediate parent of the current string</summary> 
   '''  <remarks>
   '''  <para></para>
   '''  <para></para>
   '''  </remarks> 
   Function Parent( ) As String_
      Return Parent_174(h)
   End Function

   '''  <summary> Returns the immediate parent of the current string</summary> 
   '''  <remarks>
   '''  <para></para>
   '''  <para></para>
   '''  </remarks> 
   Function Root( ) As String_
      Return Root_175(h)
   End Function

   '''  <summary> Sets the index base used in various functions</summary> 
   '''  <param name="BaseValue"> value representing index of 1st element</param>
   '''  <remarks>
   '''  <para>
   '''     By default, uCalc String Library functions use a 0-based index.  So the first element is 0 (not 1), followed by 2, 3, 4 etc.
   '''     Use this if you prefer to start by 1 or another non-zero value.  This value is passed on to string objects derived from a parent string.
   '''     Each string may have a different index base.
   '''  </para>
   '''  </remarks> 
   Function IndexBase( ByVal BaseValue As Int64) As String_
      Return IndexBase_176(h, BaseValue)
   End Function

   '''  <summary> Gets the index base used in various functions</summary> 
   '''  <remarks>
   '''  <para>
   '''     By default, uCalc String Library functions use a 0-based index.  So the first element is 0 (not 1), followed by 2, 3, 4 etc.
   '''     Use this to check to see which base is being used.
   '''  </para>
   '''  </remarks> 
   Function IndexBase( ) As Int64
      Return IndexBase_177(h)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Pattern"> ...</param>
   '''  <param name="Nth"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function UpTo( ByVal Pattern As String , Optional ByVal Nth As Int64 = 1) As String_
      Return UpTo_178(h, Pattern, Pattern.Length() , Nth)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Pattern"> ...</param>
   '''  <param name="Nth"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function StartingFrom( ByVal Pattern As String , Optional ByVal Nth As Int64 = 1) As String_
      Return StartingFrom_179(h, Pattern, Pattern.Length() , Nth)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="StartPattern"> ...</param>
   '''  <param name="EndPattern"> ...</param>
   '''  <param name="StartNth"> ...</param>
   '''  <param name="EndNth"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function StartingFromEndingWith( ByVal StartPattern As String , ByVal EndPattern As String , Optional ByVal StartNth As Int64 = 1, Optional ByVal EndNth As Int64 = 1) As String_
      Return StartingFromEndingWith_180(h, StartPattern, StartPattern.Length() , EndPattern, EndPattern.Length() , StartNth, EndNth)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Pattern"> Pattern</param>
   '''  <param name="Nth"> Nth match</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function Before( ByVal Pattern As String , Optional ByVal Nth As Int64 = 1) As String_
      Return Before_181(h, Pattern, Pattern.Length() , Nth)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Pattern"> Pattern</param>
   '''  <param name="Nth"> Nth match</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function After( ByVal Pattern As String , Optional ByVal Nth As Int64 = 1) As String_
      Return After_182(h, Pattern, Pattern.Length() , Nth)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="StartPattern"> Pattern</param>
   '''  <param name="StopPattern"> Pattern 2</param>
   '''  <param name="StartNth"> Nth match</param>
   '''  <param name="StopNth"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function Between( ByVal StartPattern As String , ByVal StopPattern As String , Optional ByVal StartNth As Int64 = 1, Optional ByVal StopNth As Int64 = 1) As String_
      Return Between_183(h, StartPattern, StartPattern.Length() , StopPattern, StopPattern.Length() , StartNth, StopNth)
   End Function

   '''  <summary> Returns list of tokens</summary> 
   '''  <returns> Object</returns>
   '''  <remarks>
   '''  <para>
   '''     ToDo +++
   '''  </para>
   '''  </remarks> 
   Function ListOfTokens( ) As String_
      Return ListOfTokens_184(h)
   End Function

   '''  <summary> Returns list of tokens</summary> 
   '''  <returns> Object</returns>
   '''  <remarks>
   '''  <para>
   '''     ToDo +++
   '''  </para>
   '''  </remarks> 
   Function ListOfChars( ) As String_
      Return ListOfChars_185(h)
   End Function

   '''  <summary> Returns substring</summary> 
   '''  <param name="StartPos"> Starting position</param>
   '''  <param name="Length"> Length of substring</param>
   '''  <returns> Object</returns>
   '''  <remarks>
   '''  <para>
   '''     ToDo +++
   '''  </para>
   '''  </remarks> 
   Function SubString( ByVal StartPos As Int64 , Optional ByVal Length As Int64 = -1) As String_
      Return SubString_186(h, StartPos , Length)
   End Function

   '''  <summary> Sets rules for when a child object is created</summary> 
   '''  <param name="Option"> +++</param>
   '''  <returns> String object</returns>
   '''  <remarks>
   '''  <para>
   '''     Many functions create a new string object derived from another given object.  This option determins the persistence of previously
   '''     derived objects.  The right option depends on what you want to do.  If you're looking to conserve memory, then ClearAll is may be the
   '''     option you need.  However, with this option, you can no longer refer to previously derived strings, otherwise the behavior will be
   '''     undefined (such as crashing).  You may delay object deletetion be removing only the ones that overlap in location with the newly derived
   '''     string.  The decision to delete may be delayed based on when if object is being written to.   ClearOverlapOnWrite, allows you to
   '''     to have multiple overlapping views of the same parent string without any conflict.  Only when modifying a derived string are overlapped
   '''     derived strings removed.  Corresponding Detach options are similar, except that instead of actually erasing an overlapping object, it
   '''     is disassassiated from the parent string.  It can continue to be used as an independent string without undefined behavior.  With this
   '''     option, the independent strings are erased only when the parent string itself is erased.</para>
   '''  <para></para>
   '''  </remarks> 
   Function ChildStringOption( ByVal Option_ As ChildStringOptionEnum) As String_
      Return ChildStringOption_187(h, Option_)
   End Function

   '''  <summary> Gets the option</summary> 
   '''  <returns> String object</returns>
   '''  <remarks>
   '''  <para>
   '''     +++
   '''  </para>
   '''  </remarks> 
   Function ChildStringOption( ) As ChildStringOptionEnum
      Return ChildStringOption_188(h)
   End Function

   '''  <summary> Clears derived strings from memory</summary> 
   '''  <returns> String object</returns>
   '''  <remarks>
   '''  <para>
   '''     +++
   '''  </para>
   '''  </remarks> 
   Function ClearDerivedStrings( ) As String_
      Return ClearDerivedStrings_189(h)
   End Function

   '''  <summary> todo</summary> 
   '''  <param name="From_"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     todo +++
   '''  </para>
   '''  </remarks> 
   Function Remove( ByVal From_ As String) As String_
      Return Remove_190(h, From_, From_.Length())
   End Function

   '''  <summary> todo</summary> 
   '''  <param name="From_"> ...</param>
   '''  <param name="To_"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     todo +++
   '''  </para>
   '''  </remarks> 
   Function Replace( ByVal From_ As String , ByVal To_ As String) As String_
      Return Replace_191(h, From_, From_.Length() , To_, To_.Length())
   End Function

   '''  <summary> todo</summary> 
   '''  <param name="Pattern"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     todo +++
   '''  </para>
   '''  </remarks> 
   Function Skip( ByVal Pattern As String) As String_
      Return Skip_192(h, Pattern, Pattern.Length())
   End Function

   '''  <summary> todo</summary> 
   '''  <param name="Pattern"> ...</param>
   '''  <param name="Nth"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     todo +++
   '''  </para>
   '''  </remarks> 
   Function ToUpper( Optional ByVal Pattern As String = "", Optional ByVal Nth As Int64 = -1) As String_
      Return ToUpper_193(h, Pattern, Pattern.Length(), Nth)
   End Function

   '''  <summary> todo</summary> 
   '''  <param name="Pattern"> ...</param>
   '''  <param name="Nth"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     todo +++
   '''  </para>
   '''  </remarks> 
   Function ToLower( Optional ByVal Pattern As String = "", Optional ByVal Nth As Int64 = -1) As String_
      Return ToLower_194(h, Pattern, Pattern.Length(), Nth)
   End Function

   '''  <summary> todo</summary> 
   '''  <param name="ListType"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     todo
   '''  </para>
   '''  </remarks> 
   Function List( Optional ByVal ListType As uCalcList = uCalcList.Matches) As String_
      Return List_195(h, ListType)
   End Function

   '''  <summary> todo</summary> 
   '''  <param name="Separator"> ...</param>
   '''  <param name="Prefix"> ...</param>
   '''  <param name="Postfix"> ...</param>
   '''  <param name="UserFunc"> ...</param>
   '''  <param name="Element"> ...</param>
   '''  <param name="Index"> ...</param>
   '''  <param name="Count"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     todo +++ Maybe rename for clarity
   '''  </para>
   '''  </remarks> 
   Function ListFormat( ByVal Separator As String , Optional ByVal Prefix As String = "", Optional ByVal Postfix As String = "", Optional ByVal UserFunc As String = "", Optional ByVal Element As String = "", Optional ByVal Index As String = "", Optional ByVal Count As String = "") As String_
      Return ListFormat_196(h, Separator, Separator.Length() , Prefix, Prefix.Length(), Postfix, Postfix.Length(), UserFunc, UserFunc.Length(), Element, Element.Length(), Index, Index.Length(), Count, Count.Length())
   End Function

   '''  <summary> Sets the separator that will delimite the elements of a list</summary> 
   '''  <param name="Separator"> Separator that will delimite each element of a list</param>
   '''  <returns> Current uCalc String object</returns>
   '''  <remarks>
   '''  <para>
   '''     Text that is returned as a list can have a prefix, postfix, and separators between elements.  A list of items
   '''     within curly braces might have an open curly brace as prefix, a comma as delimiter, and a closing curly brace as postfix.
   '''  </para>
   '''  </remarks> 
   Function ListSeparator( ByVal Separator As String) As String_
      Return ListSeparator_197(h, Separator, Separator.Length())
   End Function

   '''  <summary> Sets the prefix that is inserted at the start of lists</summary> 
   '''  <param name="Prefix"> Prefix that will be inserted at the start of a list</param>
   '''  <returns> Current uCalc String object</returns>
   '''  <remarks>
   '''  <para>
   '''     Text that is returned as a list can have a prefix, postfix, and separators between elements.  A list of items
   '''     within curly braces might have an open curly brace as prefix, a comma as delimiter, and a closing curly brace as postfix.
   '''  </para>
   '''  </remarks> 
   Function ListPrefix( ByVal Prefix As String) As String_
      Return ListPrefix_198(h, Prefix, Prefix.Length())
   End Function

   '''  <summary> Sets the postfix that is inserted at the end of lists</summary> 
   '''  <param name="Postfix"> Postfix that will be inserted at the end of a list</param>
   '''  <returns> Current uCalc String object</returns>
   '''  <remarks>
   '''  <para>
   '''     Text that is returned as a list can have a prefix, postfix, and separators between elements.  A list of items
   '''     within curly braces might have an open curly brace as prefix, a comma as delimiter, and a closing curly brace as postfix.
   '''  </para>
   '''  </remarks> 
   Function ListPostfix( ByVal Postfix As String) As String_
      Return ListPostfix_199(h, Postfix, Postfix.Length())
   End Function

   '''  <summary> Sets the formatting for displaying the elements of a list</summary> 
   '''  <param name="UserFunc"> +++</param>
   '''  <param name="Element"> +++</param>
   '''  <param name="Index"> +++</param>
   '''  <param name="MatchCount"> +++</param>
   '''  <returns> Current transform object</returns>
   '''  <remarks>
   '''  <para>
   '''     Text that is returned as a list can have a prefix, postfix, and separators between elements.  A list of items
   '''     within curly braces might have an open curly brace as prefix, a comma as delimiter, and a closing curly brace as postfix.
   '''  </para>
   '''  </remarks> 
   Function ListFunction( ByVal UserFunc As String , Optional ByVal Element As String = "", Optional ByVal Index As String = "", Optional ByVal MatchCount As String = "") As String_
      Return ListFunction_200(h, UserFunc, UserFunc.Length() , Element, Element.Length(), Index, Index.Length(), MatchCount, MatchCount.Length())
   End Function

   '''  <summary> todo</summary> 
   '''  <param name="first"> ...</param>
   '''  <param name="last"> ...</param>
   '''  <param name="expression"> ...</param>
   '''  <param name="Step"> ...+++ use "Escaped names" [Step] in VB to avoid keyword conflict</param>
   '''  <param name="Condition"> ...</param>
   '''  <param name="VarIndex"> ...</param>
   '''  <param name="VarFirst"> ...</param>
   '''  <param name="VarLast"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     todo +++
   '''  </para>
   '''  </remarks> 
   Function Populate( ByVal first As Double , ByVal last As Double , ByVal expression As String , Optional ByVal Step_ As Double = 1, Optional ByVal Condition As String = "", Optional ByVal VarIndex As String = "", Optional ByVal VarFirst As String = "", Optional ByVal VarLast As String = "") As String_
      Return Populate_201(h, first , last , expression, expression.Length() , Step_, Condition, Condition.Length(), VarIndex, VarIndex.Length(), VarFirst, VarFirst.Length(), VarLast, VarLast.Length())
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Index"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function Match( ByVal Index As Int64) As String_
      Return Match_202(h, Index)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Index"> Index of the character who's match index you want</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function MatchIndexAtChar( ByVal Index As Int64) As Int64
      Return MatchIndexAtChar_203(h, Index)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Index"> Index of the token who's match index you want</param>
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function MatchIndexAtToken( ByVal Index As Int64) As Int64
      Return MatchIndexAtToken_204(h, Index)
   End Function

   '''  <summary> todo</summary> 
   '''  <remarks>
   '''  <para>
   '''     todo +++
   '''  </para>
   '''  </remarks> 
   Function NonMatches( ) As String_
      Return NonMatches_205(h)
   End Function

   '''  <summary> ...</summary> 
   '''  <param name="Index"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     ... +++ ???
   '''  </para>
   '''  </remarks> 
   Function SubMatch( ByVal Index As Int64) As String_
      Return SubMatch_206(h, Index)
   End Function

   '''  <summary> ...</summary> 
   '''  <remarks>
   '''  <para>
   '''     ...
   '''  </para>
   '''  </remarks> 
   Function MatchCount( ) As Int64
      Return MatchCount_207(h)
   End Function

   '''  <summary> todo</summary> 
   '''  <param name="tt"> ...</param>
   '''  <remarks>
   '''  <para>
   '''     todo +++
   '''  </para>
   '''  </remarks> 
   Function Transform( ByVal tt As Transforms) As String_
      Return Transform_208(h, If(tt Is Nothing, Nothing, tt.h))
   End Function

   Public Sub New()
      h = Default_().NewString().h
   End Sub

   Public Sub New(ByVal Instance As String_)
      h = Instance.h
   End Sub

   Public Sub New(ByVal s As String)
      h = Default_().NewString(s).h
   End Sub

   Public Shared Widening Operator CType(ByVal ucString As String_) As String
   Return ucString.Str()
End Operator

'''  <summary> Returns the handle of an object</summary> 
'''  <remarks>
'''  <para>Mostly for internal use.  However, if you are iterating through a series of objects with NextOverload
'''     (when applicable), you may check Handle() to see when it becomes NULL (or 0) to know when to stop.</para>
'''  </remarks> 
Function Handle( ) As IntPtr
   Return Handle_209(h)
End Function

'''  <summary> +++ comment for each</summary> 
Sub Release()
   If h <> 0 Then
      Release_210(h)
      h = 0
   End If
End Sub

Public Shared Widening Operator CType(ByVal o As IntPtr) As String_
Return New String_(o)
End Operator

Public Sub New(ByVal PassedHandle As IntPtr)
   h = PassedHandle
End Sub
End Class 

'''  <summary> Handle for uCalc instance</summary> 
Public h As IntPtr

'''  <summary> Adds an error handler</summary> 
'''  <param name="ErrorHandlerAddress"> Address of the callback function containing the error handler code</param>
'''  <param name="Position"> Position in which to insert the error handler</param>
'''  <returns> The error handler can later be removed using this return object</returns>
'''  <remarks>
'''  <para>Use this to set a a callback function that is called whenever there is an error.  Your callback can
'''  do things like alert the user of the error, correct the error and resume, keep a log of errors, etc.</para>
'''  <para>By default, if there are multiple error handlers, they are called starting with the most recently
'''  defined one first, ending with the first one to be defined last.  In order to define a handler in a different
'''  order, specify the Position value of where it should be inserted; 0 so that it is called first, -1 so it
'''  is called last, or a positive integer indicated where it should be inserted.  If the Postion value is out
'''  of bounds, it is adjusted into the maximum acceptable value.</para>
'''  <para>If you set ErrorResponse to ErrorHandlerResponseEnum.ErrorResume, subsequent error handler callbacks will
'''  be bypassed and uCalc will resume operations as though no error had taken place.  Note that the condition
'''  that caused the error must be corrected before resuming, otherwise uCalc may get stuck in an infinite loop.</para>
'''  <para>Some functions, such as ErrorExpression, ErrorLocation, and ErrorSymbol produce a meaningful result only
'''  during the parsing stage.  They do not cause other problems beyond meaningless data during the evaluation stage.
'''  </para>
'''  </remarks> 
Function AddErrorHandler( ByVal ErrorHandlerAddress As uCalcDelegate , Optional ByVal Position As Int64 = 0) As Item
   Return AddErrorHandler_211(h, ErrorHandlerAddress , Position)
End Function

'''  <summary> Creates a new uCalc instance</summary> 
'''  <param name="BasedOn"> ...</param>
'''  <remarks>
'''  <para>This is not meant to be called directly.</para>
'''  </remarks> 
Shared Function Create( Optional ByVal BasedOn As uCalc = Nothing) As uCalc
Return Create_212(0, If(BasedOn Is Nothing, Nothing, BasedOn.h))
End Function

'''  <summary> Creates a new uCalc instance 
'''  <param name="BasedOn"> ...</param>
'''  <remarks>
'''  <para>This is not meant to be called directly.</para>
'''  </remarks> 
Shared Function CreateTempDefault( Optional ByVal BasedOn As uCalc = Nothing) As uCalc
Return CreateTempDefault_213(0, If(BasedOn Is Nothing, Nothing, BasedOn.h))
End Function

'''  <summary> Creates a new uCalc instance  +++Maybe rename TempDefaultRelease()</summary> 
'''  <remarks>
'''  <para>This is not meant to be called directly.</para>
'''  </remarks> 
Shared Function ReleaseTempDefault( ) As uCalc
Return ReleaseTempDefault_214(0)
End Function

'''  <summary> Adds an alias to an existing symbol</summary> 
'''  <param name="NewSymbol"> New symbol that will be set as equivalent to an existing symbol</param>
'''  <param name="ExistingSymbol"> Pre-existing symbol</param>
'''  <remarks>
'''  <para>
'''  This function creates a new symbol that is pegged to an existing symbol.  Whenever this new symbol is encountered by the parser,
'''  it will be the same as if it had encountered the pre-existing symbol this new symbol is an alias of.  This new symbol shares the same handle as the
'''  pre-existing symbol within the symbol table.  The new symbol actually has its own handle, but that handle can only be used to delete the item.
'''  The pre-existing handle is used for all other purposes.</para>
'''  <para>For simple situations where you just want two symbols to be considered equivalent by the parser, Alias is prefered as a more efficient option over
'''  ExpressionTransforms().FromTo().</para>
'''  <para></para>
'''  </remarks> 
Function Alias_( ByVal NewSymbol As String , ByVal ExistingSymbol As String) As Item
   Return Alias_215(h, NewSymbol, NewSymbol.Length() , ExistingSymbol, ExistingSymbol.Length())
End Function

'''  <summary> Adds an alias to an existing symbol</summary> 
'''  <param name="NewSymbol"> New symbol that will be set as equivalent to an existing symbol</param>
'''  <param name="ExistingItem"> Pre-existing item</param>
'''  <remarks>
'''  <para>
'''  This function creates a new symbol that is pegged to an existing symbol.  Whenever this new symbol is encountered by the parser,
'''  it will be the same as if it had encountered the pre-existing symbol this new symbol is an alias of.  This new symbol shares the same handle as the
'''  pre-existing symbol within the symbol table.  The new symbol actually has its own handle, but that handle can only be used to delete the item.
'''  The pre-existing handle is used for all other purposes.</para>
'''  <para>This version of Alias uses an Item object as second argument.  It is a little more efficient than the one that uses a string (the string version calls
'''  the internal version of this function).
'''  </para>
'''  </remarks> 
Function Alias_( ByVal NewSymbol As String , ByVal ExistingItem As Item) As Item
   Return Alias_216(h, NewSymbol, NewSymbol.Length() , If(ExistingItem Is Nothing, Nothing, ExistingItem.h))
End Function

'''  <summary> Adds an alias name to an existing command name for Define()</summary> 
'''  <param name="NewCommandName"> New command name that will be set as equivalent to an existing command name</param>
'''  <param name="ExistingCommandName"> Pre-existing command name</param>
'''  <remarks>
'''  <para>
'''  This creates an alternative command name for use with the Define() function.
'''  </para>
'''  </remarks> 
Sub AliasForDefine( ByVal NewCommandName As String , ByVal ExistingCommandName As String)
   AliasForDefine_217(h, NewCommandName, NewCommandName.Length() , ExistingCommandName, ExistingCommandName.Length())
End Sub

'''  <summary> Returns the data type of the expression that was passed</summary> 
'''  <param name="expression"> Expression whose data type will be returned</param>
'''  <remarks>
'''  <para>
'''     +++ Maybe consolidate with GetDataType
'''     Returns the data type of the expression that was passed
'''  </para>
'''  </remarks> 
Function DataTypeOf( ByVal expression As String) As DataType
   Return DataTypeOf_218(h, expression, expression.Length())
End Function

'''  <summary> Returns a data type object</summary> 
'''  <param name="Index"> Index associated with the data type</param>
'''  <remarks>
'''  <para>Each instance of uCalc has its own separate handle & data type object for any given data type.  For
'''  instance, Item("Int64") in one instance of uCalc is not the same object as Item("Int64") from
'''  another uCalc instance.  This allows the same data type to have a different name and different formatting
'''  in different instances.  However, they share the same data type index across instances.  Given the index
'''  of a data type, you can directly obtain the proper data type object for a particular uCalc instance,
'''  faster than obtaining it by name as text with Item().
'''  </para>
'''  </remarks> 
Function DataTypeOf( ByVal Index As BuiltInTypesEnum) As DataType
   Return DataTypeOf_219(h, Index)
End Function

'''  <summary> Defines a uCalc.Item object (a constunction, function, operator, variable, etc)</summary> 
'''  <param name="expression"> Text containing item to be defined.  expression must start with a keyword such as Function, Operator, Variable, Token, Syntax, etc., followed by a colon, before the expression</param>
'''  <param name="Address"> Address a function or variable is attached to</param>
'''  <param name="dType"> ...</param>
'''  <remarks>
'''  <para>Functions, operators, variables, constants, tokens, syntax constructs, etc., can be defined with
'''  this method.  Although there are specialized methods that do the same things, such as DefineFunction,
'''  DefineOperator, DefineVariable, and DefineConstant, this method may in same cases offer
'''  more flexibility.</para>
'''  <para>The expression must be preceded by a keyword and colon, such as "Variable:".  For a full list of keywords,
'''  see Definition Keywords.</para>
'''  <para>Sections are separated by ~~ (two tilda signs).
'''  </para>
'''  </remarks> 
Function Define( ByVal expression As String , Optional ByVal Address As IntPtr = Nothing, Optional ByVal dType As DataType = Nothing) As Item
   Return Define_220(h, expression, expression.Length() , Address, If(dType Is Nothing, Nothing, dType.h))
End Function

'''  <summary> Defines a constant</summary> 
'''  <param name="Definition"> Text containing constant to be defined</param>
'''  <param name="VariableAddress"> Address the constant is attached to</param>
'''  <remarks>
'''  <para>
'''  A constant definition is similar to that of a variable defined with DefineVariable, except that the end-user is not allowed to modify the value of a constant.
'''  You are, however, allowed to perform lower-level operations such as renaming a constant, or deleting it and re-defining a new constant or variable with the same
'''  name but different value.  If you attach the constant to the address of a variable in your host program, the host program may change the value.  However, when
'''  the end-user attempts to assign a value to the constant, an error is raised.</para>
'''  <para>DefineConstant("x") is the same as: Define("Lock ~~ Variable: x")
'''  </para>
'''  </remarks> 
Function DefineConstant( ByVal Definition As String , Optional ByVal VariableAddress As IntPtr = Nothing) As Item
   Return DefineConstant_221(h, Definition, Definition.Length() , VariableAddress)
End Function

'''  <summary> Defines a function</summary> 
'''  <param name="Definition"> Text containing function to be defined</param>
'''  <param name="FunctionAddr"> Address of callback function this function is attached to</param>
'''  <remarks>
'''  <para>
'''  A function definition can either be self-contained, or it may be attached to the address of a callback function in your
'''  source code.</para>
'''  <para>DefineFunction("f(x) = ...") is the same as: Define("Function: ...")
'''  </para>
'''  </remarks> 
Function DefineFunction( ByVal Definition As String , Optional ByVal FunctionAddr As uCalcDelegate = Nothing) As Item
   Return DefineFunction_222(h, Definition, Definition.Length() , FunctionAddr)
End Function

'''  <summary> Defines an operator</summary> 
'''  <param name="Definition"> Text containing operator to be defined</param>
'''  <param name="iPrecedence"> Precedence level of the operator. +++ Rename</param>
'''  <param name="Grouping"> Operator associativity; arithmetic operators are typically grouped left-to-right; special operators, such as the equal sign, =, assignment operator are right-to-left</param>
'''  <param name="FunctionAddr"> Address of callback function this operator is attached to</param>
'''  <remarks>
'''  <para>
'''  Many details for defining an operator are similar to those of defining a function.  In additionn, all operators must be
'''  defined with a precedence level.  You may use the Precedence function to obtain precedence levels of existing operators,
'''  and select a precedence level in comparison to those operators.  By default operators are grouped left to right.  But you
'''  may also set it to right to left.  This means that when adjacent operators have the same precedence level, the operands on
'''  the right will be evaluated first.</para>
'''  <para>DefineOperator("...") is the same as: Define("Operator: ...")
'''  More later+++
'''  </para>
'''  </remarks> 
Function DefineOperator( ByVal Definition As String , ByVal iPrecedence As Int64 , Optional ByVal Grouping As GroupingEnum = GroupingEnum.GroupLeftToRight, Optional ByVal FunctionAddr As uCalcDelegate = Nothing) As Item
   Return DefineOperator_223(h, Definition, Definition.Length() , iPrecedence , Grouping, FunctionAddr)
End Function

'''  <summary> Defines a variable</summary> 
'''  <param name="Definition"> Text containing variable to be defined</param>
'''  <param name="VariableAddress"> Address of variable in host program this uCalc variable is attached to</param>
'''  <remarks>
'''  <para>
'''  A variable consists of ...</para>
'''  <para>DefineVariable("...") is the same as: Define("Variable: x")
'''  </para>
'''  </remarks> 
Function DefineVariable( ByVal Definition As String , Optional ByVal VariableAddress As IntPtr = Nothing) As Item
   Return DefineVariable_224(h, Definition, Definition.Length() , VariableAddress)
End Function

'''  <summary> Returns the expression associated with an error that was raised</summary> 
Function ErrorExpression() As String
   Dim ReturnStrSize As IntPtr
   Dim ReturnString = ErrorExpression_225(h, ReturnStrSize )
   Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
End Function

'''  <summary> Sets a new expression after an error is raised</summary> 
'''  <param name="expression"> Error expression</param>
Sub ErrorExpression( ByVal expression As String)
   ErrorExpression_226(h, expression, expression.Length())
End Sub

'''  <summary> Returns the location of an error that was raised</summary> 
Function ErrorLocation( ) As Int64
   Return ErrorLocation_227(h)
End Function

'''  <summary> Returns a message associated with the error that was raised</summary> 
'''  <param name="Index"> Index of error message to return</param>
'''  <remarks>
'''  <para>If an error was raised, this returns a message describing the recent error.  If the Index argument is specified,
'''  then the error message associated with this Index is returned.  A value must be chosen from ErrorNumberEnum.</para>
'''  <para>Note: Errors are cleared whenever a new expression is parsed or a new item is defined.
'''  </para>
'''  </remarks> 
Function ErrorMessage(Optional ByVal Index As ErrorNumberEnum = ErrorNumberEnum.Err_None) As String
   Dim ReturnStrSize As IntPtr
   Dim ReturnString = ErrorMessage_228(h, ReturnStrSize , Index)
   Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
End Function

'''  <summary> Returns the error number of the error that was raised</summary> 
'''  <remarks>
'''  <para>
'''  Returns the error number of the most recently raised error.</para>
'''  <para>Note: Errors are cleared whenever a new expression is parsed or a new item is defined.
'''  </para>
'''  </remarks> 
Function ErrorNumber( ) As ErrorNumberEnum
   Return ErrorNumber_229(h)
End Function

'''  <summary> Sets the error response for an error handler</summary> 
'''  <param name="Response"> Indicates what should happen now that an error is raised</param>
'''  <remarks>
'''  <para>When an error is raised, you have the option of aborting the rest of the option (which is the default option),
'''  or you may correct the problem, and then resume the operation.  Or you may perform an action, and than raise the
'''  error again for a subsequent error handle to take care of.</para>
'''  <para>This method can only be called from within a callback of an error handler routine definined with AddErrorHandler.
'''  The options to use can be found at ErrorHandlerResponseEnum.
'''  </para>
'''  </remarks> 
Sub ErrorResponse( ByVal Response As ErrorHandlerResponseEnum)
   ErrorResponse_230(h, Response)
End Sub

'''  <summary> Returns the symbol associated with the error that is raised</summary> 
Function ErrorSymbol() As String
   Dim ReturnStrSize As IntPtr
   Dim ReturnString = ErrorSymbol_231(h, ReturnStrSize )
   Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
End Function

'''  <summary> Parses and evaluates an expression in one step</summary> 
'''  <param name="expression"> Expression to be evaluated</param>
'''  <remarks>
'''  <para>This takes a math expression and returns a numeric result.</para>
'''  </remarks> 
Function Eval( ByVal expression As String) As Double
   Return Eval_232(h, expression, expression.Length())
End Function

'''  <summary> Parses and evaluates an expression of any data type in one step, returning the result as a string</summary> 
'''  <param name="expression"> Expression to be evaluated</param>
'''  <remarks>
'''  <para>This is similar to Eval, however, it can return non-numeric results, such as strings.</para>
'''  </remarks> 
Function EvalStr(ByVal expression As String) As String
   Dim ReturnStrSize As IntPtr
   Dim ReturnString = EvalStr_233(h, ReturnStrSize , expression, expression.Length())
   Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
End Function

'''  <summary> Causes division by 0 errors to be raised</summary> 
'''  <param name="TrueOrFalse">...</param>
'''  <remarks>
'''  <para>
'''  This causes an error to be raised instead of silently returning a special value when a division by 0 or pole error occurs.
'''  </para>
'''  </remarks> 
Sub RaiseErrorOnDivideByZero( Optional ByVal TrueOrFalse As Boolean = True)
   RaiseErrorOnDivideByZero_234(h,  Convert.ToInt32(TrueOrFalse))
End Sub

'''  <summary> Causes inexact results to raise an error</summary> 
'''  <param name="TrueOrFalse">...</param>
'''  <remarks>
'''  <para>
'''  This causes an error to be raised instead returning an approximate value where an exact value cannot be represented.
'''  </para>
'''  </remarks> 
Sub RaiseErrorOnInexact( Optional ByVal TrueOrFalse As Boolean = True)
   RaiseErrorOnInexact_235(h,  Convert.ToInt32(TrueOrFalse))
End Sub

'''  <summary> Causes underflow to raise an error</summary> 
'''  <param name="TrueOrFalse">...</param>
'''  <remarks>
'''  <para>
'''  This causes an error to be raised for underflow.
'''  </para>
'''  </remarks> 
Sub RaiseErrorOnUnderflow( Optional ByVal TrueOrFalse As Boolean = True)
   RaiseErrorOnUnderflow_236(h,  Convert.ToInt32(TrueOrFalse))
End Sub

'''  <summary> Causes overflow to raise an error</summary> 
'''  <param name="TrueOrFalse">...</param>
'''  <remarks>
'''  <para>
'''  This causes an error to be raised instead returning infinity when there's an overflow.
'''  </para>
'''  </remarks> 
Sub RaiseErrorOnOverflow( Optional ByVal TrueOrFalse As Boolean = True)
   RaiseErrorOnOverflow_237(h,  Convert.ToInt32(TrueOrFalse))
End Sub

'''  <summary> Causes invalid value to raise an error</summary> 
'''  <param name="TrueOrFalse">...</param>
'''  <remarks>
'''  <para>
'''  This causes an error to be raised instead returning NaN when an invalid value is encountered.
'''  </para>
'''  </remarks> 
Sub RaiseErrorOnInvalid( Optional ByVal TrueOrFalse As Boolean = True)
   RaiseErrorOnInvalid_238(h,  Convert.ToInt32(TrueOrFalse))
End Sub

'''  <summary> Returns the floating point errors to catch</summary> 
'''  <param name="Value"> ...</param>
'''  <remarks>
'''  <para>
'''  ...
'''  </para>
'''  </remarks> 
Function FloatingPointErrorsToCatch( Optional ByVal Value As Int32 = -1) As Int32
   Return FloatingPointErrorsToCatch_239(h, Value)
End Function

'''  <summary> Returns the uCalc.Item object associated with the given name</summary> 
'''  <param name="ItemName"> Name of uCalc.Item that you want to get</param>
'''  <param name="Properties"> Properties to help pinpoint the right Item, in case several items share the same name +++ have Is[Alias] option (will loop through to find)</param>
'''  <remarks>
'''  <para>
'''  If there is no match, an item whose IsProperty ItemIsEnum.NotFound value is True is returned.</para>
'''  <para>In case multiple items share the same name, you can narrow it down using properties.  For instance, the + operator has a
'''  binary and unary versions.  You can specify Prefix if you wanted the unary one.</para>
'''  <para>Note: A ItemIsEnum member should not be passed directly as the second argument.  Instead Properties, with one or more
'''  ItemIsEnum members should be passed.
'''  </para>
'''  </remarks> 
Function ItemOf( ByVal ItemName As String , Optional ByVal Properties As Int64 = 0) As Item
   Return ItemOf_240(h, ItemName, ItemName.Length() , Properties)
End Function

'''  <summary> Returns the nth uCalc.Item object that matches a property</summary> 
'''  <param name="Property_"> Property of the uCalc.Item object you're after</param>
'''  <param name="nth"> The nth object</param>
'''  <param name="DataTypeName"> The data type of the object</param>
'''  <remarks>
'''  <para>
'''  This can be used to cycle through defined items.
'''  If there is no match, an item whose IsProperty ItemIsEnum.NotFound value is True is returned.
'''  </para>
'''  </remarks> 
Function ItemOf( ByVal Property_ As ItemIsEnum , ByVal nth As Int64 , Optional ByVal DataTypeName As String = "") As Item
   Return ItemOf_241(h, Property_ , nth , DataTypeName, DataTypeName.Length())
End Function

'''  <summary> ???</summary> 
'''  <param name="nth"> +++</param>
Function NamespaceChild( Optional ByVal nth As Int64 = 0) As Item
   Return NamespaceChild_242(h, nth)
End Function

'''  <summary> ???</summary> 
Function NamespaceChildCount( ) As Int64
   Return NamespaceChildCount_243(h)
End Function

'''  <summary> ???</summary> 
'''  <param name="Level"> +++</param>
Function NamespaceParent( Optional ByVal Level As Int64 = 0) As Item
   Return NamespaceParent_244(h, Level)
End Function

'''  <summary> ???</summary> 
'''  <param name="nth"> +++</param>
Function NamespaceSymbol( ByVal nth As Int64) As Item
   Return NamespaceSymbol_245(h, nth)
End Function

'''  <summary> ???</summary> 
Function NamespaceSymbolCount( ) As Int64
   Return NamespaceSymbolCount_246(h)
End Function

'''  <summary> Returns a new uCalc String object</summary> 
'''  <param name="InitialString"> String value</param>
'''  <remarks>
'''  <para>
'''  Returns a new uCalc String object.
'''  </para>
'''  </remarks> 
Function NewString( Optional ByVal InitialString As String = "") As String_
   Return NewString_247(h, InitialString, InitialString.Length())
End Function

'''  <summary> Returns a new transform object</summary> 
'''  <remarks>
'''  <para>
'''  Returns a new object that can be used to transform text.
'''  +++ Decide on name; could be CreateTransform() or TransformObj()
'''  </para>
'''  </remarks> 
Function NewTransform( ) As Transforms
   Return NewTransform_248(h)
End Function

'''  <summary> Returns the transform object associated with the current uCalc object</summary> 
'''  <remarks>
'''  <para>
'''  Whenever a math expression is parsed, this transform is first called.  Use this when you want transforms that apply to math
'''  expressions parsed with Parse, Eval, or EvalStr.  To create a new transform that does not affect math expressions sent to
'''  Parse, use NewTransform instead.</para>
'''  <para>Independent transforms created with NewTransform can be released when no longer needed.  However, the object created with
'''  ExpressionTransforms should never be released explicitely, because the uCalc object requires it in order parse expressions.</para>
'''  <para>Note: For simple situations when you just want one keyword to be the equivalent of a pre-existing one, it is more efficient to
'''  use Alias().  With Alias, nothing is transformed.  Instead, an aliased symbol simply shares the same handle as a pre-existing
'''  one in the symbol table.  When there are no expression transforms at all, the transform step is skipped altogether, slightly
'''  speeding up parsing for all expressions in a uCalc object.
'''  </para>
'''  </remarks> 
Function ExpressionTransforms( ) As Transforms
   Return ExpressionTransforms_249(h)
End Function

'''  <summary> Parses an expression that will later be evaluated with Evaluate or EvaluateStr</summary> 
'''  <param name="expression"> Expression to be parsed</param>
'''  <param name="DataType"> Data type of return value</param>
Function Parse( ByVal expression As String , Optional ByVal DataType As DataType = Nothing) As Expression
   Return Parse_250(h, expression, expression.Length() , If(DataType Is Nothing, Nothing, DataType.h))
End Function

'''  <summary> Parses an expression that will later be evaluated with Evaluate or EvaluateStr</summary> 
'''  <param name="expression"> Expression to be parsed</param>
'''  <param name="DataType"> Data type of return value</param>
Function Parse( ByVal expression As String , ByVal DataType As String) As Expression
   Return Parse_251(h, expression, expression.Length() , DataType, DataType.Length())
End Function

'''  <summary> Parses an expression that will later be evaluated with Evaluate or EvaluateStr</summary> 
'''  <param name="expression"> Expression to be parsed</param>
'''  <param name="DataTypeIndex"> Data type index of return value</param>
Function Parse( ByVal expression As String , ByVal DataTypeIndex As BuiltInTypesEnum) As Expression
   Return Parse_252(h, expression, expression.Length() , DataTypeIndex)
End Function

'''  <summary> Returns the precedence level of an operator or the level between two operators</summary> 
'''  <param name="Operator1"> Operator with lower (or equal) precedence</param>
'''  <param name="Operator2"> Operator with greater (or equal precedence)</param>
'''  <remarks>
'''  <para>
'''  This returns a precedence level based on levels of existing operators; useful when defining a new operator (or transform)
'''  with a level relative to levels of existing operators (or transforms).  If one argument is passed, then the precedence
'''  level of that item is returned.  This is useful for defining a new item at the same level as the specified item.  If two
'''  arguments are passed, then the average precedence level of the two items is returned.  This is useful for defining a level
'''  that's in between that of two existing items.
'''  </para>
'''  </remarks> 
Function Precedence( ByVal Operator1 As String , Optional ByVal Operator2 As String = "") As Int64
   Return Precedence_253(h, Operator1, Operator1.Length() , Operator2, Operator2.Length())
End Function

'''  <summary> Combines properties into a numeric value that can be passed to Item</summary> 
'''  <param name="p1"> +++</param>
'''  <param name="p2"> +++</param>
'''  <param name="p3"> +++</param>
'''  <param name="p4"> +++</param>
'''  <remarks>
'''  <para>
'''  ItemIsEnum properties are numbered sequentially (0, 1, 2, 3, 4, ...).  However the Properties argument
'''  of the Item function requires properties in the 2^x sequence (1, 2, 4, 8, 16, ...).  So you
'''  must pass one or more ItemIsEnum to Properties before passing it to Item.
'''  +++ Maybe rename for clarity (CombineProperties, or something much shorter)
'''  </para>
'''  </remarks> 
Shared Function Properties( ByVal p1 As ItemIsEnum , Optional ByVal p2 As ItemIsEnum = ItemIsEnum.SelectAny, Optional ByVal p3 As ItemIsEnum = ItemIsEnum.SelectAny, Optional ByVal p4 As ItemIsEnum = ItemIsEnum.SelectAny) As Int64
Return Properties_254(0, p1 , p2, p3, p4)
End Function

'''  <summary> Returns default settings</summary> 
'''  <remarks>
'''  <para>The Item returned contains the default settings for the current uCalc instance.  To define new settings,
'''  use Define("Default ~~ ...").
'''  +++ Rename something like DefaultSettings or DefaultItemSettings
'''  </para>
'''  </remarks> 
Function DefaultItem( ) As Item
   Return DefaultItem_255(h)
End Function

'''  <summary> ...</summary> 
'''  <remarks>
'''  <para>...
'''  </para>
'''  </remarks> 
Function DefaultDataType( ) As DataType
   Return DefaultDataType_256(h)
End Function

'''  <summary> ...</summary> 
'''  <param name="dType"> ...</param>
'''  <remarks>
'''  <para>...
'''  </para>
'''  </remarks> 
Sub DefaultDataType( ByVal dType As DataType)
   DefaultDataType_257(h, If(dType Is Nothing, Nothing, dType.h))
End Sub

'''  <summary> ..</summary> 
'''  <param name="DataTypeIndex"> ...</param>
'''  <remarks>
'''  <para>...
'''  </para>
'''  </remarks> 
Sub DefaultDataType( ByVal DataTypeIndex As BuiltInTypesEnum)
   DefaultDataType_258(h, DataTypeIndex)
End Sub

'''  <summary> ...</summary> 
'''  <param name="dTypeStr"> ...</param>
'''  <remarks>
'''  <para>...
'''  </para>
'''  </remarks> 
Sub DefaultDataType( ByVal dTypeStr As String)
   DefaultDataType_259(h, dTypeStr, dTypeStr.Length())
End Sub

'''  <summary> Checks to see if this uCalc object instance is the default</summary> 
'''  <remarks>
'''  <para>
'''  Definitions from this instance will automatically be loaded into new instances unless directed otherwise.
'''  </para>
'''  </remarks> 
Function IsDefault( ) As Boolean
   Return IsDefault_260(h)
End Function

'''  <summary> Sets this uCalc object instance as the default</summary> 
'''  <param name="Condition"> ...</param>
'''  <remarks>
'''  <para>
'''  Definitions from this instance will automatically be loaded into new instances unless directed otherwise.
'''  Set this to True.  WHen set to False, nothing happens.
'''  </para>
'''  </remarks> 
Sub IsDefault( ByVal Condition As Boolean)
   IsDefault_261(h,  Convert.ToInt32(Condition))
End Sub

'''  <summary> +++</summary> 
'''  <remarks>
'''  <para>
'''  +++
'''  </para>
'''  </remarks> 
Shared Function Default_( ) As uCalc
Return Default_262(0)
End Function

'''  <summary> +++</summary> 
'''  <param name="uCalcObj"> uCalc object to set as default</param>
'''  <remarks>
'''  <para>
'''  +++
'''  </para>
'''  </remarks> 
Shared Sub Default_( ByVal uCalcObj As uCalc)
Default_263(0, If(uCalcObj Is Nothing, Nothing, uCalcObj.h))
End Sub

'''  <summary> Allows a callback to decorate the output of EvalStr</summary> 
'''  <param name="FunctionAddr"> Address of callback function that formats the output</param>
'''  <param name="Properties"> Name of datatype that will have its output formated and/or ranking among other output formats; omit this to affect all data types and use default ranking.</param>
Function Format( ByVal FunctionAddr As uCalcDelegate , Optional ByVal Properties As String = "") As Item
   Return Format_264(h, FunctionAddr , Properties, Properties.Length())
End Function

'''  <summary> Allows a callback to decorate the output of EvalStr</summary> 
'''  <param name="FunctionAddr"> Address of callback function that formats the output</param>
'''  <param name="dType"> +++ Test dType 
Function Format( ByVal FunctionAddr As uCalcDelegate , ByVal dType As DataType) As Item
   Return Format_265(h, FunctionAddr , If(dType Is Nothing, Nothing, dType.h))
End Function

'''  <summary> Formats the appearance of results returned by EvalStr or EvaluateStr</summary> 
'''  <param name="Definition"> Format definition for the output</param>
'''  <param name="dType"> +++ Test dType</param>
'''  <remarks>
'''  <para>
'''  This function lets you modify the output returned by EvalStr or EvaluateStr.  The definition may contain one or more
'''  of the following:</para>
'''  <para>Datatype:  If you specify a data type, then the modification will affect only the evaluation result of expressions
'''  that evaluate to the specified data type.</para>
'''  <para>InsertAt:  By default, if you define multiple outputs, then the one defined most recently is applied first, followed by
'''  the other outputs in reverse order in which they were defined, ending with the output that was defined first.  You may
'''  specify a different insertion point than the default with this parameter.</para>
'''  <para>Expression:  This represents what the modified output should look like.  The expression consists of an identifier
'''  (any temporary variable name), followed by an equal sign, followed by a string expression representing the value
'''  that will be returned.  The variable holds the original value that would have been returned.
'''  </para>
'''  </remarks> 
Function Format( ByVal Definition As String , Optional ByVal dType As DataType = Nothing) As Item
   Return Format_266(h, Definition, Definition.Length() , If(dType Is Nothing, Nothing, dType.h))
End Function

'''  <summary> Removes any output formatting</summary> 
'''  <param name="dType"> Data type</param>
'''  <remarks>
'''  <para>
'''  +++
'''  </para>
'''  </remarks> 
Sub FormatRemove( Optional ByVal dType As DataType = Nothing)
   FormatRemove_267(h, If(dType Is Nothing, Nothing, dType.h))
End Sub

'''  <summary> Returns the value located at the specified IntPtr address</summary> 
'''  <param name="ValuePtr"> IntPtr address containing the data +++ Swap args to match Function: ValueAt() +++ Also have overload w/ DataType as handle instead of string</param>
'''  <param name="dType"> Data type of the data you need, which helps to determine in which form to return the value at the given location</param>
'''  <remarks>
'''  <para>+++ Rename Value()
'''  +++ SetValueAt
'''  </para>
'''  </remarks> 
Function ValueAt(ByVal ValuePtr As IntPtr , Optional ByVal dType As DataType = Nothing) As String
   Dim ReturnStrSize As IntPtr
   Dim ReturnString = ValueAt_268(h, ReturnStrSize , ValuePtr , If(dType Is Nothing, Nothing, dType.h))
   Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
End Function

'''  <summary> Returns the value located at the specified IntPtr address</summary> 
'''  <param name="ValuePtr"> IntPtr address containing the data +++ Swap args to match Function: ValueAt() +++ Also have overload w/ DataType as handle instead of string</param>
'''  <param name="ValueDataType"> Data type of the data you need, which helps to determine in which form to return the value at the given location</param>
'''  <remarks>
'''  <para>+++ maybe remove this & leave the other
'''  +++ SetValueAt
'''  </para>
'''  </remarks> 
Function ValueAt(ByVal ValuePtr As IntPtr , ByVal ValueDataType As String) As String
   Dim ReturnStrSize As IntPtr
   Dim ReturnString = ValueAt_269(h, ReturnStrSize , ValuePtr , ValueDataType, ValueDataType.Length())
   Return Marshal.PtrToStringAnsi(ReturnString, ReturnStrSize)
End Function

'''  <summary> +++</summary> 
'''  <param name="LicenseType"> +++</param>
'''  <param name="L1"> +++</param>
'''  <param name="L2"> +++</param>
'''  <param name="L3"> +++</param>
'''  <param name="L4"> +++</param>
'''  <param name="L5"> +++</param>
'''  <returns> +++</returns>
'''  <remarks>
'''  <para>
'''  ...
'''  </para>
'''  </remarks> 
Shared Sub License( ByVal LicenseType As LicenseTypeEnum , Optional ByVal L1 As Int64 = 0, Optional ByVal L2 As Int64 = 0, Optional ByVal L3 As Int64 = 0, Optional ByVal L4 As Int64 = 0, Optional ByVal L5 As Int64 = 0)
License_270(0, LicenseType , L1, L2, L3, L4, L5)
End Sub

Public Sub Reset()
   Release()
   h = Create().h
End Sub

Public Sub Reset(ByVal uCalcObj As uCalc)
   Release()
   h = Create(uCalcObj).h
End Sub

Public Sub New()
   h = Create().h
End Sub

'''  <summary> Returns the handle of an object</summary> 
'''  <remarks>
'''  <para>Mostly for internal use.  However, if you are iterating through a series of objects with NextOverload
'''     (when applicable), you may check Handle() to see when it becomes NULL (or 0) to know when to stop.</para>
'''  </remarks> 
Function Handle( ) As IntPtr
   Return Handle_271(h)
End Function

'''  <summary> +++ comment for each</summary> 
Sub Release()
   If h <> 0 Then
      Release_272(h)
      h = 0
   End If
End Sub

Public Shared Widening Operator CType(ByVal o As IntPtr) As uCalc
Return New uCalc(o)
End Operator

Public Sub New(ByVal PassedHandle As IntPtr)
   h = PassedHandle
End Sub

Public Function PinAddr(ByVal Address As uCalcDelegate) As uCalcDelegate
   Static Addresses As New List(Of uCalcDelegate)
   Addresses.Add(Address)
   Return Address
End Function
End Class
End Module

