#.

C
ACos
m
f
(Value)f
ACosh
m
f
(Value)f
ASin
m
f
(Value)f
ASinh
m
f
(Value)f
ATan
m
f
(Value)f
ATanh
m
f
(Value)f
Abs
m
v
(Value)v
Access
m
b
(Path)s[(Mode)i]
Acs
m
f
(Value)f
Acsh
m
f
(Value)f
Alloc
m
p
(SizeOrString)v[(Count)i]
Ang
m
f
(X)f(Y)f
Asc
m
i
(String)s[(Pos)i]
Ascii?
m
b
(String)s
Asn
m
f
(Value)f
Asnh
m
f
(Value)f
Atan2
m
f
(X)f(Y)f
Atn
m
f
(Value)f
Atnh
m
f
(Value)f
BChg
m
i
(Value)i(Bit)i
BClr
m
i
(Value)i(Bit)i
BSet
m
i
(Value)i(Bit)i
BTst
m
i
(Value)i(Bit)i
Bin
m
s
(Value)v[(Digits)i]
Bin$
m
s
(Value)v[(Digits)i]
Blank?
m
b
(String)s
Boolean?
m
b
(Value)v
Byte?
m
b
(Value)v
CBool
m
b
(Value)v
CByte
m
c
(Value)v
CDate
m
d
(Value)v
CFloat
m
f
(Value)v
CInt
m
i
(Value)v
CInteger
m
i
(Value)v
CShort
m
h
(Value)v
CStr
m
s
(Value)v
CString
m
s
(Value)v
Cbr
m
f
(Value)f
Choose
m
v
(Select)i[(Value)v.]
Chr
m
s
(Code)i
Chr$
m
s
(Code)i
Comp
m
i
(String1)s(String2)s[(Mode)i]
Conv
m
s
(String)s(From)s(To)s
Conv$
m
s
(String)s(From)s(To)s
Cos
m
f
(Value)f
Cosh
m
f
(Value)f
DConv
m
s
(String)s
DConv$
m
s
(String)s
DFree
m
l
(Path)s
Date
m
d
[(Year)i(Month)i(Day)i(Hour)i(Minute)i(Second)i]
Date?
m
b
(Value)v
DateAdd
m
d
(Date)d(Period)i(Interval)i
DateDiff
m
i
(Date1)d(Date2)d(Period)i
Day
m
i
(Date)d
Deg
m
f
(Radians)f
Digit?
m
b
(String)s
Dir
m
String[]
(Path)s[(Pattern)s(Filter)i]
Dir?
m
b
(Path)s
Eof
m
b
[(File)Stream;]
Eval
m
v
(Expression)s[(Context)Collection;]
Exist
m
b
(Path)s
Exp
m
f
(Value)f
Exp10
m
f
(Value)f
Exp2
m
f
(Value)f
Expm
m
f
(Value)f
Fix
m
v
(Value)v
Float?
m
b
(Value)v
Format
m
s
(Value)v[(Format)s]
Format$
m
s
(Value)v[(Format)s]
Frac
m
f
(Value)f
Free
m

(Pointer)p
Hex
m
s
(Value)v[(Digits)i]
Hex$
m
s
(Value)v[(Digits)i]
Hexa?
m
b
(String)s
Hour
m
i
(Date)d
Hyp
m
f
(X)f(Y)f
IIf
m
v
(Test)b(True)v(False)v
If
m
v
(Test)b(True)v(False)v
Instr
m
i
(String)s(Pattern)s[(From)i(Mode)i]
Int
m
v
(Value)v
Integer?
m
b
(Value)v
IsAscii
m
b
(String)s
IsBlank
m
b
(String)s
IsBoolean
m
b
(Value)v
IsByte
m
b
(Value)v
IsDate
m
b
(Value)v
IsDigit
m
b
(String)s
IsDir
m
b
(Path)s
IsFloat
m
b
(Value)v
IsHexa
m
b
(String)s
IsInteger
m
b
(Value)v
IsLetter
m
b
(String)s
IsLong
m
b
(Value)v
IsLower
m
b
(String)s
IsNull
m
b
(Value)v
IsNumber
m
b
(Value)v
IsObject
m
b
(Value)v
IsPunct
m
b
(String)s
IsShort
m
b
(Value)v
IsSpace
m
b
(String)s
IsString
m
b
(Value)v
IsUpper
m
b
(String)s
LCase
m
s
(String)s
LCase$
m
s
(String)s
LTrim
m
s
(String)s
LTrim$
m
s
(String)s
Left
m
s
(String)s[(Length)i]
Left$
m
s
(String)s[(Length)i]
Len
m
i
(String)s
Letter?
m
b
(String)s
Lof
m
l
[(File)Stream;]
Log
m
f
(Value)f
Log10
m
f
(Value)f
Log2
m
f
(Value)f
Logp
m
f
(Value)f
Long?
m
b
(Value)v
Lower
m
s
(String)s
Lower$
m
s
(String)s
Lower?
m
b
(String)s
Mag
m
f
(X)f(Y)f
Max
m
v
(Value)v(Value2)v
Mid
m
s
(String)s[(Pos)i(Length)i]
Mid$
m
s
(String)s[(Pos)i(Length)i]
Min
m
v
(Value)v(Value2)v
Minute
m
i
(Date)d
Month
m
i
(Date)d
Now
m
d

