Featured

The Lewis Dot Structure for HCN

by 11:03 AM
Created by MakeTheBrainHappy

The molecule HCN has one of the most fascinating lewis structures. It is one of the few which features a nitrogen triple bond. It is possible to draw the structure with two electrons in place of the lines to represent the covalent bonds, which would result in there being six shared electrons between the carbon and nitrogen. We know that hydrogen can only share one bond with the carbon as we looked at in a previous article. Hydrogen essentially only needs two valence electrons to fill its outer shell because it only has a 1s orbital. The carbon, based on its position in the periodic table, has four electrons to share which it does with the nitrogen. The total number of "shared" electrons equals eight, filling carbon's valence shell. The nitrogen's "shared electron" count is six, which means that it needs two more electrons to fill its shell which is accounted for by the lone pair. Furthermore, this brings the total number of electrons on nitrogen to five as the periodic table predicts. 

HCN has a linear geometry but unlike nonpolar CO2 is polar due to the intrinsic electronegativity on nitrogen and the stronger force by Coulomb's law pulling on the electrons in the triple bond creating a more negative bent on the right (based on the diagram) than the left. This means that it undergoes dipole-dipole interactions not unlike water (h2o). Water's intermolecular bonds are considered to be stronger hydrogen bonds (H-F, H-N, H-O bonds) due to these having the largest electronegativity difference. By this logic, HCN dipole-dipole interactions are also weaker the intramolecular bonds in network covalent solids. Nevertheless, these stronger intermolecular forces contribute to its boiling point at room temperature, or approximately 26˚C.
Structure of HCN from Wikimedia Commons. Source

While HCN is produced as a precursor to many molecules and chemicals, the compound itself is extremely flammable and poisonous. It can be produced by combining hydrogen chloride (HCl) and Sodium Cyanide (NaCN). Often described as a pale or blue colorless liquid, it has a distinctive scent that will warn those of its toxicity. Furthermore, it is a weak acid that partially ionizes in water. 

HCN's structure also features an sp hybridized structure with 180˚ of difference between the two molecules on the end. The triple bond contains one sigma bond and two pi bonds. Such a simple molecule can in the end still contain more complex chemistry.

Source:



Primitive Data Types in Java

by 6:20 PM
Graphic with the eight primitive data types by MakeTheBrainHappy.
Java has eight primitive data types:

Byte: integer value (8 bits)

Short: integer value (16 bits)

Int: integer value (32 bits)

Long: integer value (64 bits)

Float: floating point # (32 bits)

Double: floating point # (64 bits)

Character: one unicode character

Booleans: a true or false value

A larger number of bits corresponds to a larger number which can be stored into those variables.

Declaring Primitives:


byte varName;
short VarName;
int varname;
long Varname;
float vArname;
double vArName;
char varNAme;
boolean varNAMe;

These variables can be then be assigned using the = operator to values fitting the descriptions for each of the primitive data types.

Reserved Keywords:

Java has certain reserved keywords that cannot be utilized as variable names due to their special functions within the language. These are abstract, assert, boolean, break, byte, case, catch, char, class, const, default, do, double, else, enum, extends, false, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, null, package,  private, protected, public, return, short, static, strictfp, super, switch, synchronized,  this, throw, throws, transient, true, try, void, volatile, while, and continue.

Visibility Modifiers:

Variables can either be declared as public or private, reserved keywords which are placed in front of the type. Public variables can be accessed by all classes while private variables can only be utilized by the class in which they are declared.

Static vs. Non-Static Variables:

This keyword, also placed before the type but after the visibility modifier, determines whether the variable is a part of the object declared from the class (thereby only being accessible through the identifiers of an object) as opposed to static variables are a part of the class and therefore can be accessed from "static" contexts such as the main method or static methods.

Casting

Some variables can be changed from one type to another through casting. Between the six types dealing with numerical values, you can cast utilizing the casting operator placed before the variable name. For example, here is a variable being converted from a integer to a double.


int varname = 1;
double newDouble = (double)varname;

