Home

Strings

 

Introduction to Strings

 

Overview

As seen in Lesson 3, a string is one or a combination of characters. To declare a variable for it, you can use either the String or the Object data types. To initialize the variable, put its value in double-quotes and assign it to the variable. Here are examples:

Public Module Exercise

    Public Function Main() As Integer
        Dim FirstName As Object
        Dim LastName As String

        FirstName = "William"
        LastName = "Sansen"

        Return 0
    End Function

End Module

String Concatenation

As seen in Lesson 2, string concatenation consists of adding one string to another. to support this operation, you can use either the + or the & operator. Here are examples:

Public Module Exercise

    Public Function Main() As Integer
        Dim FirstName As Object
        Dim LastName As String
        Dim FullName As String

        FirstName = "William"
        LastName = "Sansen"
        FullName  = LastName + ", " & FirstName

        MsgBox("Full Name: " & FullName)
        Return 0
    End Function

End Module

This would produce:

String

If you have many strings to add to a primary string, you can use either the += or the &= operator. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim FullName As String

        FullName   = "Sansen"
        FullName += ", "
        FullName += "William"

        MsgBox("Full Name: " & FullName)
        Return 0
    End Function

End Module
 

Characters

 

Introduction

In Lesson 3, we have a brief introduction to strings. We learned that a string was a combination of characters. An example of a string would be: "Production". If you have such a string, you may be interested in the individual characters it contains. In Lesson 3, we also saw that, to convert an expression to a character, you can call the CChar() function. Its syntax is:

Function CChar(ByVal Expression As Object) As Char

This function takes a value as argument. The argument must be convertible to a character. If so, the function returns a character.

Getting the ASCII Character of a Number

The characters used in the US English and the most common characters of Latin-based languages are created in a list or map of character codes. Each character is represented with a small number between 0 and 255. This means that each character must fit in a byte.

To help you find the equivalent ASCII character of such a number, the Visual Basic language provides a function named Chr. Its syntax is:

Public Function Chr(ByVal CharCode As Integer) As Char

When calling this function, pass a small number as argument. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Character As Char
        Dim Number As Integer

        Number = 114
        Character = Chr(Number)

        MsgBox("The ASCII character of " & Number & " is " & Character)
        Return 0
    End Function

End Module

This would produce:

Character

Besides finding the ASCII equivalent of a number, the Chr() function can be used to apply some behavior in a program. For example, a combination of Chr(13) and Chr(10) would break a line in an expression, which is equivalent to the vbCrLf operator.

Getting the Wide ASCII Character of a Number

If you pass a number lower than 0 or higher than 255 to the Chr() function, you would receive an error. The reason you may pass a number higher than 255 is that you may want to get a character beyond those of US English, such as . To support such numbers, the Visual Basic language provides another version of the function. Its syntax is:

Public Function ChrW(ByVal CharCode As Integer) As Char

The W here represents Wide Character. This makes it possible to store the character in the memory equivalent to the Short integer data type, which can hold numbers from -32768 to 32767. Normally, you should consider that the character should fit in a Char data type,, which should be a positive number between 0 and 65535.

Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Character As Char
        Dim Number As Short

        Number = 358
        Character = ChrW(Number)

        MsgBox("The ASCII character of " & Number & " is " & Character)
        Return 0
    End Function

End Module

This would produce:

Wide Character

The Length of a String

One of the most fundamental characteristics of a string is the number of characters it contains. This number is referred to as the length of a string. To assist you with finding the length of a string, the Visual Basic language provides a function named Len. Its syntax is:

Public Shared Function Len(ByVal Expression As String) As Integer