Null?
m
b
(Value)v
Number?
m
b
(Value)v
Object?
m
b
(Value)v
Pi
m
f
[(Factor)f]
Punct?
m
b
(String)s
RDir
m
String[]
(Path)s[(Pattern)s(Filter)i]
RInstr
m
i
(String)s(Pattern)s[(From)i(Mode)i]
RTrim
m
s
(String)s
RTrim$
m
s
(String)s
Rad
m
f
(Degrees)f
Realloc
m
i
(Pointer)p(Size)i[(Count)i]
Replace
m
s
(String)s(Find)s(Replace)s[(Mode)i]
Replace$
m
s
(String)s(Find)s(Replace)s[(Mode)i]
Right
m
s
(String)s[(Length)i]
Right$
m
s
(String)s[(Length)i]
Rnd
m
f
[(From)f(To)f]
Rol
m
i
(Value)i(Shift)i
Ror
m
i
(Value)i(Shift)i
Round
m
f
(Value)f[(Round)i]
SConv
m
s
(String)s
SConv$
m
s
(String)s
Scan
m
String[]
(String)s(Pattern)s
Second
m
i
(Date)d
Seek
m
l
(File)Stream;
Sgn
m
i
(Value)v
Shl
m
i
(Value)i(Shift)i
Short?
m
b
(Value)v
Shr
m
i
(Value)i(Shift)i
Sin
m
f
(Value)f
Sinh
m
f
(Value)f
Space
m
s
(Length)i
Space$
m
s
(Length)i
Space?
m
b
(String)s
Split
m
String[]
(String)s[(Separator)s(Escape)s(IgnoreVoid)b]
Sqr
m
f
(Value)f
Stat
m
Stat
(Path)s[(FollowLink)b]
Str
m
s
(Value)v
Str$
m
s
(Value)v
StrPtr
m
s
(Pointer)p
String
m
s
(Length)i(Pattern)s
String$
m
s
(Length)i(Pattern)s
String?
m
b
(Value)v
Subst
m
s
(Pattern)s.
Subst$
m
s
(Pattern)s.
Tan
m
f
(Value)f
Tanh
m
f
(Value)f
Temp
m
s
[(Prefix)s]
Temp$
m
s
[(Prefix)s]
Time
m
d
[(Hour)i(Minute)i(Second)i]
Timer
m
f

Trim
m
s
(String)s
Trim$
m
s
(String)s
TypeOf
m
i
(Value)v
UCase
m
s
(String)s
UCase$
m
s
(String)s
Upper
m
s
(String)s
Upper$
m
s
(String)s
Upper?
m
b
(String)s
Val
m
v
(String)s
Week
m
i
[(Date)d(Mode)i(Plain)b]
WeekDay
m
i
(Date)d
Year
m
i
(Date)d
#.ApplicationArgs


_get
M
s
(Index)i
_next
M
s

Count
R
i

#.ApplicationEnv


_get
M
s
(Key)s
_next
M
s

_put
M

(Value)s(Key)s
Count
R
i

#.Array.Bounds


_get
m
i
(Dimension)i
#.ClassSymbols


_next
m
s

Count
r
i

#.FilePerm


_get
m
s
(UserOrGroup)s
Group
r
s

Other
r
s

User
r
s

#.SubCollection

C
Exist
m
b
(Key)s
Refresh
m


_free
m