This is a widening conversion since a more restrictive data type is changed to a more free version; therefore, no data is lost. But if you are converting a double to an integer, you would lose the information encoded by the decimals. This means that this would be a narrowing conversation.

Numerical Methods: Estimating Integrals and the Trapezoidal Rule

7:46 PM
The magnitude of an integral in 2D can be geometrically interpreted as the area bounded by y=f(x) and the independent variable x between an interval set by x. The positivity/negativity of the resulting integral is determined by how much area is over/under the x-axis such that any area over the x-axis adds to the value of the integral, and vice-versa. Thus, using basic geometry we are able to estimate/determine the value of an integral using common area formulas we already know, even integrals whose answer cannot be represented by elementary functions.

Many methods to estimate the area under a function evaluates the integral of simpler sub-curves that resembles the original function. Essentially, the curve is broken up into different sub-intervals and a simpler curve that estimates the original curve is created for each sub-interval. The curves made are generally a polynomial since polynomials are easy to integrate. Then, the integral of sub-curve in each sub-interval is evaluated and summed together. The result is an approximation of the integral of the entire curve.

Some notable and widely used methods include the Riemann sum which uses horizontal lines to estimate the integral, trapezoidal rule which use lines, and Simpson's 1/3 and 3/8 rule which uses degree two and three polynomials, respectively. It is important to note that estimating the integral of the overall curve then boils down to the integration of the sub-curves. If the area bounded by the sub-curve in each sub-interval and the x-axis is a simple shape (i.e. rectangles for the Riemann sum or polygons for the trapezoidal rule) then the integral of each sub-curve can be geometrically represented by such area.

Figure 1: The area under the curve in black is approximated using the (left) Riemann sum (in red), trapezoidal rule (in yellow) and the Simpson's 1/3 rule (in green). Note the number of sub-intervals in this case is two, and each different method uses different polymeric curves to resemble the shape of the original curve.
In figure 1 it is evident that the maximum error of the estimate decreases as we increase the degree of the polynomial used to estimate the curve. It is also the case that the larger the amount of sub-intervals, the smaller the maximum error. These properties are generally true for any function.

The Trapezoidal Rule

