InitialObjectDescriptor {
  objectDescriptorID 1
  ODProfileLevelIndication 1
  sceneProfileLevelIndication 1
  audioProfileLevelIndication 1
  visualProfileLevelIndication 1
  graphicsProfileLevelIndication 1

  esdescr [
    ES_Descriptor {
      es_id 1
      decConfigDescr DecoderConfigDescriptor {
				streamType 3
				decSpecificInfo BIFSv2Config {
				  isCommandStream true
				  pixelMetric true
				  pixelWidth 400
				  pixelHeight 400
				}
      }
    }
  ]
}

OrderedGroup {
	children [
		Background2D {
			backColor 1 1 1
		}
		DEF TimeOutSensor TimeSensor {
			enabled FALSE
			cycleInterval 0.15
		}			
		Transform2D {
			translation 0 180
			children [
				DEF StartTS TouchSensor {}
				Shape {
					geometry Rectangle { size 100 25 }
					appearance Appearance { material Material2D { emissiveColor 0.5 0.5 0.5 filled TRUE } }
				}
				Shape { 
					appearance Appearance { 
						material Material2D { 
							filled TRUE
							emissiveColor 1 0 0					
						}
					}
					geometry Text { 
						string [ "Start Game" ]
						fontStyle FontStyle {
							size 20			
							justify ["MIDDLE" "MIDDLE"]
						}
					}
				}
			]
		}
		Switch {
			whichChoice -1
			choice [
				DEF BlankPiece Transform2D {
					children [
						DEF BackRectangle Shape {
							geometry DEF R Rectangle { size 42 42 }
							appearance Appearance { 
								material Material2D { 
									filled TRUE 
									emissiveColor 0 0.5 0.5
								}
							}
						}	
						Shape {
							geometry DEF C Circle { radius 18 }
							appearance Appearance { 
								material Material2D { 
									filled TRUE 
									emissiveColor 0 0.5 0.5
								}
							}
						}
					]
				}
				DEF WhitePiece Transform2D {
					children [
						USE BackRectangle
						DEF WhiteC Shape {
							geometry USE C
							appearance Appearance { 
								material Material2D { 
									filled TRUE 
									emissiveColor 1 1 1 
								} 
							}
						}
					]
				}
				DEF WhiteTransPiece Transform2D {
					children [
						USE BackRectangle
						USE WhiteC
					]
				}
				DEF BlackPiece Transform2D {
					children [
						USE BackRectangle 
						DEF BlackC Shape {
							geometry USE C
							appearance Appearance { 
								material Material2D { 
									filled TRUE 
									emissiveColor 0 0 0 
								} 
							}
						}
					]
				}
				DEF BlackTransPiece Transform2D {
					children [
						USE BackRectangle 	
						USE BlackC
					]
				}
				DEF Trans1 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "1" ]
								fontStyle DEF TFS FontStyle {
									size 20
									justify [ "MIDDLE" "MIDDLE" ]
								}
							}
							appearance DEF TA Appearance { 
								material Material2D { 
									filled TRUE 
									emissiveColor 0 1 0 
								} 
							}
						}
					]
				}
				DEF Trans2 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "2" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans3 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "3" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans4 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "4" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans5 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "5" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans6 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "6" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans7 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "7" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans8 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "8" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans9 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "9" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans10 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "10" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans11 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "11" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans12 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "12" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans13 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "13" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans14 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "14" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans15 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "15" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans16 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "16" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans17 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "17" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans18 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "18" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans19 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "19" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans20 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "20" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				DEF Trans21 Transform2D {
					children [
						USE BackRectangle 	
						Shape {
							geometry Text {
								string [ "21" ]
								fontStyle USE TFS
							}
							appearance USE TA 
						}
					]
				}
				
			]
		}
		DEF Board Form {
			size 345 345
			groups [ 
				 1 -1  2 -1  3 -1  4 -1  5 -1  6 -1  7 -1  8 -1 
				 9 -1 10 -1 11 -1 12 -1 13 -1 14 -1 15 -1 16 -1 
				17 -1 18 -1 19 -1 20 -1 21 -1 22 -1 23 -1 24 -1
				25 -1 26 -1 27 -1 28 -1 29 -1 30 -1 31 -1 32 -1
				33 -1 34 -1 35 -1 36 -1 37 -1 38 -1 39 -1 40 -1
				41 -1 42 -1 43 -1 44 -1 45 -1 46 -1 47 -1 48 -1
				49 -1 50 -1 51 -1 52 -1 53 -1 54 -1 55 -1 56 -1
				57 -1 58 -1 59 -1 60 -1 61 -1 62 -1 63 -1 64 -1
				 1  2  3  4  5  6  7  8 -1 
				 9 10 11 12 13 14 15 16 -1
				17 18 19 20 21 22 23 24 -1
				25 26 27 28 29 30 31 32 -1
				33 34 35 36 37 38 39 40 -1
				41 42 43 44 45 46 47 48 -1
				49 50 51 52 53 54 55 56 -1
				57 58 59 60 61 62 63 64 -1
			]
			groupsIndex [ 
				 1  2  3  4  5  6  7  8 -1 
				 9 10 11 12 13 14 15 16 -1
				17 18 19 20 21 22 23 24 -1
				25 26 27 28 29 30 31 32 -1
				33 34 35 36 37 38 39 40 -1
				41 42 43 44 45 46 47 48 -1
				49 50 51 52 53 54 55 56 -1
				57 58 59 60 61 62 63 64 -1
				65 66 67 68 69 70 71 72 -1
			]
			constraints [ 
				"SHin" 
				"SHin" 
				"SHin" 
				"SHin" 
				"SHin" 
				"SHin" 
				"SHin" 
				"SHin" 
				"SVin" 
			]
			children [
				Transform2D {
					children [
						DEF TS00 TouchSensor {}
						USE BlankPiece
						DEF V00_Over Valuator {}
						DEF V00_Out Valuator {}
						DEF V00_Click Valuator {}
						DEF C00_Over Conditional {
							buffer {
								REPLACE V00_Over.inSFVec2f BY 0 0 
							}
						}
						DEF C00_Out Conditional {
							buffer {
								REPLACE V00_Out.inSFVec2f BY 0 0
							}
						}
						DEF C00_Click Conditional {
							buffer {
								REPLACE V00_Click.inSFVec2f BY 0 0
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS01 TouchSensor {}
						USE BlankPiece
						DEF V01_Over Valuator {}
						DEF V01_Out Valuator {}
						DEF V01_Click Valuator {}
						DEF C01_Over Conditional {
							buffer {
								REPLACE V01_Over.inSFVec2f BY 0 1 
							}
						}
						DEF C01_Out Conditional {
							buffer {
								REPLACE V01_Out.inSFVec2f BY 0 1
							}
						}
						DEF C01_Click Conditional {
							buffer {
								REPLACE V01_Click.inSFVec2f BY 0 1
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS02 TouchSensor {}
						USE BlankPiece
						DEF V02_Over Valuator {}
						DEF V02_Out Valuator {}
						DEF V02_Click Valuator {}
						DEF C02_Over Conditional {
							buffer {
								REPLACE V02_Over.inSFVec2f BY 0 2 
							}
						}
						DEF C02_Out Conditional {
							buffer {
								REPLACE V02_Out.inSFVec2f BY 0 2
							}
						}
						DEF C02_Click Conditional {
							buffer {
								REPLACE V02_Click.inSFVec2f BY 0 2
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS03 TouchSensor {}
						USE BlankPiece
						DEF V03_Over Valuator {}
						DEF V03_Out Valuator {}
						DEF V03_Click Valuator {}
						DEF C03_Over Conditional {
							buffer {
								REPLACE V03_Over.inSFVec2f BY 0 3 
							}
						}
						DEF C03_Out Conditional {
							buffer {
								REPLACE V03_Out.inSFVec2f BY 0 3
							}
						}
						DEF C03_Click Conditional {
							buffer {
								REPLACE V03_Click.inSFVec2f BY 0 3
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS04 TouchSensor {}
						USE BlankPiece
						DEF V04_Over Valuator {}
						DEF V04_Out Valuator {}
						DEF V04_Click Valuator {}
						DEF C04_Over Conditional {
							buffer {
								REPLACE V04_Over.inSFVec2f BY 0 4 
							}
						}
						DEF C04_Out Conditional {
							buffer {
								REPLACE V04_Out.inSFVec2f BY 0 4
							}
						}
						DEF C04_Click Conditional {
							buffer {
								REPLACE V04_Click.inSFVec2f BY 0 4
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS05 TouchSensor {}
						USE BlankPiece
						DEF V05_Over Valuator {}
						DEF V05_Out Valuator {}
						DEF V05_Click Valuator {}
						DEF C05_Over Conditional {
							buffer {
								REPLACE V05_Over.inSFVec2f BY 0 5 
							}
						}
						DEF C05_Out Conditional {
							buffer {
								REPLACE V05_Out.inSFVec2f BY 0 5
							}
						}
						DEF C05_Click Conditional {
							buffer {
								REPLACE V05_Click.inSFVec2f BY 0 5
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS06 TouchSensor {}
						USE BlankPiece
						DEF V06_Over Valuator {}
						DEF V06_Out Valuator {}
						DEF V06_Click Valuator {}
						DEF C06_Over Conditional {
							buffer {
								REPLACE V06_Over.inSFVec2f BY 0 6 
							}
						}
						DEF C06_Out Conditional {
							buffer {
								REPLACE V06_Out.inSFVec2f BY 0 6
							}
						}
						DEF C06_Click Conditional {
							buffer {
								REPLACE V06_Click.inSFVec2f BY 0 6
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS07 TouchSensor {}
						USE BlankPiece
						DEF V07_Over Valuator {}
						DEF V07_Out Valuator {}
						DEF V07_Click Valuator {}
						DEF C07_Over Conditional {
							buffer {
								REPLACE V07_Over.inSFVec2f BY 0 7 
							}
						}
						DEF C07_Out Conditional {
							buffer {
								REPLACE V07_Out.inSFVec2f BY 0 7
							}
						}
						DEF C07_Click Conditional {
							buffer {
								REPLACE V07_Click.inSFVec2f BY 0 7
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS10 TouchSensor {}
						USE BlankPiece
						DEF V10_Over Valuator {}
						DEF V10_Out Valuator {}
						DEF V10_Click Valuator {}
						DEF C10_Over Conditional {
							buffer {
								REPLACE V10_Over.inSFVec2f BY 1 0 
							}
						}
						DEF C10_Out Conditional {
							buffer {
								REPLACE V10_Out.inSFVec2f BY 1 0
							}
						}
						DEF C10_Click Conditional {
							buffer {
								REPLACE V10_Click.inSFVec2f BY 1 0
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS11 TouchSensor {}
						USE BlankPiece
						DEF V11_Over Valuator {}
						DEF V11_Out Valuator {}
						DEF V11_Click Valuator {}
						DEF C11_Over Conditional {
							buffer {
								REPLACE V11_Over.inSFVec2f BY 1 1 
							}
						}
						DEF C11_Out Conditional {
							buffer {
								REPLACE V11_Out.inSFVec2f BY 1 1
							}
						}
						DEF C11_Click Conditional {
							buffer {
								REPLACE V11_Click.inSFVec2f BY 1 1
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS12 TouchSensor {}
						USE BlankPiece
						DEF V12_Over Valuator {}
						DEF V12_Out Valuator {}
						DEF V12_Click Valuator {}
						DEF C12_Over Conditional {
							buffer {
								REPLACE V12_Over.inSFVec2f BY 1 2 
							}
						}
						DEF C12_Out Conditional {
							buffer {
								REPLACE V12_Out.inSFVec2f BY 1 2
							}
						}
						DEF C12_Click Conditional {
							buffer {
								REPLACE V12_Click.inSFVec2f BY 1 2
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS13 TouchSensor {}
						USE BlankPiece
						DEF V13_Over Valuator {}
						DEF V13_Out Valuator {}
						DEF V13_Click Valuator {}
						DEF C13_Over Conditional {
							buffer {
								REPLACE V13_Over.inSFVec2f BY 1 3 
							}
						}
						DEF C13_Out Conditional {
							buffer {
								REPLACE V13_Out.inSFVec2f BY 1 3
							}
						}
						DEF C13_Click Conditional {
							buffer {
								REPLACE V13_Click.inSFVec2f BY 1 3
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS14 TouchSensor {}
						USE BlankPiece
						DEF V14_Over Valuator {}
						DEF V14_Out Valuator {}
						DEF V14_Click Valuator {}
						DEF C14_Over Conditional {
							buffer {
								REPLACE V14_Over.inSFVec2f BY 1 4 
							}
						}
						DEF C14_Out Conditional {
							buffer {
								REPLACE V14_Out.inSFVec2f BY 1 4
							}
						}
						DEF C14_Click Conditional {
							buffer {
								REPLACE V14_Click.inSFVec2f BY 1 4
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS15 TouchSensor {}
						USE BlankPiece
						DEF V15_Over Valuator {}
						DEF V15_Out Valuator {}
						DEF V15_Click Valuator {}
						DEF C15_Over Conditional {
							buffer {
								REPLACE V15_Over.inSFVec2f BY 1 5 
							}
						}
						DEF C15_Out Conditional {
							buffer {
								REPLACE V15_Out.inSFVec2f BY 1 5
							}
						}
						DEF C15_Click Conditional {
							buffer {
								REPLACE V15_Click.inSFVec2f BY 1 5
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS16 TouchSensor {}
						USE BlankPiece
						DEF V16_Over Valuator {}
						DEF V16_Out Valuator {}
						DEF V16_Click Valuator {}
						DEF C16_Over Conditional {
							buffer {
								REPLACE V16_Over.inSFVec2f BY 1 6 
							}
						}
						DEF C16_Out Conditional {
							buffer {
								REPLACE V16_Out.inSFVec2f BY 1 6
							}
						}
						DEF C16_Click Conditional {
							buffer {
								REPLACE V16_Click.inSFVec2f BY 1 6
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS17 TouchSensor {}
						USE BlankPiece
						DEF V17_Over Valuator {}
						DEF V17_Out Valuator {}
						DEF V17_Click Valuator {}
						DEF C17_Over Conditional {
							buffer {
								REPLACE V17_Over.inSFVec2f BY 1 7 
							}
						}
						DEF C17_Out Conditional {
							buffer {
								REPLACE V17_Out.inSFVec2f BY 1 7
							}
						}
						DEF C17_Click Conditional {
							buffer {
								REPLACE V17_Click.inSFVec2f BY 1 7
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS20 TouchSensor {}
						USE BlankPiece
						DEF V20_Over Valuator {}
						DEF V20_Out Valuator {}
						DEF V20_Click Valuator {}
						DEF C20_Over Conditional {
							buffer {
								REPLACE V20_Over.inSFVec2f BY 2 0 
							}
						}
						DEF C20_Out Conditional {
							buffer {
								REPLACE V20_Out.inSFVec2f BY 2 0
							}
						}
						DEF C20_Click Conditional {
							buffer {
								REPLACE V20_Click.inSFVec2f BY 2 0
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS21 TouchSensor {}
						USE BlankPiece
						DEF V21_Over Valuator {}
						DEF V21_Out Valuator {}
						DEF V21_Click Valuator {}
						DEF C21_Over Conditional {
							buffer {
								REPLACE V21_Over.inSFVec2f BY 2 1 
							}
						}
						DEF C21_Out Conditional {
							buffer {
								REPLACE V21_Out.inSFVec2f BY 2 1
							}
						}
						DEF C21_Click Conditional {
							buffer {
								REPLACE V21_Click.inSFVec2f BY 2 1
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS22 TouchSensor {}
						USE BlankPiece
						DEF V22_Over Valuator {}
						DEF V22_Out Valuator {}
						DEF V22_Click Valuator {}
						DEF C22_Over Conditional {
							buffer {
								REPLACE V22_Over.inSFVec2f BY 2 2 
							}
						}
						DEF C22_Out Conditional {
							buffer {
								REPLACE V22_Out.inSFVec2f BY 2 2
							}
						}
						DEF C22_Click Conditional {
							buffer {
								REPLACE V22_Click.inSFVec2f BY 2 2
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS23 TouchSensor {}
						USE BlankPiece
						DEF V23_Over Valuator {}
						DEF V23_Out Valuator {}
						DEF V23_Click Valuator {}
						DEF C23_Over Conditional {
							buffer {
								REPLACE V23_Over.inSFVec2f BY 2 3 
							}
						}
						DEF C23_Out Conditional {
							buffer {
								REPLACE V23_Out.inSFVec2f BY 2 3
							}
						}
						DEF C23_Click Conditional {
							buffer {
								REPLACE V23_Click.inSFVec2f BY 2 3
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS24 TouchSensor {}
						USE BlankPiece
						DEF V24_Over Valuator {}
						DEF V24_Out Valuator {}
						DEF V24_Click Valuator {}
						DEF C24_Over Conditional {
							buffer {
								REPLACE V24_Over.inSFVec2f BY 2 4 
							}
						}
						DEF C24_Out Conditional {
							buffer {
								REPLACE V24_Out.inSFVec2f BY 2 4
							}
						}
						DEF C24_Click Conditional {
							buffer {
								REPLACE V24_Click.inSFVec2f BY 2 4
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS25 TouchSensor {}
						USE BlankPiece
						DEF V25_Over Valuator {}
						DEF V25_Out Valuator {}
						DEF V25_Click Valuator {}
						DEF C25_Over Conditional {
							buffer {
								REPLACE V25_Over.inSFVec2f BY 2 5 
							}
						}
						DEF C25_Out Conditional {
							buffer {
								REPLACE V25_Out.inSFVec2f BY 2 5
							}
						}
						DEF C25_Click Conditional {
							buffer {
								REPLACE V25_Click.inSFVec2f BY 2 5
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS26 TouchSensor {}
						USE BlankPiece
						DEF V26_Over Valuator {}
						DEF V26_Out Valuator {}
						DEF V26_Click Valuator {}
						DEF C26_Over Conditional {
							buffer {
								REPLACE V26_Over.inSFVec2f BY 2 6 
							}
						}
						DEF C26_Out Conditional {
							buffer {
								REPLACE V26_Out.inSFVec2f BY 2 6
							}
						}
						DEF C26_Click Conditional {
							buffer {
								REPLACE V26_Click.inSFVec2f BY 2 6
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS27 TouchSensor {}
						USE BlankPiece
						DEF V27_Over Valuator {}
						DEF V27_Out Valuator {}
						DEF V27_Click Valuator {}
						DEF C27_Over Conditional {
							buffer {
								REPLACE V27_Over.inSFVec2f BY 2 7 
							}
						}
						DEF C27_Out Conditional {
							buffer {
								REPLACE V27_Out.inSFVec2f BY 2 7
							}
						}
						DEF C27_Click Conditional {
							buffer {
								REPLACE V27_Click.inSFVec2f BY 2 7
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS30 TouchSensor {}
						USE BlankPiece
						DEF V30_Over Valuator {}
						DEF V30_Out Valuator {}
						DEF V30_Click Valuator {}
						DEF C30_Over Conditional {
							buffer {
								REPLACE V30_Over.inSFVec2f BY 3 0 
							}
						}
						DEF C30_Out Conditional {
							buffer {
								REPLACE V30_Out.inSFVec2f BY 3 0
							}
						}
						DEF C30_Click Conditional {
							buffer {
								REPLACE V30_Click.inSFVec2f BY 3 0
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS31 TouchSensor {}
						USE BlankPiece
						DEF V31_Over Valuator {}
						DEF V31_Out Valuator {}
						DEF V31_Click Valuator {}
						DEF C31_Over Conditional {
							buffer {
								REPLACE V31_Over.inSFVec2f BY 3 1 
							}
						}
						DEF C31_Out Conditional {
							buffer {
								REPLACE V31_Out.inSFVec2f BY 3 1
							}
						}
						DEF C31_Click Conditional {
							buffer {
								REPLACE V31_Click.inSFVec2f BY 3 1
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS32 TouchSensor {}
						USE BlankPiece
						DEF V32_Over Valuator {}
						DEF V32_Out Valuator {}
						DEF V32_Click Valuator {}
						DEF C32_Over Conditional {
							buffer {
								REPLACE V32_Over.inSFVec2f BY 3 2 
							}
						}
						DEF C32_Out Conditional {
							buffer {
								REPLACE V32_Out.inSFVec2f BY 3 2
							}
						}
						DEF C32_Click Conditional {
							buffer {
								REPLACE V32_Click.inSFVec2f BY 3 2
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS33 TouchSensor {}
						USE WhitePiece
						DEF V33_Over Valuator {}
						DEF V33_Out Valuator {}
						DEF V33_Click Valuator {}
						DEF C33_Over Conditional {
							buffer {
								REPLACE V33_Over.inSFVec2f BY 3 3 
							}
						}
						DEF C33_Out Conditional {
							buffer {
								REPLACE V33_Out.inSFVec2f BY 3 3
							}
						}
						DEF C33_Click Conditional {
							buffer {
								REPLACE V33_Click.inSFVec2f BY 3 3
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS34 TouchSensor {}
						USE BlackPiece
						DEF V34_Over Valuator {}
						DEF V34_Out Valuator {}
						DEF V34_Click Valuator {}
						DEF C34_Over Conditional {
							buffer {
								REPLACE V34_Over.inSFVec2f BY 3 4 
							}
						}
						DEF C34_Out Conditional {
							buffer {
								REPLACE V34_Out.inSFVec2f BY 3 4
							}
						}
						DEF C34_Click Conditional {
							buffer {
								REPLACE V34_Click.inSFVec2f BY 3 4
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS35 TouchSensor {}
						USE BlankPiece
						DEF V35_Over Valuator {}
						DEF V35_Out Valuator {}
						DEF V35_Click Valuator {}
						DEF C35_Over Conditional {
							buffer {
								REPLACE V35_Over.inSFVec2f BY 3 5 
							}
						}
						DEF C35_Out Conditional {
							buffer {
								REPLACE V35_Out.inSFVec2f BY 3 5
							}
						}
						DEF C35_Click Conditional {
							buffer {
								REPLACE V35_Click.inSFVec2f BY 3 5
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS36 TouchSensor {}
						USE BlankPiece
						DEF V36_Over Valuator {}
						DEF V36_Out Valuator {}
						DEF V36_Click Valuator {}
						DEF C36_Over Conditional {
							buffer {
								REPLACE V36_Over.inSFVec2f BY 3 6 
							}
						}
						DEF C36_Out Conditional {
							buffer {
								REPLACE V36_Out.inSFVec2f BY 3 6
							}
						}
						DEF C36_Click Conditional {
							buffer {
								REPLACE V36_Click.inSFVec2f BY 3 6
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS37 TouchSensor {}
						USE BlankPiece
						DEF V37_Over Valuator {}
						DEF V37_Out Valuator {}
						DEF V37_Click Valuator {}
						DEF C37_Over Conditional {
							buffer {
								REPLACE V37_Over.inSFVec2f BY 3 7 
							}
						}
						DEF C37_Out Conditional {
							buffer {
								REPLACE V37_Out.inSFVec2f BY 3 7
							}
						}
						DEF C37_Click Conditional {
							buffer {
								REPLACE V37_Click.inSFVec2f BY 3 7
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS40 TouchSensor {}
						USE BlankPiece
						DEF V40_Over Valuator {}
						DEF V40_Out Valuator {}
						DEF V40_Click Valuator {}
						DEF C40_Over Conditional {
							buffer {
								REPLACE V40_Over.inSFVec2f BY 4 0 
							}
						}
						DEF C40_Out Conditional {
							buffer {
								REPLACE V40_Out.inSFVec2f BY 4 0
							}
						}
						DEF C40_Click Conditional {
							buffer {
								REPLACE V40_Click.inSFVec2f BY 4 0
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS41 TouchSensor {}
						USE BlankPiece
						DEF V41_Over Valuator {}
						DEF V41_Out Valuator {}
						DEF V41_Click Valuator {}
						DEF C41_Over Conditional {
							buffer {
								REPLACE V41_Over.inSFVec2f BY 4 1 
							}
						}
						DEF C41_Out Conditional {
							buffer {
								REPLACE V41_Out.inSFVec2f BY 4 1
							}
						}
						DEF C41_Click Conditional {
							buffer {
								REPLACE V41_Click.inSFVec2f BY 4 1
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS42 TouchSensor {}
						USE BlankPiece
						DEF V42_Over Valuator {}
						DEF V42_Out Valuator {}
						DEF V42_Click Valuator {}
						DEF C42_Over Conditional {
							buffer {
								REPLACE V42_Over.inSFVec2f BY 4 2 
							}
						}
						DEF C42_Out Conditional {
							buffer {
								REPLACE V42_Out.inSFVec2f BY 4 2
							}
						}
						DEF C42_Click Conditional {
							buffer {
								REPLACE V42_Click.inSFVec2f BY 4 2
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS43 TouchSensor {}
						USE BlackPiece
						DEF V43_Over Valuator {}
						DEF V43_Out Valuator {}
						DEF V43_Click Valuator {}
						DEF C43_Over Conditional {
							buffer {
								REPLACE V43_Over.inSFVec2f BY 4 3 
							}
						}
						DEF C43_Out Conditional {
							buffer {
								REPLACE V43_Out.inSFVec2f BY 4 3
							}
						}
						DEF C43_Click Conditional {
							buffer {
								REPLACE V43_Click.inSFVec2f BY 4 3
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS44 TouchSensor {}
						USE WhitePiece
						DEF V44_Over Valuator {}
						DEF V44_Out Valuator {}
						DEF V44_Click Valuator {}
						DEF C44_Over Conditional {
							buffer {
								REPLACE V44_Over.inSFVec2f BY 4 4 
							}
						}
						DEF C44_Out Conditional {
							buffer {
								REPLACE V44_Out.inSFVec2f BY 4 4
							}
						}
						DEF C44_Click Conditional {
							buffer {
								REPLACE V44_Click.inSFVec2f BY 4 4
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS45 TouchSensor {}
						USE BlankPiece
						DEF V45_Over Valuator {}
						DEF V45_Out Valuator {}
						DEF V45_Click Valuator {}
						DEF C45_Over Conditional {
							buffer {
								REPLACE V45_Over.inSFVec2f BY 4 5 
							}
						}
						DEF C45_Out Conditional {
							buffer {
								REPLACE V45_Out.inSFVec2f BY 4 5
							}
						}
						DEF C45_Click Conditional {
							buffer {
								REPLACE V45_Click.inSFVec2f BY 4 5
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS46 TouchSensor {}
						USE BlankPiece
						DEF V46_Over Valuator {}
						DEF V46_Out Valuator {}
						DEF V46_Click Valuator {}
						DEF C46_Over Conditional {
							buffer {
								REPLACE V46_Over.inSFVec2f BY 4 6 
							}
						}
						DEF C46_Out Conditional {
							buffer {
								REPLACE V46_Out.inSFVec2f BY 4 6
							}
						}
						DEF C46_Click Conditional {
							buffer {
								REPLACE V46_Click.inSFVec2f BY 4 6
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS47 TouchSensor {}
						USE BlankPiece
						DEF V47_Over Valuator {}
						DEF V47_Out Valuator {}
						DEF V47_Click Valuator {}
						DEF C47_Over Conditional {
							buffer {
								REPLACE V47_Over.inSFVec2f BY 4 7 
							}
						}
						DEF C47_Out Conditional {
							buffer {
								REPLACE V47_Out.inSFVec2f BY 4 7
							}
						}
						DEF C47_Click Conditional {
							buffer {
								REPLACE V47_Click.inSFVec2f BY 4 7
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS50 TouchSensor {}
						USE BlankPiece
						DEF V50_Over Valuator {}
						DEF V50_Out Valuator {}
						DEF V50_Click Valuator {}
						DEF C50_Over Conditional {
							buffer {
								REPLACE V50_Over.inSFVec2f BY 5 0 
							}
						}
						DEF C50_Out Conditional {
							buffer {
								REPLACE V50_Out.inSFVec2f BY 5 0
							}
						}
						DEF C50_Click Conditional {
							buffer {
								REPLACE V50_Click.inSFVec2f BY 5 0
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS51 TouchSensor {}
						USE BlankPiece
						DEF V51_Over Valuator {}
						DEF V51_Out Valuator {}
						DEF V51_Click Valuator {}
						DEF C51_Over Conditional {
							buffer {
								REPLACE V51_Over.inSFVec2f BY 5 1 
							}
						}
						DEF C51_Out Conditional {
							buffer {
								REPLACE V51_Out.inSFVec2f BY 5 1
							}
						}
						DEF C51_Click Conditional {
							buffer {
								REPLACE V51_Click.inSFVec2f BY 5 1
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS52 TouchSensor {}
						USE BlankPiece
						DEF V52_Over Valuator {}
						DEF V52_Out Valuator {}
						DEF V52_Click Valuator {}
						DEF C52_Over Conditional {
							buffer {
								REPLACE V52_Over.inSFVec2f BY 5 2 
							}
						}
						DEF C52_Out Conditional {
							buffer {
								REPLACE V52_Out.inSFVec2f BY 5 2
							}
						}
						DEF C52_Click Conditional {
							buffer {
								REPLACE V52_Click.inSFVec2f BY 5 2
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS53 TouchSensor {}
						USE BlankPiece
						DEF V53_Over Valuator {}
						DEF V53_Out Valuator {}
						DEF V53_Click Valuator {}
						DEF C53_Over Conditional {
							buffer {
								REPLACE V53_Over.inSFVec2f BY 5 3 
							}
						}
						DEF C53_Out Conditional {
							buffer {
								REPLACE V53_Out.inSFVec2f BY 5 3
							}
						}
						DEF C53_Click Conditional {
							buffer {
								REPLACE V53_Click.inSFVec2f BY 5 3
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS54 TouchSensor {}
						USE BlankPiece
						DEF V54_Over Valuator {}
						DEF V54_Out Valuator {}
						DEF V54_Click Valuator {}
						DEF C54_Over Conditional {
							buffer {
								REPLACE V54_Over.inSFVec2f BY 5 4 
							}
						}
						DEF C54_Out Conditional {
							buffer {
								REPLACE V54_Out.inSFVec2f BY 5 4
							}
						}
						DEF C54_Click Conditional {
							buffer {
								REPLACE V54_Click.inSFVec2f BY 5 4
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS55 TouchSensor {}
						USE BlankPiece
						DEF V55_Over Valuator {}
						DEF V55_Out Valuator {}
						DEF V55_Click Valuator {}
						DEF C55_Over Conditional {
							buffer {
								REPLACE V55_Over.inSFVec2f BY 5 5 
							}
						}
						DEF C55_Out Conditional {
							buffer {
								REPLACE V55_Out.inSFVec2f BY 5 5
							}
						}
						DEF C55_Click Conditional {
							buffer {
								REPLACE V55_Click.inSFVec2f BY 5 5
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS56 TouchSensor {}
						USE BlankPiece
						DEF V56_Over Valuator {}
						DEF V56_Out Valuator {}
						DEF V56_Click Valuator {}
						DEF C56_Over Conditional {
							buffer {
								REPLACE V56_Over.inSFVec2f BY 5 6 
							}
						}
						DEF C56_Out Conditional {
							buffer {
								REPLACE V56_Out.inSFVec2f BY 5 6
							}
						}
						DEF C56_Click Conditional {
							buffer {
								REPLACE V56_Click.inSFVec2f BY 5 6
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS57 TouchSensor {}
						USE BlankPiece
						DEF V57_Over Valuator {}
						DEF V57_Out Valuator {}
						DEF V57_Click Valuator {}
						DEF C57_Over Conditional {
							buffer {
								REPLACE V57_Over.inSFVec2f BY 5 7 
							}
						}
						DEF C57_Out Conditional {
							buffer {
								REPLACE V57_Out.inSFVec2f BY 5 7
							}
						}
						DEF C57_Click Conditional {
							buffer {
								REPLACE V57_Click.inSFVec2f BY 5 7
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS60 TouchSensor {}
						USE BlankPiece
						DEF V60_Over Valuator {}
						DEF V60_Out Valuator {}
						DEF V60_Click Valuator {}
						DEF C60_Over Conditional {
							buffer {
								REPLACE V60_Over.inSFVec2f BY 6 0 
							}
						}
						DEF C60_Out Conditional {
							buffer {
								REPLACE V60_Out.inSFVec2f BY 6 0
							}
						}
						DEF C60_Click Conditional {
							buffer {
								REPLACE V60_Click.inSFVec2f BY 6 0
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS61 TouchSensor {}
						USE BlankPiece
						DEF V61_Over Valuator {}
						DEF V61_Out Valuator {}
						DEF V61_Click Valuator {}
						DEF C61_Over Conditional {
							buffer {
								REPLACE V61_Over.inSFVec2f BY 6 1 
							}
						}
						DEF C61_Out Conditional {
							buffer {
								REPLACE V61_Out.inSFVec2f BY 6 1
							}
						}
						DEF C61_Click Conditional {
							buffer {
								REPLACE V61_Click.inSFVec2f BY 6 1
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS62 TouchSensor {}
						USE BlankPiece
						DEF V62_Over Valuator {}
						DEF V62_Out Valuator {}
						DEF V62_Click Valuator {}
						DEF C62_Over Conditional {
							buffer {
								REPLACE V62_Over.inSFVec2f BY 6 2 
							}
						}
						DEF C62_Out Conditional {
							buffer {
								REPLACE V62_Out.inSFVec2f BY 6 2
							}
						}
						DEF C62_Click Conditional {
							buffer {
								REPLACE V62_Click.inSFVec2f BY 6 2
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS63 TouchSensor {}
						USE BlankPiece
						DEF V63_Over Valuator {}
						DEF V63_Out Valuator {}
						DEF V63_Click Valuator {}
						DEF C63_Over Conditional {
							buffer {
								REPLACE V63_Over.inSFVec2f BY 6 3 
							}
						}
						DEF C63_Out Conditional {
							buffer {
								REPLACE V63_Out.inSFVec2f BY 6 3
							}
						}
						DEF C63_Click Conditional {
							buffer {
								REPLACE V63_Click.inSFVec2f BY 6 3
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS64 TouchSensor {}
						USE BlankPiece
						DEF V64_Over Valuator {}
						DEF V64_Out Valuator {}
						DEF V64_Click Valuator {}
						DEF C64_Over Conditional {
							buffer {
								REPLACE V64_Over.inSFVec2f BY 6 4 
							}
						}
						DEF C64_Out Conditional {
							buffer {
								REPLACE V64_Out.inSFVec2f BY 6 4
							}
						}
						DEF C64_Click Conditional {
							buffer {
								REPLACE V64_Click.inSFVec2f BY 6 4
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS65 TouchSensor {}
						USE BlankPiece
						DEF V65_Over Valuator {}
						DEF V65_Out Valuator {}
						DEF V65_Click Valuator {}
						DEF C65_Over Conditional {
							buffer {
								REPLACE V65_Over.inSFVec2f BY 6 5 
							}
						}
						DEF C65_Out Conditional {
							buffer {
								REPLACE V65_Out.inSFVec2f BY 6 5
							}
						}
						DEF C65_Click Conditional {
							buffer {
								REPLACE V65_Click.inSFVec2f BY 6 5
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS66 TouchSensor {}
						USE BlankPiece
						DEF V66_Over Valuator {}
						DEF V66_Out Valuator {}
						DEF V66_Click Valuator {}
						DEF C66_Over Conditional {
							buffer {
								REPLACE V66_Over.inSFVec2f BY 6 6 
							}
						}
						DEF C66_Out Conditional {
							buffer {
								REPLACE V66_Out.inSFVec2f BY 6 6
							}
						}
						DEF C66_Click Conditional {
							buffer {
								REPLACE V66_Click.inSFVec2f BY 6 6
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS67 TouchSensor {}
						USE BlankPiece
						DEF V67_Over Valuator {}
						DEF V67_Out Valuator {}
						DEF V67_Click Valuator {}
						DEF C67_Over Conditional {
							buffer {
								REPLACE V67_Over.inSFVec2f BY 6 7 
							}
						}
						DEF C67_Out Conditional {
							buffer {
								REPLACE V67_Out.inSFVec2f BY 6 7
							}
						}
						DEF C67_Click Conditional {
							buffer {
								REPLACE V67_Click.inSFVec2f BY 6 7
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS70 TouchSensor {}
						USE BlankPiece
						DEF V70_Over Valuator {}
						DEF V70_Out Valuator {}
						DEF V70_Click Valuator {}
						DEF C70_Over Conditional {
							buffer {
								REPLACE V70_Over.inSFVec2f BY 7 0 
							}
						}
						DEF C70_Out Conditional {
							buffer {
								REPLACE V70_Out.inSFVec2f BY 7 0
							}
						}
						DEF C70_Click Conditional {
							buffer {
								REPLACE V70_Click.inSFVec2f BY 7 0
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS71 TouchSensor {}
						USE BlankPiece
						DEF V71_Over Valuator {}
						DEF V71_Out Valuator {}
						DEF V71_Click Valuator {}
						DEF C71_Over Conditional {
							buffer {
								REPLACE V71_Over.inSFVec2f BY 7 1 
							}
						}
						DEF C71_Out Conditional {
							buffer {
								REPLACE V71_Out.inSFVec2f BY 7 1
							}
						}
						DEF C71_Click Conditional {
							buffer {
								REPLACE V71_Click.inSFVec2f BY 7 1
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS72 TouchSensor {}
						USE BlankPiece
						DEF V72_Over Valuator {}
						DEF V72_Out Valuator {}
						DEF V72_Click Valuator {}
						DEF C72_Over Conditional {
							buffer {
								REPLACE V72_Over.inSFVec2f BY 7 2 
							}
						}
						DEF C72_Out Conditional {
							buffer {
								REPLACE V72_Out.inSFVec2f BY 7 2
							}
						}
						DEF C72_Click Conditional {
							buffer {
								REPLACE V72_Click.inSFVec2f BY 7 2
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS73 TouchSensor {}
						USE BlankPiece
						DEF V73_Over Valuator {}
						DEF V73_Out Valuator {}
						DEF V73_Click Valuator {}
						DEF C73_Over Conditional {
							buffer {
								REPLACE V73_Over.inSFVec2f BY 7 3 
							}
						}
						DEF C73_Out Conditional {
							buffer {
								REPLACE V73_Out.inSFVec2f BY 7 3
							}
						}
						DEF C73_Click Conditional {
							buffer {
								REPLACE V73_Click.inSFVec2f BY 7 3
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS74 TouchSensor {}
						USE BlankPiece
						DEF V74_Over Valuator {}
						DEF V74_Out Valuator {}
						DEF V74_Click Valuator {}
						DEF C74_Over Conditional {
							buffer {
								REPLACE V74_Over.inSFVec2f BY 7 4 
							}
						}
						DEF C74_Out Conditional {
							buffer {
								REPLACE V74_Out.inSFVec2f BY 7 4
							}
						}
						DEF C74_Click Conditional {
							buffer {
								REPLACE V74_Click.inSFVec2f BY 7 4
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS75 TouchSensor {}
						USE BlankPiece
						DEF V75_Over Valuator {}
						DEF V75_Out Valuator {}
						DEF V75_Click Valuator {}
						DEF C75_Over Conditional {
							buffer {
								REPLACE V75_Over.inSFVec2f BY 7 5 
							}
						}
						DEF C75_Out Conditional {
							buffer {
								REPLACE V75_Out.inSFVec2f BY 7 5
							}
						}
						DEF C75_Click Conditional {
							buffer {
								REPLACE V75_Click.inSFVec2f BY 7 5
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS76 TouchSensor {}
						USE BlankPiece
						DEF V76_Over Valuator {}
						DEF V76_Out Valuator {}
						DEF V76_Click Valuator {}
						DEF C76_Over Conditional {
							buffer {
								REPLACE V76_Over.inSFVec2f BY 7 6 
							}
						}
						DEF C76_Out Conditional {
							buffer {
								REPLACE V76_Out.inSFVec2f BY 7 6
							}
						}
						DEF C76_Click Conditional {
							buffer {
								REPLACE V76_Click.inSFVec2f BY 7 6
							}
						}
					]
				}
				Transform2D {
					children [
						DEF TS77 TouchSensor {}
						USE BlankPiece
						DEF V77_Over Valuator {}
						DEF V77_Out Valuator {}
						DEF V77_Click Valuator {}
						DEF C77_Over Conditional {
							buffer {
								REPLACE V77_Over.inSFVec2f BY 7 7 
							}
						}
						DEF C77_Out Conditional {
							buffer {
								REPLACE V77_Out.inSFVec2f BY 7 7
							}
						}
						DEF C77_Click Conditional {
							buffer {
								REPLACE V77_Click.inSFVec2f BY 7 7
							}
						}
					]
				}
			]
		}
		DEF SC Script { 
eventIn SFBool startGame
eventIn SFVec2f mouseOver
eventIn SFVec2f mouseOut
eventIn SFVec2f click			
eventIn SFBool timeOut

field SFNode timer USE TimeOutSensor

# some internal global variables
field MFNode picture [ 
	USE BlankPiece
	USE WhitePiece
	USE BlackPiece
	USE WhiteTransPiece
	USE BlackTransPiece
	USE Trans1
	USE Trans2
	USE Trans3
	USE Trans4
	USE Trans5
	USE Trans6
	USE Trans7
	USE Trans8
	USE Trans9
	USE Trans10
	USE Trans11
	USE Trans12
	USE Trans13
	USE Trans14
	USE Trans15
	USE Trans16
	USE Trans17
	USE Trans18
	USE Trans19
	USE Trans20
	USE Trans21
]
field SFNode images USE Board

			url "javascript:
// JavaScript Othello Game
// Copyright (c) 2000, 2001 Kelly Yancey <kbyanc@posi.net>
// All rights reserved.
//
// Redistribution and use in source form, with or without modification, is
// permitted provided that the following conditions are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer,
//    without modification, immediately at the beginning of the file.
// 2. All advertising materials mentioning features or use of this software
//    must display the following acknowledgement:
//      This product includes software developed by Kelly Yancey     
//    and a reference to the URL http://www.posi.net/software/othello/
// 3. The name of the author may not be used to endorse or promote products
//    derived from this software without specific prior written permission.
//    
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT  
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// picture numbers
function initialize() {
EMPTY = 0;		// empty square
WHITE = 1;		// white piece
BLACK = 2;		// black piece
WHITETRANS = 3;		// white transparent cursor piece
BLACKTRANS = 4;		// black transparent cursor piece
NUMBASE = 5;		// beginning of numeric pictures

// size of the pictures used to represent pieces (all pictures must be the same size)
piecewidth = 42;
pieceheight = 42;

// size of the board
width = 8;
height = 8;

// player settings
human = BLACK;
showcursor = true;	// display cursor showing user where they can go
showflips = false;	// display counts showing how many pieces they can flip by putting a piece in a given square

// AI settings
weightsquares = 1;	// whether AI prefers squares that yield higher flip counts
edgesensitive = 1;	// whether AI is sensitive to the importance of edge squares

// some internal global variables
board = new Array(width);
score = new Array();
turn = BLACK;


human = BLACK;
showcursor = true;
showflips = true;
weightsquares = true;
edgesensitive = true;

InitializeBoard();

Play(0);

}

function piece(x,y) {
// object definition for 'piece' type
	this.imagenum = x * width + y;
    this.player = EMPTY;
    // how many pieces each player could flip by taking this square
    this.flips = new Array();
    this.flips[WHITE] = 0;
    this.flips[BLACK] = 0;
    // how valuable this location is to each player
    this.value = new Array();
    this.value[WHITE] = 0;
    this.value[BLACK] = 0;
}


function SetPieceImage(x, y, src) {
// routine to set the image associated with the given piece
    if(images.children[board[x][y].imagenum].children[1] != src) {
		// we explicitely check to see if we are changing the image source to prevent
		// unnecessary redrawing of images which do not change
		images.children[board[x][y].imagenum].children[1] = src;
    }
}

function InitializeBoard() {
// routine to initialize the state of the game and draw the board
    // build the board array
    for(x = 0; x < width; x++)
	board[x] = new Array (height);

    for(y = 0; y < height; y++) {
	for(x = 0; x < width; x++) {
	    // place initial pieces
	    if((x == 3 && y == 3) || (x == 4 && y == 4)) player = WHITE;
	    else if((x == 3 && y == 4) || (x == 4 && y == 3)) player = BLACK;
	    else player = EMPTY;
	    board[x][y] = new piece(x,y);
	    board[x][y].player = player;
	}
    }
    // initialize scores
    score[WHITE] = 2;
    score[BLACK] = 2;
}

function ResetBoard() {
// routine to reset all of the pieces on the board

    // reset the board
    for(y = 0; y < height; y++) {
	for(x = 0; x < width; x++) {
	    board[x][y].player = EMPTY;
	    SetPieceImage(x, y, picture[EMPTY]);
	}
    }

    // reset scores
    score[WHITE] = 0;
    score[BLACK] = 0;

    // put initial pieces back on the board
    RawPutPiece(3, 3, WHITE);
    RawPutPiece(4, 4, WHITE);
    RawPutPiece(3, 4, BLACK);
    RawPutPiece(4, 3, BLACK);

    turn = BLACK;
}

function NumFlips(x, y, player) {
    count = 0;

    for(deltay = -1; deltay <= 1; deltay++) {
	for(deltax = -1; deltax <= 1; deltax++) {
	    for(distance = 1;; distance++) {
		posx = x + (distance * deltax);
		posy = y + (distance * deltay);
		// stop if we go off the board
		if(posx < 0 || posx >= width || posy < 0 || posy >= height)
		    break;
		// stop when we reach an empty square
		if(board[posx][posy].player == EMPTY)
		    break;
		// only update the flip count when we reach another of the
		// player's pieces
		if(board[posx][posy].player == player) {
		    count += distance - 1;
		    break;
		}
	    }
	}
    }
    return(count);
}

function CalcFlipCounts() {
    
    for(y = 0; y < height; y++) {
	for(x = 0; x < width; x++) {
	    board[x][y].flips[WHITE] = 0;
	    board[x][y].flips[BLACK] = 0;

	    if(board[x][y].player != EMPTY) continue;

	    board[x][y].flips[WHITE] = NumFlips(x, y, WHITE);
	    board[x][y].flips[BLACK] = NumFlips(x, y, BLACK);
	}
    }
}

function RawPutPiece(x, y, player) {
    other = OtherPlayer(player);
    if(board[x][y].player == other) score[other]--;
	
    board[x][y].player = player;
    SetPieceImage(x, y, picture[player]);
    score[player]++;
}

function FlipPieces(x, y, player) {
    count = 0;

    // put a piece down at the desired location
    RawPutPiece(x, y, player);

    for(deltay = -1; deltay <= 1; deltay++) {
	for(deltax = -1; deltax <= 1; deltax++) {
	    for(distance = 1;; distance++) {
		posx = x + (distance * deltax);
		posy = y + (distance * deltay);
		// stop if we go off the board
		if(posx < 0 || posx >= width || posy < 0 || posy >= height)
		    break;
		// stop when we reach an empty square
		if(board[posx][posy].player == EMPTY)
		    break;
		if(board[posx][posy].player == player) {
		    // backtrack, flipping pieces
		    for(distance--; distance > 0; distance--) {
			posx = x + (distance * deltax);
			posy = y + (distance * deltay);
			RawPutPiece(posx, posy, player);
		    }
		    break;
		}
	    }
	}
    }
    return(count);
}

function AnyMoves(player) {
    
    for(y = 0; y < height; y++) {
	for(x = 0; x < width; x++) {
	    if(board[x][y].player != EMPTY) continue;
	    if(NumFlips(x, y, player) > 0) return(true);
	}
    }
    return(false);
}

function CanPutPiece(x, y, player) {
// determine whether the player can put a piece at the given position
    if(turn != player)
	return(false);
    if(board[x][y].player != EMPTY)
	return(false);
    return(NumFlips(x, y, player) > 0);
}

function CheckPutPiece(x, y) {    
    if(! showcursor) return;
    if(! CanPutPiece(x, y, human)) return;
    if(human == WHITE) over = WHITETRANS;
    else over = BLACKTRANS;

    SetPieceImage(x, y, picture[over]);
}

function RestorePiece(x, y) {
    if(showflips && RawShowFlipCount(x, y, human)) return;
    SetPieceImage(x, y, picture[board[x][y].player]);
}

function PutPiece(x, y, timestamp) {
    if(! CanPutPiece(x, y, human)) return;

    FlipPieces(x, y, human);
    DoneTurn(timestamp);
}

function RawShowFlipCount(x, y, player) {
    if(board[x][y].player != EMPTY) return(false);
    if((flips = board[x][y].flips[player]) == 0) return(false);
    SetPieceImage(x, y, picture[NUMBASE + flips]);
    return(true);
}

function ShowFlipCounts(player) {
    
    CalcFlipCounts();
    for(y = 0; y < height; y++) {
	for(x = 0; x < width; x++) {
	    RawShowFlipCount(x, y, player);
	}
    }
}

function HideFlipCounts() {
    
    for(y = 0; y < height; y++) {
	for(x = 0; x < width; x++) {
	    if(board[x][y].player == EMPTY) 
		SetPieceImage(x, y, picture[EMPTY]);
	}
    }
}

function OtherPlayer(player) {
    return((player == WHITE)? BLACK: WHITE);
}

function DoneTurn(timestamp) {
	moves = AnyMoves(turn);
	turn = OtherPlayer(turn);

    // check whether the new player has any moves
    if(! AnyMoves(turn)) {
    	if(! moves) return(GameOver());
    	
    	// XXX inform user the player has no move
    	// and switch players again
    	turn = OtherPlayer(turn);
    }

    // add a slight delay before the computer takes it's turn so game feels
    // 'warmer'; when computer is playing itself, add larger delay so user
    // can watch
    if(turn != human) {
    	HideFlipCounts();
    	timer.cycleInterval = ((human == EMPTY)? 1: 0.150);
    	timer.startTime = timestamp;
    	timer.enabled = true;
    } else if(showflips) ShowFlipCounts(human);
}
 
function Rate(x, y, player) {
    
    if(board[x][y].player != EMPTY) return(0);
    if(x < 0 || x >= width || y < 0 || y >= height) return(0);

    rating = board[x][y].flips[player];

    if(! weightsquares)
	rating = (rating > 0)? 1: 0;

    if(edgesensitive && rating > 0) {
	// increase all non-zero weightings by 3 so we have room
	// to wait 'less ideal' squares below the baseline
	rating += 10;

	// raise edge ratings 4 points, corners are raised 8
	if(x == 0 || x == width - 1) rating += 4;
	if(y == 0 || y == height - 1) rating += 4;
	// lower next-to-edge ratings by 5 points, next-to-corner by 10
	if(x == 1 || x == width - 2) rating -= 5;
	if(y == 1 || y == height - 2) rating -= 5;

	// we cannot rule out a move because of bad location; we must
	// always go somewhere
	if(rating < 1) rating = 1;
    }
    return(rating);
}

function OthelloAI(player, timestamp) {
    best = 0;
    numbest = 0;
    
    // rank each position on the board by the potential flip count
    CalcFlipCounts();

    // apply AI rating algorithm
    for(y = 0; y < height; y++) {
	for(x = 0; x < width; x++) {
	    rating = Rate(x, y, player);

	    // store the rating back into the board
	    board[x][y].value[player] = rating;

	    if(rating == best)
		numbest++;
	    else if(rating > best) {
		best = rating;
		numbest = 1;
	    }
	}
    }

    while(numbest > 0) {
	// pick a square to put our piece
	pick = Math.floor(Math.random() * numbest);
	count = 0;
	for(y = 0; y < height; y++) {
	    for(x = 0; x < width; x++) {
		rating = board[x][y].value[player];
		if(rating == best) {
		    if(count == pick) {
			FlipPieces(x, y, player);
			DoneTurn(timestamp);
			return;
		    }
		    else count++;
		}
	    }
	}
    }

    // if we make it here, then there was nowhere to go
    DoneTurn(timestamp);
}

function Play(timestamp) {
    // black always goes first
    if(human != BLACK)
	OthelloAI(BLACK,timestamp);
    else if(showflips)
	ShowFlipCounts(human);
}

function GameOver() {
    turn = EMPTY;
}

function timeOut(value, timestamp) {	
	if (!value) {
		OthelloAI(turn, timestamp);
	}
}

function startGame(value,timestamp) {	
	if (value) {
		Play(timestamp);
	}
}

function click(value, timestamp) {
	PutPiece(value.x, value.y, timestamp);
}

function mouseOver(value) {
	CheckPutPiece(value.x, value.y);
}

function mouseOut(value) {
	RestorePiece(value.x, value.y);
}	
 
			
			"
		}		
	]
}
ROUTE StartTS.isActive TO SC.startGame
ROUTE TimeOutSensor.isActive TO SC.timeOut

ROUTE TS00.isActive TO C00_Click.activate
ROUTE TS00.isOver TO C00_Over.activate
ROUTE TS00.isOver TO C00_Out.reverseActivate
ROUTE V00_Over.outSFVec2f TO SC.mouseOver
ROUTE V00_Out.outSFVec2f TO SC.mouseOut
ROUTE V00_Click.outSFVec2f TO SC.click
ROUTE TS01.isActive TO C01_Click.activate
ROUTE TS01.isOver TO C01_Over.activate
ROUTE TS01.isOver TO C01_Out.reverseActivate
ROUTE V01_Over.outSFVec2f TO SC.mouseOver
ROUTE V01_Out.outSFVec2f TO SC.mouseOut
ROUTE V01_Click.outSFVec2f TO SC.click
ROUTE TS02.isActive TO C02_Click.activate
ROUTE TS02.isOver TO C02_Over.activate
ROUTE TS02.isOver TO C02_Out.reverseActivate
ROUTE V02_Over.outSFVec2f TO SC.mouseOver
ROUTE V02_Out.outSFVec2f TO SC.mouseOut
ROUTE V02_Click.outSFVec2f TO SC.click
ROUTE TS03.isActive TO C03_Click.activate
ROUTE TS03.isOver TO C03_Over.activate
ROUTE TS03.isOver TO C03_Out.reverseActivate
ROUTE V03_Over.outSFVec2f TO SC.mouseOver
ROUTE V03_Out.outSFVec2f TO SC.mouseOut
ROUTE V03_Click.outSFVec2f TO SC.click
ROUTE TS04.isActive TO C04_Click.activate
ROUTE TS04.isOver TO C04_Over.activate
ROUTE TS04.isOver TO C04_Out.reverseActivate
ROUTE V04_Over.outSFVec2f TO SC.mouseOver
ROUTE V04_Out.outSFVec2f TO SC.mouseOut
ROUTE V04_Click.outSFVec2f TO SC.click
ROUTE TS05.isActive TO C05_Click.activate
ROUTE TS05.isOver TO C05_Over.activate
ROUTE TS05.isOver TO C05_Out.reverseActivate
ROUTE V05_Over.outSFVec2f TO SC.mouseOver
ROUTE V05_Out.outSFVec2f TO SC.mouseOut
ROUTE V05_Click.outSFVec2f TO SC.click
ROUTE TS06.isActive TO C06_Click.activate
ROUTE TS06.isOver TO C06_Over.activate
ROUTE TS06.isOver TO C06_Out.reverseActivate
ROUTE V06_Over.outSFVec2f TO SC.mouseOver
ROUTE V06_Out.outSFVec2f TO SC.mouseOut
ROUTE V06_Click.outSFVec2f TO SC.click
ROUTE TS07.isActive TO C07_Click.activate
ROUTE TS07.isOver TO C07_Over.activate
ROUTE TS07.isOver TO C07_Out.reverseActivate
ROUTE V07_Over.outSFVec2f TO SC.mouseOver
ROUTE V07_Out.outSFVec2f TO SC.mouseOut
ROUTE V07_Click.outSFVec2f TO SC.click
ROUTE TS10.isActive TO C10_Click.activate
ROUTE TS10.isOver TO C10_Over.activate
ROUTE TS10.isOver TO C10_Out.reverseActivate
ROUTE V10_Over.outSFVec2f TO SC.mouseOver
ROUTE V10_Out.outSFVec2f TO SC.mouseOut
ROUTE V10_Click.outSFVec2f TO SC.click
ROUTE TS11.isActive TO C11_Click.activate
ROUTE TS11.isOver TO C11_Over.activate
ROUTE TS11.isOver TO C11_Out.reverseActivate
ROUTE V11_Over.outSFVec2f TO SC.mouseOver
ROUTE V11_Out.outSFVec2f TO SC.mouseOut
ROUTE V11_Click.outSFVec2f TO SC.click
ROUTE TS12.isActive TO C12_Click.activate
ROUTE TS12.isOver TO C12_Over.activate
ROUTE TS12.isOver TO C12_Out.reverseActivate
ROUTE V12_Over.outSFVec2f TO SC.mouseOver
ROUTE V12_Out.outSFVec2f TO SC.mouseOut
ROUTE V12_Click.outSFVec2f TO SC.click
ROUTE TS13.isActive TO C13_Click.activate
ROUTE TS13.isOver TO C13_Over.activate
ROUTE TS13.isOver TO C13_Out.reverseActivate
ROUTE V13_Over.outSFVec2f TO SC.mouseOver
ROUTE V13_Out.outSFVec2f TO SC.mouseOut
ROUTE V13_Click.outSFVec2f TO SC.click
ROUTE TS14.isActive TO C14_Click.activate
ROUTE TS14.isOver TO C14_Over.activate
ROUTE TS14.isOver TO C14_Out.reverseActivate
ROUTE V14_Over.outSFVec2f TO SC.mouseOver
ROUTE V14_Out.outSFVec2f TO SC.mouseOut
ROUTE V14_Click.outSFVec2f TO SC.click
ROUTE TS15.isActive TO C15_Click.activate
ROUTE TS15.isOver TO C15_Over.activate
ROUTE TS15.isOver TO C15_Out.reverseActivate
ROUTE V15_Over.outSFVec2f TO SC.mouseOver
ROUTE V15_Out.outSFVec2f TO SC.mouseOut
ROUTE V15_Click.outSFVec2f TO SC.click
ROUTE TS16.isActive TO C16_Click.activate
ROUTE TS16.isOver TO C16_Over.activate
ROUTE TS16.isOver TO C16_Out.reverseActivate
ROUTE V16_Over.outSFVec2f TO SC.mouseOver
ROUTE V16_Out.outSFVec2f TO SC.mouseOut
ROUTE V16_Click.outSFVec2f TO SC.click
ROUTE TS17.isActive TO C17_Click.activate
ROUTE TS17.isOver TO C17_Over.activate
ROUTE TS17.isOver TO C17_Out.reverseActivate
ROUTE V17_Over.outSFVec2f TO SC.mouseOver
ROUTE V17_Out.outSFVec2f TO SC.mouseOut
ROUTE V17_Click.outSFVec2f TO SC.click
ROUTE TS20.isActive TO C20_Click.activate
ROUTE TS20.isOver TO C20_Over.activate
ROUTE TS20.isOver TO C20_Out.reverseActivate
ROUTE V20_Over.outSFVec2f TO SC.mouseOver
ROUTE V20_Out.outSFVec2f TO SC.mouseOut
ROUTE V20_Click.outSFVec2f TO SC.click
ROUTE TS21.isActive TO C21_Click.activate
ROUTE TS21.isOver TO C21_Over.activate
ROUTE TS21.isOver TO C21_Out.reverseActivate
ROUTE V21_Over.outSFVec2f TO SC.mouseOver
ROUTE V21_Out.outSFVec2f TO SC.mouseOut
ROUTE V21_Click.outSFVec2f TO SC.click
ROUTE TS22.isActive TO C22_Click.activate
ROUTE TS22.isOver TO C22_Over.activate
ROUTE TS22.isOver TO C22_Out.reverseActivate
ROUTE V22_Over.outSFVec2f TO SC.mouseOver
ROUTE V22_Out.outSFVec2f TO SC.mouseOut
ROUTE V22_Click.outSFVec2f TO SC.click
ROUTE TS23.isActive TO C23_Click.activate
ROUTE TS23.isOver TO C23_Over.activate
ROUTE TS23.isOver TO C23_Out.reverseActivate
ROUTE V23_Over.outSFVec2f TO SC.mouseOver
ROUTE V23_Out.outSFVec2f TO SC.mouseOut
ROUTE V23_Click.outSFVec2f TO SC.click
ROUTE TS24.isActive TO C24_Click.activate
ROUTE TS24.isOver TO C24_Over.activate
ROUTE TS24.isOver TO C24_Out.reverseActivate
ROUTE V24_Over.outSFVec2f TO SC.mouseOver
ROUTE V24_Out.outSFVec2f TO SC.mouseOut
ROUTE V24_Click.outSFVec2f TO SC.click
ROUTE TS25.isActive TO C25_Click.activate
ROUTE TS25.isOver TO C25_Over.activate
ROUTE TS25.isOver TO C25_Out.reverseActivate
ROUTE V25_Over.outSFVec2f TO SC.mouseOver
ROUTE V25_Out.outSFVec2f TO SC.mouseOut
ROUTE V25_Click.outSFVec2f TO SC.click
ROUTE TS26.isActive TO C26_Click.activate
ROUTE TS26.isOver TO C26_Over.activate
ROUTE TS26.isOver TO C26_Out.reverseActivate
ROUTE V26_Over.outSFVec2f TO SC.mouseOver
ROUTE V26_Out.outSFVec2f TO SC.mouseOut
ROUTE V26_Click.outSFVec2f TO SC.click
ROUTE TS27.isActive TO C27_Click.activate
ROUTE TS27.isOver TO C27_Over.activate
ROUTE TS27.isOver TO C27_Out.reverseActivate
ROUTE V27_Over.outSFVec2f TO SC.mouseOver
ROUTE V27_Out.outSFVec2f TO SC.mouseOut
ROUTE V27_Click.outSFVec2f TO SC.click
ROUTE TS30.isActive TO C30_Click.activate
ROUTE TS30.isOver TO C30_Over.activate
ROUTE TS30.isOver TO C30_Out.reverseActivate
ROUTE V30_Over.outSFVec2f TO SC.mouseOver
ROUTE V30_Out.outSFVec2f TO SC.mouseOut
ROUTE V30_Click.outSFVec2f TO SC.click
ROUTE TS31.isActive TO C31_Click.activate
ROUTE TS31.isOver TO C31_Over.activate
ROUTE TS31.isOver TO C31_Out.reverseActivate
ROUTE V31_Over.outSFVec2f TO SC.mouseOver
ROUTE V31_Out.outSFVec2f TO SC.mouseOut
ROUTE V31_Click.outSFVec2f TO SC.click
ROUTE TS32.isActive TO C32_Click.activate
ROUTE TS32.isOver TO C32_Over.activate
ROUTE TS32.isOver TO C32_Out.reverseActivate
ROUTE V32_Over.outSFVec2f TO SC.mouseOver
ROUTE V32_Out.outSFVec2f TO SC.mouseOut
ROUTE V32_Click.outSFVec2f TO SC.click
ROUTE TS33.isActive TO C33_Click.activate
ROUTE TS33.isOver TO C33_Over.activate
ROUTE TS33.isOver TO C33_Out.reverseActivate
ROUTE V33_Over.outSFVec2f TO SC.mouseOver
ROUTE V33_Out.outSFVec2f TO SC.mouseOut
ROUTE V33_Click.outSFVec2f TO SC.click
ROUTE TS34.isActive TO C34_Click.activate
ROUTE TS34.isOver TO C34_Over.activate
ROUTE TS34.isOver TO C34_Out.reverseActivate
ROUTE V34_Over.outSFVec2f TO SC.mouseOver
ROUTE V34_Out.outSFVec2f TO SC.mouseOut
ROUTE V34_Click.outSFVec2f TO SC.click
ROUTE TS35.isActive TO C35_Click.activate
ROUTE TS35.isOver TO C35_Over.activate
ROUTE TS35.isOver TO C35_Out.reverseActivate
ROUTE V35_Over.outSFVec2f TO SC.mouseOver
ROUTE V35_Out.outSFVec2f TO SC.mouseOut
ROUTE V35_Click.outSFVec2f TO SC.click
ROUTE TS36.isActive TO C36_Click.activate
ROUTE TS36.isOver TO C36_Over.activate
ROUTE TS36.isOver TO C36_Out.reverseActivate
ROUTE V36_Over.outSFVec2f TO SC.mouseOver
ROUTE V36_Out.outSFVec2f TO SC.mouseOut
ROUTE V36_Click.outSFVec2f TO SC.click
ROUTE TS37.isActive TO C37_Click.activate
ROUTE TS37.isOver TO C37_Over.activate
ROUTE TS37.isOver TO C37_Out.reverseActivate
ROUTE V37_Over.outSFVec2f TO SC.mouseOver
ROUTE V37_Out.outSFVec2f TO SC.mouseOut
ROUTE V37_Click.outSFVec2f TO SC.click
ROUTE TS40.isActive TO C40_Click.activate
ROUTE TS40.isOver TO C40_Over.activate
ROUTE TS40.isOver TO C40_Out.reverseActivate
ROUTE V40_Over.outSFVec2f TO SC.mouseOver
ROUTE V40_Out.outSFVec2f TO SC.mouseOut
ROUTE V40_Click.outSFVec2f TO SC.click
ROUTE TS41.isActive TO C41_Click.activate
ROUTE TS41.isOver TO C41_Over.activate
ROUTE TS41.isOver TO C41_Out.reverseActivate
ROUTE V41_Over.outSFVec2f TO SC.mouseOver
ROUTE V41_Out.outSFVec2f TO SC.mouseOut
ROUTE V41_Click.outSFVec2f TO SC.click
ROUTE TS42.isActive TO C42_Click.activate
ROUTE TS42.isOver TO C42_Over.activate
ROUTE TS42.isOver TO C42_Out.reverseActivate
ROUTE V42_Over.outSFVec2f TO SC.mouseOver
ROUTE V42_Out.outSFVec2f TO SC.mouseOut
ROUTE V42_Click.outSFVec2f TO SC.click
ROUTE TS43.isActive TO C43_Click.activate
ROUTE TS43.isOver TO C43_Over.activate
ROUTE TS43.isOver TO C43_Out.reverseActivate
ROUTE V43_Over.outSFVec2f TO SC.mouseOver
ROUTE V43_Out.outSFVec2f TO SC.mouseOut
ROUTE V43_Click.outSFVec2f TO SC.click
ROUTE TS44.isActive TO C44_Click.activate
ROUTE TS44.isOver TO C44_Over.activate
ROUTE TS44.isOver TO C44_Out.reverseActivate
ROUTE V44_Over.outSFVec2f TO SC.mouseOver
ROUTE V44_Out.outSFVec2f TO SC.mouseOut
ROUTE V44_Click.outSFVec2f TO SC.click
ROUTE TS45.isActive TO C45_Click.activate
ROUTE TS45.isOver TO C45_Over.activate
ROUTE TS45.isOver TO C45_Out.reverseActivate
ROUTE V45_Over.outSFVec2f TO SC.mouseOver
ROUTE V45_Out.outSFVec2f TO SC.mouseOut
ROUTE V45_Click.outSFVec2f TO SC.click
ROUTE TS46.isActive TO C46_Click.activate
ROUTE TS46.isOver TO C46_Over.activate
ROUTE TS46.isOver TO C46_Out.reverseActivate
ROUTE V46_Over.outSFVec2f TO SC.mouseOver
ROUTE V46_Out.outSFVec2f TO SC.mouseOut
ROUTE V46_Click.outSFVec2f TO SC.click
ROUTE TS47.isActive TO C47_Click.activate
ROUTE TS47.isOver TO C47_Over.activate
ROUTE TS47.isOver TO C47_Out.reverseActivate
ROUTE V47_Over.outSFVec2f TO SC.mouseOver
ROUTE V47_Out.outSFVec2f TO SC.mouseOut
ROUTE V47_Click.outSFVec2f TO SC.click
ROUTE TS50.isActive TO C50_Click.activate
ROUTE TS50.isOver TO C50_Over.activate
ROUTE TS50.isOver TO C50_Out.reverseActivate
ROUTE V50_Over.outSFVec2f TO SC.mouseOver
ROUTE V50_Out.outSFVec2f TO SC.mouseOut
ROUTE V50_Click.outSFVec2f TO SC.click
ROUTE TS51.isActive TO C51_Click.activate
ROUTE TS51.isOver TO C51_Over.activate
ROUTE TS51.isOver TO C51_Out.reverseActivate
ROUTE V51_Over.outSFVec2f TO SC.mouseOver
ROUTE V51_Out.outSFVec2f TO SC.mouseOut
ROUTE V51_Click.outSFVec2f TO SC.click
ROUTE TS52.isActive TO C52_Click.activate
ROUTE TS52.isOver TO C52_Over.activate
ROUTE TS52.isOver TO C52_Out.reverseActivate
ROUTE V52_Over.outSFVec2f TO SC.mouseOver
ROUTE V52_Out.outSFVec2f TO SC.mouseOut
ROUTE V52_Click.outSFVec2f TO SC.click
ROUTE TS53.isActive TO C53_Click.activate
ROUTE TS53.isOver TO C53_Over.activate
ROUTE TS53.isOver TO C53_Out.reverseActivate
ROUTE V53_Over.outSFVec2f TO SC.mouseOver
ROUTE V53_Out.outSFVec2f TO SC.mouseOut
ROUTE V53_Click.outSFVec2f TO SC.click
ROUTE TS54.isActive TO C54_Click.activate
ROUTE TS54.isOver TO C54_Over.activate
ROUTE TS54.isOver TO C54_Out.reverseActivate
ROUTE V54_Over.outSFVec2f TO SC.mouseOver
ROUTE V54_Out.outSFVec2f TO SC.mouseOut
ROUTE V54_Click.outSFVec2f TO SC.click
ROUTE TS55.isActive TO C55_Click.activate
ROUTE TS55.isOver TO C55_Over.activate
ROUTE TS55.isOver TO C55_Out.reverseActivate
ROUTE V55_Over.outSFVec2f TO SC.mouseOver
ROUTE V55_Out.outSFVec2f TO SC.mouseOut
ROUTE V55_Click.outSFVec2f TO SC.click
ROUTE TS56.isActive TO C56_Click.activate
ROUTE TS56.isOver TO C56_Over.activate
ROUTE TS56.isOver TO C56_Out.reverseActivate
ROUTE V56_Over.outSFVec2f TO SC.mouseOver
ROUTE V56_Out.outSFVec2f TO SC.mouseOut
ROUTE V56_Click.outSFVec2f TO SC.click
ROUTE TS57.isActive TO C57_Click.activate
ROUTE TS57.isOver TO C57_Over.activate
ROUTE TS57.isOver TO C57_Out.reverseActivate
ROUTE V57_Over.outSFVec2f TO SC.mouseOver
ROUTE V57_Out.outSFVec2f TO SC.mouseOut
ROUTE V57_Click.outSFVec2f TO SC.click
ROUTE TS60.isActive TO C60_Click.activate
ROUTE TS60.isOver TO C60_Over.activate
ROUTE TS60.isOver TO C60_Out.reverseActivate
ROUTE V60_Over.outSFVec2f TO SC.mouseOver
ROUTE V60_Out.outSFVec2f TO SC.mouseOut
ROUTE V60_Click.outSFVec2f TO SC.click
ROUTE TS61.isActive TO C61_Click.activate
ROUTE TS61.isOver TO C61_Over.activate
ROUTE TS61.isOver TO C61_Out.reverseActivate
ROUTE V61_Over.outSFVec2f TO SC.mouseOver
ROUTE V61_Out.outSFVec2f TO SC.mouseOut
ROUTE V61_Click.outSFVec2f TO SC.click
ROUTE TS62.isActive TO C62_Click.activate
ROUTE TS62.isOver TO C62_Over.activate
ROUTE TS62.isOver TO C62_Out.reverseActivate
ROUTE V62_Over.outSFVec2f TO SC.mouseOver
ROUTE V62_Out.outSFVec2f TO SC.mouseOut
ROUTE V62_Click.outSFVec2f TO SC.click
ROUTE TS63.isActive TO C63_Click.activate
ROUTE TS63.isOver TO C63_Over.activate
ROUTE TS63.isOver TO C63_Out.reverseActivate
ROUTE V63_Over.outSFVec2f TO SC.mouseOver
ROUTE V63_Out.outSFVec2f TO SC.mouseOut
ROUTE V63_Click.outSFVec2f TO SC.click
ROUTE TS64.isActive TO C64_Click.activate
ROUTE TS64.isOver TO C64_Over.activate
ROUTE TS64.isOver TO C64_Out.reverseActivate
ROUTE V64_Over.outSFVec2f TO SC.mouseOver
ROUTE V64_Out.outSFVec2f TO SC.mouseOut
ROUTE V64_Click.outSFVec2f TO SC.click
ROUTE TS65.isActive TO C65_Click.activate
ROUTE TS65.isOver TO C65_Over.activate
ROUTE TS65.isOver TO C65_Out.reverseActivate
ROUTE V65_Over.outSFVec2f TO SC.mouseOver
ROUTE V65_Out.outSFVec2f TO SC.mouseOut
ROUTE V65_Click.outSFVec2f TO SC.click
ROUTE TS66.isActive TO C66_Click.activate
ROUTE TS66.isOver TO C66_Over.activate
ROUTE TS66.isOver TO C66_Out.reverseActivate
ROUTE V66_Over.outSFVec2f TO SC.mouseOver
ROUTE V66_Out.outSFVec2f TO SC.mouseOut
ROUTE V66_Click.outSFVec2f TO SC.click
ROUTE TS67.isActive TO C67_Click.activate
ROUTE TS67.isOver TO C67_Over.activate
ROUTE TS67.isOver TO C67_Out.reverseActivate
ROUTE V67_Over.outSFVec2f TO SC.mouseOver
ROUTE V67_Out.outSFVec2f TO SC.mouseOut
ROUTE V67_Click.outSFVec2f TO SC.click
ROUTE TS70.isActive TO C70_Click.activate
ROUTE TS70.isOver TO C70_Over.activate
ROUTE TS70.isOver TO C70_Out.reverseActivate
ROUTE V70_Over.outSFVec2f TO SC.mouseOver
ROUTE V70_Out.outSFVec2f TO SC.mouseOut
ROUTE V70_Click.outSFVec2f TO SC.click
ROUTE TS71.isActive TO C71_Click.activate
ROUTE TS71.isOver TO C71_Over.activate
ROUTE TS71.isOver TO C71_Out.reverseActivate
ROUTE V71_Over.outSFVec2f TO SC.mouseOver
ROUTE V71_Out.outSFVec2f TO SC.mouseOut
ROUTE V71_Click.outSFVec2f TO SC.click
ROUTE TS72.isActive TO C72_Click.activate
ROUTE TS72.isOver TO C72_Over.activate
ROUTE TS72.isOver TO C72_Out.reverseActivate
ROUTE V72_Over.outSFVec2f TO SC.mouseOver
ROUTE V72_Out.outSFVec2f TO SC.mouseOut
ROUTE V72_Click.outSFVec2f TO SC.click
ROUTE TS73.isActive TO C73_Click.activate
ROUTE TS73.isOver TO C73_Over.activate
ROUTE TS73.isOver TO C73_Out.reverseActivate
ROUTE V73_Over.outSFVec2f TO SC.mouseOver
ROUTE V73_Out.outSFVec2f TO SC.mouseOut
ROUTE V73_Click.outSFVec2f TO SC.click
ROUTE TS74.isActive TO C74_Click.activate
ROUTE TS74.isOver TO C74_Over.activate
ROUTE TS74.isOver TO C74_Out.reverseActivate
ROUTE V74_Over.outSFVec2f TO SC.mouseOver
ROUTE V74_Out.outSFVec2f TO SC.mouseOut
ROUTE V74_Click.outSFVec2f TO SC.click
ROUTE TS75.isActive TO C75_Click.activate
ROUTE TS75.isOver TO C75_Over.activate
ROUTE TS75.isOver TO C75_Out.reverseActivate
ROUTE V75_Over.outSFVec2f TO SC.mouseOver
ROUTE V75_Out.outSFVec2f TO SC.mouseOut
ROUTE V75_Click.outSFVec2f TO SC.click
ROUTE TS76.isActive TO C76_Click.activate
ROUTE TS76.isOver TO C76_Over.activate
ROUTE TS76.isOver TO C76_Out.reverseActivate
ROUTE V76_Over.outSFVec2f TO SC.mouseOver
ROUTE V76_Out.outSFVec2f TO SC.mouseOut
ROUTE V76_Click.outSFVec2f TO SC.click
ROUTE TS77.isActive TO C77_Click.activate
ROUTE TS77.isOver TO C77_Over.activate
ROUTE TS77.isOver TO C77_Out.reverseActivate
ROUTE V77_Over.outSFVec2f TO SC.mouseOver
ROUTE V77_Out.outSFVec2f TO SC.mouseOut
ROUTE V77_Click.outSFVec2f TO SC.click