_get
m
o
(Key)s
_next
m
o

Count
r
i

#.Symbol


Hidden
r
b

Kind
r
i

Name
r
s

ReadOnly
r
b

Signature
r
s

Static
r
b

Type
r
s

Value
r
v

#Application


Daemon
P
b

Return
P
i

Args
R
.ApplicationArgs

Dir
R
i

Env
R
.ApplicationEnv

Handle
R
i

Id
R
i

Name
R
s

Path
R
s

Title
R
s

Version
R
s

#Array


Clear
m


Remove
m

(Index)i[(Length)i]
Resize
m

(Size)i
Reverse
m


_free
m


_print
m


Bounds
r
.Array.Bounds

Count
r
i

Data
r
p

Dim
r
i

Length
r
i

Max
r
i

Type
r
i

#Boolean[]
Array
C
Add
m

(Value)b[(Index)i]
Copy
m
Boolean[]
[(Start)i(Length)i]
Delete
m
Boolean[]
(Start)i[(Length)i]
Exist
m
b
(Value)b
Extract
m
Boolean[]
(Start)i[(Length)i]
Fill
m

(Value)b[(Start)i(Length)i]
Find
m
i
(Value)b
Insert
m
Boolean[]
(Array)Boolean[];[(Pos)i]
Pop
m
b

Push
m

(Value)b
Read
m

(Stream)Stream;[(Start)i(Length)i]
Sort
m
Boolean[]
[(Mode)i]
Write
m

(Stream)Stream;[(Start)i(Length)i]
_get
m
b
(Index)i.
_new
m

[(Size)i.]
_next
m
b

_put
m

(Value)b(Index)i.
#Byte[]
Array
C
Add
m

(Value)c[(Index)i]
Copy
m
Byte[]
[(Start)i(Length)i]
Delete
m
Byte[]
(Start)i[(Length)i]
Exist
m
b
(Value)c
Extract
m
Byte[]
(Start)i[(Length)i]
Fill
m

(Value)c[(Start)i(Length)i]
Find
m
i
(Value)c
Insert
m
Byte[]
(Array)Byte[];[(Pos)i]
Pop
m
c

Push
m

(Value)c
Read
m

(Stream)Stream;[(Start)i(Length)i]
Sort
m
Byte[]
[(Mode)i]
Write
m

(Stream)Stream;[(Start)i(Length)i]
_get
m
c
(Index)i.
_new
m

[(Size)i.]
_next
m
c

_put
m

(Value)c(Index)i.
#Class


Constant
C
i
5
Event
C
i
4
Method
C
i
3
Property
C
i
2
Variable
C
i
1
Load
M
Class
(Name)s
_get
m
.Symbol
(Name)s
Component
r
Component

Count
r
i

Hidden
r
b

Instance
r
o

Name
r
s

Native
r
b

Parent
r
Class

Symbols
r
.ClassSymbols

#Classes


_get
M
Class
(Name)s
_next
M
Class

Count
R
i

#Collection

C
Add
m

(Value)v(Key)s
Clear
m


Exist
m
b
(Key)s
Remove
m

(Key)s
_free
m


_get
m
v
(Key)s
_new
m

[(Mode)i]
_next
m
v

_put
m

(Value)v(Key)s
Count
r
i

Key
r
s

Length
r
i

#Component


Load
M
Component
(Name)s
Path
R
s

UserPath
R
s

Name
r
s

#Components


Load
M
Component
(Name)s
_get
M
Component
(Name)s
_next
M
Component

Count
R
i

#Date[]
Array
C
Add
m

(Value)d[(Index)i]
Copy
m
Date[]
[(Start)i(Length)i]
Delete
m
Date[]
(Start)i[(Length)i]
Exist
m
b
(Value)d
Extract
m
Date[]
(Start)i[(Length)i]
Fill
m

(Value)d[(Start)i(Length)i]
Find
m
i
(Value)d
Insert
m
Date[]
(Array)Date[];[(Pos)i]
Pop
m
d

Push
m

(Value)d
Read
m

(Stream)Stream;[(Start)i(Length)i]
Sort
m
Date[]
[(Mode)i]
Write
m

(Stream)Stream;[(Start)i(Length)i]
_get
m
d
(Index)i.
_new
m

[(Size)i.]
_next
m
d

_put
m

(Value)d(Index)i.
#Enum


Stop
M


_next
M