The trapezoidal rule is one of the easiest methods to estimate the value of an integral. It uses lines to approximate the shape of a curve. Then, the integration of all such lines results in an estimation. The trapezoidal rule is also simple to use since the equations are simple and the number of sub-intervals chosen does not have additional restrictions other than being positive (e.g. Simpson's 1/3 rule requires the number of sub-intervals to be even).

Figure 2: Graphical explanation of the trapezoidal rule: two sub-intervals $[x_0,x_1]$ and $[x_1,x_2]$ are created as $n=2$. A line is drawn from $f(x_0)$ to $f(x_1)$ and from $f(x_1)$ to $f(x_2)$. The sum of the integral of the lines (shaded in yellow) gives the estimated value of the function's integral. 

Derivation

We briefly discuss a geometric derivation of the trapezoidal rule. Suppose we have an integral that spans from $x_0=a$ to $x_n=b$. We assume the function is continuous over the interval. We can partition such interval $[a,b]$ into $n$ smaller sub-intervals such that $a = x_0 \lt x_1 \lt \dots \lt x_i \lt \dots \lt x_{n-1} \lt x_n=b$. Define $\Delta x_i$ to be $x_i - x_{i-1}$. For each sub-interval $[x_{i-1},x_i]$ if $f(x_i)$ and $f(x_{i-1}) \geq 0$ then the integral is given by the area bounded by the curve and x-axis in the interval. The curve in the sub-interval is estimated to be a linear line between the bounds of the sub-interval evaluated at the function. Thus, the area bounded by the line and the x-axis in the interval is determined to be $$I_i \approx \frac{f(x_i)+f(x_{i-1})}{2}\Delta x_i \label{eq:1} \tag{1}$$
For $f(x_i)$ and $f(x_{i-1}) \leq 0$ the integral is estimated using the same method as above, and is the negative of the area. Thus it is $-\frac{|f(x_i)+f(x_{i-1})|}{2}\Delta x_i$. This equals to equation \ref{eq:1} since $f(x_i)$ and $f(x_{i-1}) \leq 0$. If $f(x_i)$ and $f(x_{i-1})$ have opposing signs, we can further break up the sub-interval. There only exists one point $x_k$ where $f(x_k)=0$ due to the intermediate value theorem and the fact that a line can only pass the x-axis once or an infinite amount of times. The estimated integral of the function in $[x_{i-1},x_i]$ is determined to be:
\begin{align*}I_i &\approx \frac{f(x_k)+f(x_{i-1})}{2}(x_k-x_{i-1})+\frac{f(x_i)+f(x_k)}{2}(x_i-x_k)\\
&=\frac{f(x_{i-1})}{2}(x_k-x_{i-1})+\frac{f(x_i)}{2}(x_i-x_k)\\\end{align*}By similar triangles we see that $x_k-x_{i-1}=-\frac{f(x_{i-1})\Delta x_i}{f(x_i)-f(x_{i-1})}$ and $x_i-x_k=\frac{f(x_i)\Delta x_i}{f(x_i)-f(x_{i-1})}$ so
\begin{align*}I_i &\approx -\frac{f^2(x_{i-1})}{2(f(x_i)-f(x_{i-1}))}\Delta x_i+\frac{f^2(x_i)}{2(f(x_i)-f(x_{i-1}))}\Delta x_i\\
&=\frac{f^2(x_i)-f^2(x_{i-1})}{2(f(x_i)-f(x_{i-1}))}\Delta x_i\\
&=\frac{f(x_i)+f(x_{i-1})}{2}\Delta x_i\\\end{align*}
Therefore regardless of the nature of the function in any sub-interval, the integral in $[x_{i-1},x_i]$ is estimated to be equation \ref{eq:1}.
The integral of the overall curve in the interval $[a,b]$ is the sum of all the estimated integrals in each sub-interval, explicitly:
$$I = \sum_{i=1}^{n} I_i$$
$$I \approx \sum_{i=1}^{n} \frac{f(x_{i-1})+f(x_{i})}{2}\Delta x_i \label{eq:2} \tag{2}$$

If the sub-intervals are evenly spaced, then
$$I \approx \frac{b-a}{2n}\sum_{i=1}^{n} \big(f(x_{i-1})+f(x_i)\big)$$
$$I \approx \frac{b-a}{2n} \bigg(f(x_0)+f(x_n)+2\sum_{i=1}^{n-1} f(x_{i})\bigg) \label{eq:3} \tag{3}$$

Equations \ref{eq:2} and \ref{eq:3} are the final forms used in this numerical method.

Implementation

Implementation of the trapezoidal rule is relatively straightforward. One thing to note is that the higher the number of sub-intervals, the better the accuracy however it is important to realize that the higher the number, the more prominent round-off errors get. Generally the round-off errors associated to this method are negligible assuming the number of intervals don't get ridiculously large. It is recommended to calculate and use the minimum number of sub-intervals to achieve a desired maximum error using this formula. Then as the integration bounds change, it is generally recommended to triple the number of sub-intervals for the doubling of the integration interval; this will keep the maximum error relatively the same assuming the maximum concavity of the function in the new interval change stays constant compared to the old one.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
function f(x)
return math.sin(x)/x
end

a=1 --lower bound
b=3 --upper bound
n=5000 --number of sub-intervals

sum=0
for i=1,n do
xi=((b-a)*i/n)+a
xi1=((b-a)*(i-1)/n)+a
sum=sum+(f(xi)+f(xi1))*((b-a)/(2*n))
end

print(sum)
Figure 3: Lua code for the implementation of the trapezoidal rule. Note the estimation of a non-elementary integral sin(x)/x.


Exercises

  1. Using the error formula for the trapezoidal rule what is the equation that gives the maximum possible error for the integral $\int^{x}_{0} t^3+e^{t}~dt$ using $n$ equal sub-intervals? What is the formula for the exact error?
  2. Prove that the trapezoidal rule, for any number of sub-intervals greater or equal to 1,
    1. overestimates a parabola's integral if it faces upward.
    2. perfectly estimates the integral for functions of the form $y=ax+b$.
  3. Use the trapezoidal rule with $n=4$ to estimate $\int_{0}^{5}5x-5~dx$.
  4. Estimate the integral from $\pi$ to $2\pi$ of $\frac{\sin(x)}{x}$ with the minimum number of sub-intervals such that the maximum error is no more than 0.05.
  5. For batch/simple distillation where a binary liquid mixture is boiled and condensed into a receiving flask, the equation $\ln\Big(\frac{W}{F}\Big)=-\int_{x_w}^{x_f}\frac{dx}{y-x}$ is important to quantify the ending amounts of liquid in both containers and its respective concentrations. $x$ is related to $y$ as provided in the table below:
  6. Figure 4: Table of values for question 5.
    If $x_w=0.02, x_f=0.20$, and $F=1$, estimate $W$, the remaining liquid in the feed pot in mols. [1]
  7. Derive equation \ref{eq:1} using
    1. a geometric approach.
    2. a mathematical approach.
  8. Using one sub-interval with the trapezoidal rule to estimate certain functions is sometimes more accurate than using two or more intervals. Provide a function that shows this.
  9. Refer to Figure 1 and identify the numerical method that estimates the integral
    1. the most poorly?
    2. the most accurately?
    3. the quickest, if calculated manually?
    4. the slowest, if calculated manually?
  10. Refer to the equation \ref{eq:3} and the equation directly above it. Why is it more efficient to use equation \ref{eq:3} rather than the other one, especially when manually evaluating the formula?
  11. We've seen different methods that can be used to estimate the integral of a curve. The ones mentioned use polynomials of varying degrees to resemble the shape of the original curve. Referring to Figure 5 and considering all the methods presented in this article, which method would be the best (efficiency and accuracy wise) at estimating the integral of the functions from $x=1$ to $x=5$? For each function,
    1. is equation \ref{eq:2} or \ref{eq:3} more useful?
    2. how many sub-intervals would you choose?
    3. where would you partition the sub-intervals?
Figure 5: Question 10 graphs - which method would be the best (efficiency and accuracy wise) at estimating the integral of the following functions?

[1] Question adapted from Prof. R. Pal from the University of Waterloo, Ontario.

Images belong to KrIsMa. HTML code format generated using hilite.me.

ALIRA Unofficial Practice Test 1

by 8:30 AM
The ALIRA Test is a reading comprehension test for Latin with a variety of passages ranging from historical narratives to modern articles. Scores are measured on a range from N1-5 to A with I1-5 in between. You can see a sample score report here. The Language Testing International Organization has released a practice exam, available here. This practice exam is based on the structure of the official sample test, providing those interested with unofficial materials to study with. The questions generally increase in difficulty as you move through the texts and are taken from a wide range of sources. Currently, there is no way to assess the level of each question, but generally the first questions are equivalent to novice levels and the final questions are equivalent to the intermediate levels. Good Luck!


Source: Lingua Latīna Per Sē Illūstrāta Pars I: Familia Rōmāna


Which of the following would the ships trade with?
A.) Oppidum
B.) Fluvius
C.) Insula
D.) None of the Above