This function expects a string as argument. If the function succeeds in counting the number of characters, which it usually does, it returns the an integer. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Item As String
        Dim Length As Integer

        Item = "Television"
        Length = Len(Item)

        MsgBox("The number of characters in """ & Item & """ is " & Length)
        Return 0
    End Function

End Module

This would produce:

Length

Characters, Strings, and Procedures

 

Passing a Character or a String to a Procedure

Like a normal value, a character or a string can be passed to a procedure. When creating the procedure, enter the argument and its name in the parentheses of the procedure. Then, in the body of the procedure, use the argument as you see fit. Here is an example:

Public Module Exercise

    Private Sub Show(ByVal Gdr As Char)
        MsgBox(Gdr)
    End Sub

End Module

When calling the procedure, you can pass a value for the argument in double-quotes. Here is an example:

Public Module Exercise

    Private Sub Show(ByVal Sex As Char)
        MsgBox(Sex)
    End Sub

    Public Function Main() As Integer
        
        Show("F")
        
       Return 0
    End Function

End Module

In the same way, you can apply any of the features we studied for procedures, including passing as many arguments as you want or passing a mixture of characters, strings, and other types of arguments. You can also create a procedure that receives an optional argument.

Returning a Character or a String From a Function

To create a function that returns a character or a string, create the procedure using the Function keyword and, on the right side of the parentheses, include the Char or String data type preceded by the As keyword. Here is an example we saw in Lesson 5:

Public Module Exercise

    Function GetFullName$()
        Dim FirstName$, LastName$

        FirstName = InputBox("Enter First Name: ")
        LastName = InputBox("Enter Last Name: ")

        Return LastName & ", " & FirstName
    End Function

End Module

When calling the function, you can use it as a normal procedure or you can retrieve the value it returns and use it as you see fit. Here is an example:

Public Module Exercise

    Function GetFullName$()
        Dim FirstName$, LastName$

        FirstName = InputBox("Enter First Name: ")
        LastName = InputBox("Enter Last Name: ")

        GetFullName = LastName & ", " & FirstName
    End Function

    Private Sub Show(ByVal Name As String, ByVal Gdr As String)
        MsgBox("=-= Student Registration =-=" & vbCrLf & _
               "Full Name: " & Name & vbCrLf & _
               "Gender: " & vbTab & Gdr)
    End Sub

    Public Function Main() As Integer
        Dim FullName As String

        FullName = GetFullName()
        
        Show(FullName, "Unknown")
        Return 0
    End Function

End Module

Here is an example of executing the program:

String

String

In the same way, you can apply any of the features of procedures and functions we studied in Lessons 5 and 6.

The Characters of a String

 

Getting the Character From its Position in a String

As mentioned already, a string is a combination of symbols or characters. An example is "Television". Each character in a string has an indexed position from 1 to its last character:

T e l e v i s i o n
1 2 3 4 5 6 7 8 9 10

To find out what character occupies a certain position inside of a string, you can call the GetChar() function. Its syntax is:

Public Shared Function GetChar( _
   ByVal str As String, _
   ByVal Index As Integer _
) As Char

The first argument is the string that will be considered. If you pass this argument as an empty string or Nothing, you would receive an error.

The second argument is the position to be consider inside the string. The value must be between 1 and the length of the string. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Item As String

        Item = "Television"

        MsgBox("The character at position 5 is " & GetChar(Item, 5))
        Return 0
    End Function

End Module

This would produce:

GetChar

Getting the ASCII Numeric Equivalent of a Character

If you have a character and want to find its equivalent character, you can call the Asc() function. Its syntax is:

Public Overloads Function Asc(ByVal String As Char) As Integer

This function takes a character as argument. If the function is successful, it returns the numeric equivalent. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Character As Char
        Dim Number As Integer

        Character = "W"
        Number = Asc(Character)

        MsgBox("The number of " & Character & " is " & Number)
        Return 0
    End Function

End Module

This would produce:

The Asc Function

 

Character and String Conversions

 

Introduction

In Lesson 3, we saw that, to convert an expression to a string, you can call the CStr() function. Its syntax is:

Public Function CStr(ByVal Expression As Object) As String

The argument can be almost any expression but the compiler has to be able to convert it to a string, which in most cases it can. If it is successful, the function returns a string. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim DateHired As Date

        DateHired = #1/4/2005#

        MsgBox("Date Hired: " & CStr(DateHired))
        Return 0
    End Function

End Module

This would produce:

Conversion to String

The CStr() function is used to convert any type of value to a string. If the value to be converted is a number, you can use the Str() function. Its syntax is:

Public Shared Function Str(ByVal Number As Object) As String

This function expects a number as argument. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Number As Double

        Number = 1450.5 / 2

        MsgBox("1450.50 / 2 =  " & Str(Number))
        Return 0
    End Function

End Module

This would produce:

Conversion to String

Numeric Hexadecimal Conversion

In Lesson 3, we saw that the Visual Basic language supports hexadecimal number and we saw how to initialize an integer variable with a hexadecimal number. Now, on the other hand, if you have a decimal number but need it in hexadecimal format, you can convert it. To support this operation, you can call the Hex() function. Its syntax is:

Public Shared Function Hex( _
   ByVal Number As { Byte | SByte | Short | UShort |
   Integer | UInteger | Long | ULong | Object } _
) As String

This function is used to convert either an integer-based or a decimal number to its hexadecimal equivalent. It returns the result as a string. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Number As UInteger

        Number = 286345
        MsgBox(CStr(Number) & " in hexadecimal format is " & Hex(Number))

        Return 0
    End Function

End Module

This would produce:

Hexadecimal

Numeric Octal Conversion

If you have a decimal number you want to convert to its octal format, you can call the Oct() function. Its syntax is:

Public Shared Function Oct( _
   ByVal Number As { Byte | SByte | Short | UShort | _
   Integer | UInteger | Long | ULong | Object } _
) As String

This function takes an integer-based or a decimal number and converts its octal equivalent. It returns the result as a string. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Number As Integer

        Number = 286345
        MsgBox(CStr(Number) & " in octal format is " & Oct(Number))

        Return 0
    End Function

End Module

This would produce:

Octal

Case Conversion

If you are presented with a string or an expression whose cases must be the same, you can convert all of its characters in either uppercase or lowercase.

To convert a character, a string or an expression to uppercase, you can call the UCase() function. These functions take one argument as the string or expression to be considered. The syntaxes are:

Public Shared Function UCase(ByVal Value As Char) As Char
Public Shared Function UCase(ByVal Value As String) As String

The first version receives a character as argument. If the character is already in uppercase, it would be returned the same. If the character is not a readable character, no conversion would happen and the function would return it. If the character is in lowercase, it would be converted to uppercase and the function would then return the uppercase equivalent.

The second version considers the argument supplied as a string. Any letter that is in lowercase in the string would be converted to uppercase. Any letter that is in uppercase would be preserved and would not be changed. Any non-alphabetic character in the string would be kept "as is".

Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim ProgrammingEnvironment As String

        ProgrammingEnvironment = "Microsoft Visual Basic 2008 Express Edition"

        MsgBox(UCase(ProgrammingEnvironment))
        Return 0
    End Function

End Module

This would produce:

Case Conversion

To convert a character or a string to lowercase, you can call the LCase() function. It is overloaded in two versions whose syntaxes are:

Public Shared Function LCase(ByVal Value As Char) As Char
Public Shared Function LCase(ByVal Value As String) As String

The first version receives a character as argument. If the character is not a readable symbol, it would be kept "as is". If the character is in lowercase, it would not be converted. If the character is in uppercase, it would be converted to lowercase.

The second version of the function receives a string as argument. Any letter in uppercase in the string would be converted to lowercase. Any letter that is in lowercase would not be changed. Any non-alphabetic character in the string would be kept "as is".

The Sub-Strings of a String

 

Introduction

A sub-string is a character or a group of characters or symbols that are part of an existing string. The Visual Basic language provides functions to create, manipulate or manage sub-strings. The primary rule to keep in mind is that a sub-string is part of, and depends on, a string. In other words, you cannot have a sub-string if you do  not have a string in the first place.

The Left Sub-String of a String

If you have an existing string but want to create a new string using a number of characters from the left side characters of the string, you can use the Left() function. Its syntax is:

Public Shared Function Left( ByVal str As String,   ByVal Length As Integer) As String

The function takes two arguments and both are required. The first argument is the existing string. The second argument is the number of characters counted from the left side of the string. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Process As String

        Process = "learning"

        MsgBox("To " & Left(Process, 5) & " is to gain understanding")
        Return 0
    End Function

End Module

This would produce:

Left

The Right Sub-String of a String

To create a new string using one or more characters from the right side of an existing string, call a function named Right. Its syntax is:

Public Shared Function Right(ByVal str As String, ByVal Length As Integer) As String

Both arguments are required. The first argument is the original string. The second argument is the number of characters counted from the right side of the string. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim ProgrammingEnvironment As String

        ProgrammingEnvironment = "Microsoft Visual Basic"

        MsgBox("Q" & Right(ProgrammingEnvironment, 5) & " in MS DOS 5.2")
        Return 0
    End Function

End Module

This would produce:

Right

 

The Mid Sub-String of a String

You may want to create a string using some characters eight from the left, from the right, or from somewhere inside an existing string. To assist you with this, the Visual Basic language provides a function named Mid. Its syntax is:

Public Module Exercise

    Public Function Main() As Integer
        Dim ProgrammingEnvironment As String

        ProgrammingEnvironment = "Microsoft Visual Basic 2008 Express Edition"

        MsgBox("The " & Mid(ProgrammingEnvironment, 10, 13) & " language")
        Return 0
    End Function

End Module

This would produce:

Mid

Finding a Sub-String

One of the most regular operations you will perform on a string consists of finding out whether it contains a certain character or a certain contiguous group of characters. To help you with this operation, the Visual Basic language provides the InStr() function. It is overloaded with two versions whose syntaxes are:

Public Shared Function InStr(_
   ByVal String1 As String, _
   ByVal String2 As String, _
   Optional ByVal Compare As CompareMethod _
) As Integer
' -or-
Public Shared Function InStr(_
   ByVal Start As Integer, _
   ByVal String1 As String, _
   ByVal String2 As String, _
   Optional ByVal Compare As Microsoft.VisualBasic.CompareMethod _
) As Integer

In the first version of the function, the String1 argument is the string on which the operation will be performed. The String2 argument is the character or the sub-string to look for. If String2 is found in String1 (as part of String1), the function return the position of the first character. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim ProgrammingEnvironment As String

        ProgrammingEnvironment = "Microsoft Visual Basic Express Edition"

        MsgBox("In " & ProgrammingEnvironment & ", ""Basic"" is found at position " & _
                     InStr(ProgrammingEnvironment, "Basic"))
        Return 0
    End Function

End Module

This would produce:

In String

The first version of the function asks the interpreter to check String1 from the left looking for String2. If String1 contains more than one instance of String2, the function returns (only) the position of the first instance. Any other subsequent instance would be ignored. If you want to skip the first instance or want the interpreter to start checking from a position other than the left character, use the second version. In this case, the Start argument allows you to specify the starting position from where to start looking for String2 in String1.

The InStr() function is used to start checking a string from the left side. If you want to start checking from the right side, call the InStrRev() function. Its syntax is:

Public Function InStrRev(
   ByVal StringCheck As String,
   ByVal StringMatch As String,
   Optional ByVal Start As Integer = -1,
   Optional ByVal Compare As CompareMethod = CompareMethod.Binary
) As Integer

Replacing a Character or a Sub-String in a String

After finding a character or a sub-string inside of a string, you can take action on it. One of the operations you can perform consists of replacing that character or that sub-string with another character or a sub-string. To do this, the Visual Basic language provides the Replace() function. Its syntax is:

Public Function Replace(
   ByVal Expression As String,
   ByVal Find As String,
   ByVal Replacement As String,
   Optional ByVal Start As Integer = 1,
   Optional ByVal Count As Integer = -1,
   Optional ByVal Compare As CompareMethod = CompareMethod.Binary
) As String

The first argument is the string on which the operation will be performed. The second argument is the character or string to look for in the Expression. If that character or string is found, the third argument is the character or string to replace it with. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim ProgrammingEnvironment As String

        ProgrammingEnvironment = "Microsoft Visual Basic 2008 Express Edition"

        MsgBox(Replace(ProgrammingEnvironment, "Basic", "C++"))
        Return 0
    End Function

End Module

This would produce:

Formatting a Value

 

Introduction

So far, after performing a calculation, we were presenting the result "as is". To appropriately display a value, the Visual Basic language provides a function named Format. This function can be used for different types of values The most basic technique consists of passing it an expression that holds the value to display. The syntax of this function is:

Public Shared Function Format( _
   ByVal Expression As Object, _
   Optional ByVal Style As String = "" _
) As String

As mentioned above, this function can be used in various scenarios. The simplest way to use this function is to pass it a number, a string, or a date/time). The function would then produce that number.

Besides the Format() function, the Visual Basic language provides some additional functions we will review below.

Formatting a Number

So far, to display a number, we simply passed it to the MsgBox() function or to another procedure. In some cases, you may want the number to display in a particular format. To control how the number should display, you can pass the second argument of the Format() function. This argument would be passed as a string.

To produce the number in a general format, you can pass the second argument as "g", "G", "f", or "F" .

To display the number with a decimal separator, pass the second argument as "n", "N", or "Standard". Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Number As Double

        Number = 20502.48

        MsgBox("Number: " & Format(Number, "STANDARD"))
        Return 0
    End Function

End Module

This would produce:

Format

An alternative to get this format is to call a function named FormatNumber. Its syntax is:

Function FormatNumber(
   ByVal Expression As Object,
   Optional ByVal NumDigitsAfterDecimal As Integer = -1,
   Optional ByVal IncludeLeadingDigit As TriState = TriState.UseDefault,
   Optional ByVal UseParensForNegativeNumbers As TriState = TriState.UseDefault,
   Optional ByVal GroupDigits As TriState = TriState.UseDefault
) As String

Only the first argument is required and it represents the value to display. If you pass only this argument, you get the same format as the Format() function called with the Standard option. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Number As Double

        Number = 20502.48

        MsgBox("Number: " & Format(Number, "STANDARD"))
        MsgBox("Number: " & FormatNumber(Number))
        Return 0
    End Function

End Module

This would produce the same result as above.

If you call the Format() function with the Standard option, it would consider only the number of digits on the right side of the decimal separator. If you want to display more digits than the number actually has, call the FormatNumber() function and pass a second argument with the desired number. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Number As Double

        Number = 20502.48

        MsgBox("Number: " & Format(Number, "STANDARD") & vbCrLf & _
               "Number: " & FormatNumber(Number, 4))
        Return 0
    End Function

End Module

This would display:

Format Number

In the same way, if you want the number to display with less numbers on the right side of the decimal separator, specify that number.

As a third alternative, you can call the Format() function. In reality, the second argument is used to format the number with many more options. To represent the integral part of a number, you use the # sign. To specify the number of digits to display on the right side of the decimal separator, type a period on the right side of # followed by the number of 0s representing each decimal place. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Number As Double

        Number = 20502.48

        MsgBox("Number: " & Format(Number, "#.00000"))
        Return 0
    End Function

End Module

The five 0s on the right side of the period indicate that you want to display 5 digits on the right side of the period. This would produce:

Format

You can enter as many # signs as you want; it wouldn't change anything. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Number As Double

        Number = 20502.48

        MsgBox("Number: " & Format(Number, "##########.00000"))
        Return 0
    End Function

End Module

This would produce the same result as above. To specify that you want to display the decimal separator, include its character between the # signs. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Number As Double

        Number = 20502.48

        MsgBox("Number: " & Format(Number, "###,#######.00000"))
        Return 0
    End Function

End Module

This would produce:

Format

You can include any other character or symbol you want in the string to be part of the result, but you should include such a character only at the beginning or the end of the string, otherwise the interpreter might give you an unexpected result.

Getting a Currency Number

Another regular type of number used in applications and finances is the currency. A currency value uses a special character specified in the Control Panel. In US English, this character would be the $ sign:

Customize Regional Options

Of course, to display a symbol in the result, you can simply add it as part of the second argument to the Format() function. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Number As Double

        Number = 205.5

        MsgBox("Number: " & Format(Number, "$###,#######.00"))
        Return 0
    End Function

End Module

This would produce:

Fortunately, there are more professional options. Besides the Format() function, to support currency formatting of a number, the Visual Basic language provides the FormatCurrency() function. Its syntax is:

Function FormatCurrency(
   ByVal Expression As Object,
   Optional ByVal NumDigitsAfterDecimal As Integer = -1,
   Optional ByVal IncludeLeadingDigit As TriState = TriState.UseDefault,
   Optional ByVal UseParensForNegativeNumbers As TriState = TriState.UseDefault,
   Optional ByVal GroupDigits As TriState = TriState.UseDefault
) As String

Only the first argument is required. It is the value that needs to be formatted. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim UnitPrice As Double

        UnitPrice = 1450.5

        MsgBox("Dress Price: " & FormatCurrency(UnitPrice))
        Return 0
    End Function

End Module

This would produce:

Format

Notice that, by default, the FormatCurrency() function is equipped to display the currency symbol (which in US English is the $ sign), the decimal separator (which is US English is the comma), and two decimal digits. If you want to control how many decimal digits are given to the result, pass a second argument as an integer. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim UnitPrice As Double

        UnitPrice = 1450.5

        MsgBox("Dress Price: " & FormatCurrency(UnitPrice, 4))
        Return 0
    End Function

End Module

Instead of calling the FormatCurrency() function to format a number to currency, you can use the Format() function. If you do, pass it a second argument as "Currency", "c", or "C". Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim CarPrice As Double

        CarPrice = 42790

        MsgBox("Car Price: " & Format(CarPrice, "Currency"))
        Return 0
    End Function

End Module

This would produce:

Format

Formatting a Percentage Value

A percentage of a number represents its rate on a scale, usually of 100 (or more). The number is expressed using digits accompanied by the % sign. Besides the Format() function, to support currency formatting, the Visual Basic language provides a function named FormatPercent. Its syntax is:

Function FormatPercent(
   ByVal Expression As Object,
   Optional ByVal NumDigitsAfterDecimal As Integer = -1,
   Optional ByVal IncludeLeadingDigit As TriState = TriState.UseDefault,
   Optional ByVal UseParensForNegativeNumbers As TriState = TriState.UseDefault,
   Optional ByVal GroupDigits As TriState = TriState.UseDefault
) As String

Only the first argument is required and it is the number that needs to be formatted. When calling this function, pay attention to the number you provide as argument. If the number represents a percentage value as a fraction of 0 to 1, make sure you provide it as such. An example would be 0.25. In this case, the Visual Basic interpreter would multiply the value by 100 to give the result. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim DiscountRate As Double

        DiscountRate = 0.25

        MsgBox("Discount Rate: " & FormatPercent(DiscountRate))
        Return 0
    End Function

End Module

This would produce:

Format

On the other hand, if you pass the value in the hundreds, the interpreter would still multiply it by 100. Although it is not impossible to get a percentage value in the hundreds or thousands, you should make sure that's the type of value you mean to get.

Besides the FormatPercent() function, to format a number to its percentage equivalent, you can call the Format() function and pass the second argument as "Percent", "p", or "P". Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim DiscountRate As Double

        DiscountRate = 0.25

        MsgBox("Discount Rate: " & Format(DiscountRate, "Percent"))
        Return 0
    End Function

End Module

 

 

Previous Copyright 2008 Yevol Next