Index
P
v

_free
m


#Error


Clear
M


Propagate
M


Raise
M

(Message)s
Backtrace
R
String[]

Class
R
Class

Code
R
i

Text
R
s

Where
R
s

#File
Stream

:Read
:


:Write
:


BaseName
M
s
(Path)s
Dir
M
s
(Path)s
Ext
M
s
(Path)s
Load
M
s
(FileName)s
Name
M
s
(Path)s
Save
M

(FileName)s(Data)s
SetBaseName
M
s
(Path)s(NewBaseName)s
SetDir
M
s
(Path)s(NewDir)s
SetExt
M
s
(Path)s(NewExt)s
SetName
M
s
(Path)s(NewName)s
Err
R
File

In
R
File

Out
R
File

_free
m


#Float[]
Array
C
Add
m

(Value)f[(Index)i]
Copy
m
Float[]
[(Start)i(Length)i]
Delete
m
Float[]
(Start)i[(Length)i]
Exist
m
b
(Value)f
Extract
m
Float[]
(Start)i[(Length)i]
Fill
m

(Value)f[(Start)i(Length)i]
Find
m
i
(Value)f
Insert
m
Float[]
(Array)Float[];[(Pos)i]
Pop
m
f

Push
m

(Value)f
Read
m

(Stream)Stream;[(Start)i(Length)i]
Sort
m
Float[]
[(Mode)i]
Write
m

(Stream)Stream;[(Start)i(Length)i]
_get
m
f
(Index)i.
_new
m

[(Size)i.]
_next
m
f

_put
m

(Value)f(Index)i.
#Integer[]
Array
C
Add
m

(Value)i[(Index)i]
Copy
m
Integer[]
[(Start)i(Length)i]
Delete
m
Integer[]
(Start)i[(Length)i]
Exist
m
b
(Value)i
Extract
m
Integer[]
(Start)i[(Length)i]
Fill
m

(Value)i[(Start)i(Length)i]
Find
m
i
(Value)i
Insert
m
Integer[]
(Array)Integer[];[(Pos)i]
Pop
m
i

Push
m

(Value)i
Read
m

(Stream)Stream;[(Start)i(Length)i]
Sort
m
Integer[]
[(Mode)i]
Write
m

(Stream)Stream;[(Start)i(Length)i]
_get
m
i
(Index)i.
_new
m

[(Size)i.]
_next
m
i

_put
m

(Value)i(Index)i.
#Long[]
Array
C
Add
m

(Value)l[(Index)i]
Copy
m
Long[]
[(Start)i(Length)i]
Delete
m
Long[]
(Start)i[(Length)i]
Exist
m
b
(Value)l
Extract
m
Long[]
(Start)i[(Length)i]
Fill
m

(Value)l[(Start)i(Length)i]
Find
m
i
(Value)l
Insert
m
Long[]
(Array)Long[];[(Pos)i]
Pop
m
l

Push
m

(Value)l
Read
m

(Stream)Stream;[(Start)i(Length)i]
Sort
m
Long[]
[(Mode)i]
Write
m

(Stream)Stream;[(Start)i(Length)i]
_get
m
l
(Index)i.
_new
m

[(Size)i.]
_next
m
l

_put
m

(Value)l(Index)i.
#Object


Attach
M

(Object)o(Parent)o(Name)s
Call
M
v
(Object)o(Method)s[(Arguments)Array;]
Class
M
Class
(Object)o
Count
M
i
(Object)o
Detach
M

(Object)o
GetProperty
M
v
(Object)o(Property)s
Is
M
b
(Object)o(Class)s
IsLocked
M
b
(Object)o
IsValid
M
b
(Object)o
Lock
M

(Object)o
New
M
o
(Class)s[(Arguments)Array;]
Parent
M
o
(Object)o
SetProperty
M

(Object)o(Property)s(Value)v
Type
M
s
(Object)o
Unlock
M

(Object)o
_LastEventName
R
s

#Object[]
Array
C
Add
m

(Value)o[(Index)i.]
Copy
m
Object[]
[(Start)i(Length)i]
Delete
m
Object[]
(Start)i[(Length)i]
Exist
m
b
(Value)o
Extract
m
Object[]
(Start)i[(Length)i]
Fill
m

(Value)o[(Start)i(Length)i]
Find
m
i
(Value)o
Insert
m
Object[]
(Array)Object[];[(Pos)i]
Pop
m
o