The image above is related to
A.) Funerals
B.) Schools
C.) Marriages
D.) Economics


Source: Wheelock’s Sixth Edition


Whom is Martial addressing?
A.) Himself
B.) Fidentius
C.) a Male
D.) Recitas


“In primis annis Romani habuerunt reges. Reges fuerunt Etrusci. Etrusci erant in throno Romano.”
Source: Latin by the Natural Method
Who ruled Rome?
A.) The Romans
B.) The Etruscans
C.) Roman Kings
D.) Etruscan Kings


Source: The Latin Wikipedia News Page


What happens to the Capital?
A.) The citizens recreate it like it was in 1991
B.) The president gave an address in Astana
C.) The capital city was renamed to “Nursultan”
D.) The president left office.


Source: Western Washington University


What is the origin of the cold air?
A.) Canada
B.) Mississippi
C.) Louisiana
D.) Georgia




What is going on in this passage?
A.) The Roman Senate debates going to war with Carthage
B.) The Carthaginian Senate debates going to war with Rome
C.) The Carthaginian Senate discusses the command of Hasdrubal
D.) The Carthaginian Senate discusses the command of Hannibal


Source: Via Latin; An Easy Latin Reader


Why did Pelias wish to kill Jason?
A.) He wanted to become king
B.) He felt that Jason was a danger to the Kingdom
C.) He had abducted the king
D.) He didn’t.