Push
m

(Value)o
Sort
m
Object[]
[(Mode)i]
_get
m
o
(Index)i.
_new
m

[(Size)i.]
_next
m
o

_put
m

(Value)o(Index)i.
#Observer

C
_free
m


_new
m

(Object)o[(After)b]
#Param


_get
M
v
(Index)i
_next
M
v

Count
R
i

Length
R
i

Max
R
i

Name
R
s

Property
R
b

#Pointer[]
Array
C
Add
m

(Value)p[(Index)i]
Copy
m
Pointer[]
[(Start)i(Length)i]
Delete
m
Pointer[]
(Start)i[(Length)i]
Exist
m
b
(Value)p
Extract
m
Pointer[]
(Start)i[(Length)i]
Fill
m

(Value)p[(Start)i(Length)i]
Find
m
i
(Value)p
Insert
m
Pointer[]
(Array)Pointer[];[(Pos)i]
Pop
m
p

Push
m

(Value)p
Read
m

(Stream)Stream;[(Start)i(Length)i]
Sort
m
Pointer[]
[(Mode)i]
Write
m

(Stream)Stream;[(Start)i(Length)i]
_get
m
p
(Index)i.
_new
m

[(Size)i.]
_next
m
p

_put
m

(Value)p(Index)i.
#Process
Stream

:Error
:

(Error)s
:Kill
:


:Read
:


Crashed
C
i
2
Running
C
i
1
Signaled
C
i
2
Stopped
C
i
0
_exit
M


LastState
R
i

LastValue
R
i

Kill
m


Signal
m


Wait
m


_free
m


_new
m


Tag
p
v

Handle
r
i

Id
r
i

State
r
i

Value
r
i

#Quote


Shell
M
s
(String)s
_call
M
s
(String)s
#Short[]
Array
C
Add
m

(Value)h[(Index)i]
Copy
m
Short[]
[(Start)i(Length)i]
Delete
m
Short[]
(Start)i[(Length)i]
Exist
m
b
(Value)h
Extract
m
Short[]
(Start)i[(Length)i]
Fill
m

(Value)h[(Start)i(Length)i]
Find
m
i
(Value)h
Insert
m
Short[]
(Array)Short[];[(Pos)i]
Pop
m
h

Push
m

(Value)h
Read
m

(Stream)Stream;[(Start)i(Length)i]
Sort
m
Short[]
[(Mode)i]
Write
m

(Stream)Stream;[(Start)i(Length)i]
_get
m
h
(Index)i.
_new
m

[(Size)i.]
_next
m
h

_put
m

(Value)h(Index)i.
#Single[]
Array
C
Add
m

(Value)g[(Index)i]
Copy
m
Single[]
[(Start)i(Length)i]
Delete
m
Single[]
(Start)i[(Length)i]
Exist
m
b
(Value)g
Extract
m
Single[]
(Start)i[(Length)i]
Fill
m

(Value)g[(Start)i(Length)i]
Find
m
i
(Value)g
Insert
m
Single[]
(Array)Single[];[(Pos)i]
Pop
m
g

Push
m

(Value)g
Read
m

(Stream)Stream;[(Start)i(Length)i]
Sort
m
Single[]
[(Mode)i]
Write
m

(Stream)Stream;[(Start)i(Length)i]
_get
m
g
(Index)i.
_new
m

[(Size)i.]
_next
m
g

_put
m

(Value)g(Index)i.
#Stat


_free
m


Group
r
s

Hidden
r
b

LastAccess
r
d

LastChange
r
d

LastModified
r
d

Link
r
s

Mode
r
i

Path
r
s

Perm
r
.FilePerm

SetGID
r
b

SetUID
r
b

Size
r
l

Sticky
r
b

Time
r
d

Type
r
i

User
r
s

#Stream


Close
m


ByteOrder
p
i

EndOfLine
p
i

EndOfFile
r
b

Handle
r
i

Id
r
i

#String