Source: A First Latin Reader (1912)


What prevented Columbus from traveling on the sea?
A.) Family Obligations
B.) Money
C.) Care
D.) Danger


Source: Fabulae Facilis


What did Laomedon not wish to do?
A.) Be in the favor of Neptune and Apollo
B.) Pay for the services of Neptune and Apollo
C.) Ask Neptune and Apollo for good fortune
D.) Increase tribute to Neptune and Apollo


Eo nomine senatus decretis honorificis in ordinem suum me adlegit, C. Pansa et A. Hirtio consulibus, consularem locum sententiae dicendae tribuens, et imperium mihi dedit. Res publica ne quid detrimenti caperet, me propraetore simul cum consulibus providere iussit. Populus autem eodem anno me consulem, cum cos. uterque bello cecidisset, et triumvirum rei publicae constituendae creavit. - Octavian
Source: Res Gestae Divi Augusti


With what rank did Octavian gain imperium?
A.) Tribune
B.) Propraetor
C.) Consulship
D.) Triumvir

Answer Key (highlight it): 1.) A 2.) B 3.) B 4.) D 5.) C 6.) A 7.) D 8.) A 9.) B 10.) B 11.) B

Minesweeper in Java

by 12:45 PM
Minesweeper is a video game where you are trying to clear a "board" while avoiding the hidden traps. There are individual squares which serve as these traps; all of the other squares are defined by the number of traps adjacent to that square. This means that a non-trap square can have a maximum value of eight (although this is highly unlikely). (Source). Here is an example of minesweeper wit a 2D GUI (Graphical User Interface): http://minesweeperonline.com/

This implementation utilizes 2D arrays but does not include a graphical user interface. For this java code, the "9" represents a trap or bomb while -1 represents a spot on the board which isn't visible. Therefore the original board looks like this:


This version also does not include any method to "flow" and reveal all zeroes adjacent to one another. Therefore, you need to reveal each square one at a time.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
public class MinesweeperGame {
    private int rows;
    private int columns;
    private int mines;
    private int board[][];
    private int visibleBoard[][];

    public MinesweeperGame(int inputRows, int inputColumns, int inputMines) { // Service Constructor
        rows = inputRows;
        columns = inputColumns;
        mines = inputMines;
        visibleBoard = new int[rows][columns];
        board = this.createBoard();
        board = populateBoard(board);
        visibleBoard();
    }

    public int playerInteract(int inputRow, int inputColumn) { // Determines the result of an interaction with the board and changes all components appropriately
        if (board[inputRow][inputColumn] == 9) {
            return 2;
        }
        else {
            visibleBoard[inputRow][inputColumn] = board[inputRow][inputColumn];
        }
        for (int i = 0; i< rows; i++) { // Checks for a win, if they haven't won yet, then they need to keep playing
            for (int j = 0; j < columns; j++) {
                if (board[i][j] != 9) {
                    if (visibleBoard[i][j] == board[i][j]) {
                        visibleBoard[i][j] = visibleBoard[i][j];
                    }
                    else {
                        return 0;
                    }
                }
            }
        }
        return 1;
    }

    public void getVisibleBoard() {
        printBoard(visibleBoard);
    } // Calls the "visible" board, i.e. what the player can see
    public void getBoard() {
        printBoard(board);
    } // Calls the master board with all of the answers

    private int[][] createBoard(){ // Helper Method to instantiate the board
        int temp[][] = new int[rows][columns];
        return temp;
    }