Byte
M
i
(String)s(Index)i
Chr
M
s
(Unicode)i
Chr$
M
s
(Unicode)i
Code
M
i
(String)s[(Index)i]
Comp
M
i
(String)s(String2)s[(Mode)i]
InStr
M
i
(String)s(Pattern)s[(From)i]
Index
M
i
(String)s(Byte)i
LCase
M
s
(String)s
LCase$
M
s
(String)s
Left
M
s
(String)s[(Length)i]
Left$
M
s
(String)s[(Length)i]
Len
M
i
(String)s
Lower
M
s
(String)s
Lower$
M
s
(String)s
Mid
M
s
(String)s(Start)i[(Length)i]
Mid$
M
s
(String)s(Start)i[(Length)i]
Pos
M
i
(String)s(Index)i
RInStr
M
i
(String)s(Pattern)s[(From)i]
Right
M
s
(String)s[(Length)i]
Right$
M
s
(String)s[(Length)i]
UCase
M
s
(String)s
UCase$
M
s
(String)s
Upper
M
s
(String)s
Upper$
M
s
(String)s
#String[]
Array
C
Add
m

(Value)s[(Index)i]
Copy
m
String[]
[(Start)i(Length)i]
Delete
m
String[]
(Start)i[(Length)i]
Exist
m
b
(Value)s[(Mode)i]
Extract
m
String[]
(Start)i[(Length)i]
Fill
m

(Value)s[(Start)i(Length)i]
Find
m
i
(Value)s[(Mode)i]
Insert
m
String[]
(Array)String[];[(Pos)i]
Join
m
s
[(Separator)s(Escape)s]
Pop
m
s

Push
m

(Value)s
Sort
m
String[]
[(Mode)i]
_get
m
s
(Index)i.
_new
m

[(Size)i.]
_next
m
s

_put
m

(Value)s(Index)i.
#System


Language
P
s

Backtrace
R
String[]

ByteOrder
R
i

Charset
R
s

Domain
R
s

Host
R
s

Path
R
s

RightToLeft
R
b

User
R
User

Version
R
s

#Timer

C
:Timer
:


_DefaultEvent
C
s
Timer
_Properties
C
s
Enabled,Delay{Range:0;86400000;10;ms}=1000
Start
m


Stop
m


Trigger
m


_free
m


_new
m


Delay
p
i

Enabled
p
b

#UnQuote


_call
M
s
(String)s
#User


Group
R
i

Home
R
s

Id
R
i

Name
R
s

#Variant[]
Array
C
Add
m

(Value)v[(Index)i]
Copy
m
Variant[]
[(Start)i(Length)i]
Delete
m
Variant[]
(Start)i[(Length)i]
Extract
m
Variant[]
(Start)i[(Length)i]
Fill
m

(Value)v[(Start)i(Length)i]
Insert
m
Variant[]
(Array)Variant[];[(Pos)i]
Pop
m
v

Push
m

(Value)v
_get
m
v
(Index)i.
_new
m

[(Size)i.]
_next
m
v

_put
m

(Value)v(Index)i.
#gb


Ascent
C
i
0
BigEndian
C
i
1
Binary
C
i
0
Boolean
C
i
1
Byte
C
i
2
Case
C
i
1
Class
C
i
14
Currency
C
i
6
Date
C
i
8
Day
C
i
4
Descent
C
i
16
Device
C
i
3
Directory
C
i
2
Exec
C
i
1
File
C
i
1
Fixed
C
i
3
Float
C
i
7
Friday
C
i
5
GeneralDate
C
i
8
GeneralNumber
C
i
2
Hour
C
i
3
Integer
C
i
4
International
C
i
7
Language
C
i
2
Link
C
i
6
LittleEndian
C
i
0
Long
C
i
5
LongDate
C
i
9
LongTime
C
i
12
Mac
C
i
2
MediumDate
C
i
10
MediumTime
C
i
13
Minute
C
i
2
Monday
C
i
1
Month
C
i
7
NewLine
C
s
\n
Null
C
i
15
Object
C
i
16
Percent
C
i
4
Pipe
C
i
4
Quarter
C
i
8
Read
C
i
4
Saturday
C
i
6
Scientific
C
i
5
Second
C
i
1
Short
C
i
3
ShortDate
C
i
11
ShortTime
C
i
14
Single
C
i
6
Socket
C
i
5
Standard
C
i
1
String
C
i
9
Sunday
C
i
0
Tab
C
s
\t
Text
C
i
1
Thursday
C
i
4
Tuesday
C
i
2
Unix
C
i
0
Variant
C
i
11
Wednesday
C
i
3
Week
C
i
5
WeekDay
C
i
6
Windows
C
i
1
Write
C
i
2
Year
C
i
9