    private int[][] populateBoard(int inputBoard[][]) { // Helper Method to randomly place mines
        while (mines != 0) {
            int a = (int)(Math.random()*rows);
            int b = (int)(Math.random()*columns);
            if (inputBoard[a][b] == 0) {
                inputBoard[a][b] = 9;
                mines -= 1;
            }
        }

        for(int i = 0; i < rows; i++) { // This section then assigns each space of number based on the surrounding mines.
            for (int j = 0; j < columns; j++) {
                if (inputBoard[i][j] != 9) {
                    int tempMines = 0;
                    if ((j - 1) != -1) {
                        if (inputBoard[i][j - 1] == 9) {
                            tempMines += 1;
                        }
                    }
                    if ((i - 1) != -1) {
                        if (inputBoard[i - 1][j] == 9) {
                            tempMines += 1;
                        }
                    }
                    if ((i - 1) != -1 && (j - 1) != -1) {
                        if (inputBoard[i - 1][j - 1] == 9) {
                            tempMines += 1;
                        }
                    }
                    if ((i - 1) != -1 && (j + 1) != columns) {
                        if (inputBoard[i - 1][j + 1] == 9) {
                            tempMines += 1;
                        }
                    }
                    if ((i + 1) != rows) {
                        if (inputBoard[i + 1][j] == 9) {
                            tempMines += 1;
                        }
                    }
                    if ((j + 1) != columns) {
                        if (inputBoard[i][j + 1] == 9) {
                            tempMines += 1;
                        }
                    }
                    if ((i + 1) != rows && (j + 1) != columns) {
                        if (inputBoard[i + 1][j + 1] == 9) {
                            tempMines += 1;
                        }
                    }
                    if ((i + 1) != rows && (j - 1) != -1) {
                        if (inputBoard[i + 1][j - 1] == 9) {
                            tempMines += 1;
                        }
                    }
                    inputBoard[i][j] = tempMines;
                }
            }
        }
        return (inputBoard);
    }

    private void printBoard(int inputBoard[][]) { // Prints the board in a neat matrix fashion
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                System.out.print(inputBoard[i][j] + "   ");
            }
            System.out.println();
        }
    }

    private void visibleBoard() { // Generates a blank "visible board"
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                visibleBoard[i][j] = -1;
            }
        }
        printBoard(visibleBoard);
    }

}

Here is the driver class for the above game. This version is very customizable; the user selects the # of traps and the dimensions of the board. Furthermore, this edition does not have an option to replay the game; it automatically shuts down after a win or loss.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import java.util.Scanner;

public class MinesweeperPlayer {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Please enter three positive constants (the # of rows | the # of columns | the # of mines): ");
        int rows = sc.nextInt();
        int columns = sc.nextInt();
        int mines = sc.nextInt();
        System.out.println("Please note that mines are represented by the # 9 while -1 refers to 'hidden' spaces");
        System.out.println("");
        MinesweeperGame game = new MinesweeperGame(rows, columns, mines); // Creates the game
        System.out.println("");
        System.out.println("Let's get started!");
        int x = 0;
        while (x != -1) { // Actually plays the game
            System.out.println("");
            System.out.println("Please select a row | column to examine (zero-based indexing please): ");
            int inputRow = sc.nextInt();
            int inputColumn = sc.nextInt();
            int y = game.playerInteract(inputRow, inputColumn); // User input to select square
            if (y == 2) { // Response System: Win, Hit or Miss
                System.out.println("");
                System.out.println("You have hit a mine!");
                System.out.println("");
                game.getBoard();
                System.exit(0); // Exits after the game is complete
            }
            if (y == 1) {
                System.out.println("");
                System.out.println("You won! Congratulations");
                System.out.println("");
                game.getBoard();
                System.exit(0); // Exits after the game is complete
            }
            if (y == 0) {
                System.out.println("");
                System.out.println("Here is the board for reference. Play you next move wisely.");
                System.out.println("");
                game.getVisibleBoard(); // Continues if the game has not been completed. 
            }
        }
    }
}

Thank you to http://hilite.me/ for the source code formatting.
Powered by Blogger.