<!-- Hide script from old browsers
		
		function newWindow (imgName)
		{
			imgWindow = window.open ( imgName, "imgWin", 'toolbar=no,location=yes,scrollbars=yes,resizable=yes,width=700,height=700')
			imgWindow.focus()
		}
		
		function newAVI (pageURL)
		{
			imgWindow = window.open ( pageURL, "imgWin", 'toolbar=no,location=yes,scrollbars=yes,resizable=yes,width=500,height=400')
			imgWindow.focus()
		}
		
		var DELAY = 20
		var STEP = 100
		var IMGLEN = 150
		var IMGLONG = 133
		var MAXIMGLEN = 280
		var FACTOR = 10
		var FACTOR_LONG = 1.33
		var MAXFACTOR = 20
		var DCVALUE = 0
		var PORTRAIT = 1
		var LANDSCAPE = 0
		
		var t1
		var s1
		var orient1
		var count1 = 0
		var tick1 = 0
		 rImg1 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img1 = new Image(IMGLEN, IMGLEN)
				
		function setOrient1(or)
		{
			orient1 = or;
		}		
		function size1(Xfact)
		{
			if ( orient1 == LANDSCAPE )
				document.pic1.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic1.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand1()
		{
			if ( tick1 < MAXFACTOR) 
			{
				if ( count1 > DELAY )
					tick1 ++
				else
					count1 ++
				
				size1(tick1 )	
				t1 = setTimeout("expand1()", STEP )
			}
		}
		function epdImg1 (imgName )
		{
			clearTimeout(s1)
			rImg1.src = imgName
			return rImg1.src
		}		
		function shrink1()
		{
			if ( tick1 >= DCVALUE) 
			{
				size1(tick1);
				if ( tick1 > DCVALUE )
					tick1 = tick1 - 1
					
				s1 = setTimeout("shrink1()", STEP )
			}
			if ( tick1 == DCVALUE )
				count1 = DCVALUE
		}	
		function shkImg1(imgName)
		{
			clearTimeout(t1)
			img1.src = imgName
			return img1.src
		}
		
		var t2
		var s2
		var orient2
		var count2 = 0
		var tick2 = 0
		 rImg2 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img2 = new Image(IMGLEN, IMGLEN)
				
		function setOrient2(or)
		{
			orient2 = or;
		}		
		function size2(Xfact)
		{
			if ( orient2 == LANDSCAPE )
				document.pic2.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic2.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand2()
		{
			if ( tick2 < MAXFACTOR) 
			{
				if ( count2 > DELAY )
					tick2 ++
				else
					count2 ++
				
				size2(tick2 )	
				t2 = setTimeout("expand2()", STEP )
			}
		}
		function epdImg2 (imgName )
		{
			clearTimeout(s2)
			rImg2.src = imgName
			return rImg2.src
		}		
		function shrink2()
		{
			if ( tick2 >= DCVALUE) 
			{
				size2(tick2);
				if ( tick2 > DCVALUE )
					tick2 = tick2 - 1
					
				s2 = setTimeout("shrink2()", STEP )
			}
			if ( tick2 == DCVALUE )
				count2 = DCVALUE
		}	
		function shkImg2(imgName)
		{
			clearTimeout(t2)
			img2.src = imgName
			return img2.src
		}
		
				var t3
		var s3
		var orient3
		var count3 = 0
		var tick3 = 0
		 rImg3 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img3 = new Image(IMGLEN, IMGLEN)
				
		function setOrient3(or)
		{
			orient3 = or;
		}		
		function size3(Xfact)
		{
			if ( orient3 == LANDSCAPE )
				document.pic3.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic3.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand3()
		{
			if ( tick3 < MAXFACTOR) 
			{
				if ( count3 > DELAY )
					tick3 ++
				else
					count3 ++
				
				size3(tick3 )	
				t3 = setTimeout("expand3()", STEP )
			}
		}
		function epdImg3 (imgName )
		{
			clearTimeout(s3)
			rImg3.src = imgName
			return rImg3.src
		}		
		function shrink3()
		{
			if ( tick3 >= DCVALUE) 
			{
				size3(tick3);
				if ( tick3 > DCVALUE )
					tick3 = tick3 - 1
					
				s3 = setTimeout("shrink3()", STEP )
			}
			if ( tick3 == DCVALUE )
				count3 = DCVALUE
		}	
		function shkImg3(imgName)
		{
			clearTimeout(t3)
			img3.src = imgName
			return img3.src
		}
		
				var t4
		var s4
		var orient4
		var count4 = 0
		var tick4 = 0
		 rImg4 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img4 = new Image(IMGLEN, IMGLEN)
				
		function setOrient4(or)
		{
			orient4 = or;
		}		
		function size4(Xfact)
		{
			if ( orient4 == LANDSCAPE )
				document.pic4.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic4.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand4()
		{
			if ( tick4 < MAXFACTOR) 
			{
				if ( count4 > DELAY )
					tick4 ++
				else
					count4 ++
				
				size4(tick4 )	
				t4 = setTimeout("expand4()", STEP )
			}
		}
		function epdImg4 (imgName )
		{
			clearTimeout(s4)
			rImg4.src = imgName
			return rImg4.src
		}		
		function shrink4()
		{
			if ( tick4 >= DCVALUE) 
			{
				size4(tick4);
				if ( tick4 > DCVALUE )
					tick4 = tick4 - 1
					
				s4 = setTimeout("shrink4()", STEP )
			}
			if ( tick4 == DCVALUE )
				count4 = DCVALUE
		}	
		function shkImg4(imgName)
		{
			clearTimeout(t4)
			img4.src = imgName
			return img4.src
		}
		
				var t5
		var s5
		var orient5
		var count5 = 0
		var tick5 = 0
		 rImg5 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img5 = new Image(IMGLEN, IMGLEN)
				
		function setOrient5(or)
		{
			orient5 = or;
		}		
		function size5(Xfact)
		{
			if ( orient5 == LANDSCAPE )
				document.pic5.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic5.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand5()
		{
			if ( tick5 < MAXFACTOR) 
			{
				if ( count5 > DELAY )
					tick5 ++
				else
					count5 ++
				
				size5(tick5 )	
				t5 = setTimeout("expand5()", STEP )
			}
		}
		function epdImg5 (imgName )
		{
			clearTimeout(s5)
			rImg5.src = imgName
			return rImg5.src
		}		
		function shrink5()
		{
			if ( tick5 >= DCVALUE) 
			{
				size5(tick5);
				if ( tick5 > DCVALUE )
					tick5 = tick5 - 1
					
				s5 = setTimeout("shrink5()", STEP )
			}
			if ( tick5 == DCVALUE )
				count5 = DCVALUE
		}	
		function shkImg5(imgName)
		{
			clearTimeout(t5)
			img5.src = imgName
			return img5.src
		}		
		
				var t6
		var s6
		var orient6
		var count6 = 0
		var tick6 = 0
		 rImg6 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img6 = new Image(IMGLEN, IMGLEN)
				
		function setOrient6(or)
		{
			orient6 = or;
		}		
		function size6(Xfact)
		{
			if ( orient6 == LANDSCAPE )
				document.pic6.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic6.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand6()
		{
			if ( tick6 < MAXFACTOR) 
			{
				if ( count6 > DELAY )
					tick6 ++
				else
					count6 ++
				
				size6(tick6 )	
				t6 = setTimeout("expand6()", STEP )
			}
		}
		function epdImg6 (imgName )
		{
			clearTimeout(s6)
			rImg6.src = imgName
			return rImg6.src
		}		
		function shrink6()
		{
			if ( tick6 >= DCVALUE) 
			{
				size6(tick6);
				if ( tick6 > DCVALUE )
					tick6 = tick6 - 1
					
				s6 = setTimeout("shrink6()", STEP )
			}
			if ( tick6 == DCVALUE )
				count6 = DCVALUE
		}	
		function shkImg6(imgName)
		{
			clearTimeout(t6)
			img6.src = imgName
			return img6.src
		}
		
				var t7
		var s7
		var orient7
		var count7 = 0
		var tick7 = 0
		 rImg7 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img7 = new Image(IMGLEN, IMGLEN)
				
		function setOrient7(or)
		{
			orient7 = or;
		}		
		function size7(Xfact)
		{
			if ( orient7 == LANDSCAPE )
				document.pic7.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic7.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand7()
		{
			if ( tick7 < MAXFACTOR) 
			{
				if ( count7 > DELAY )
					tick7 ++
				else
					count7 ++
				
				size7(tick7 )	
				t7 = setTimeout("expand7()", STEP )
			}
		}
		function epdImg7 (imgName )
		{
			clearTimeout(s7)
			rImg7.src = imgName
			return rImg7.src
		}		
		function shrink7()
		{
			if ( tick7 >= DCVALUE) 
			{
				size7(tick7);
				if ( tick7 > DCVALUE )
					tick7 = tick7 - 1
					
				s7 = setTimeout("shrink7()", STEP )
			}
			if ( tick7 == DCVALUE )
				count7 = DCVALUE
		}	
		function shkImg7(imgName)
		{
			clearTimeout(t7)
			img7.src = imgName
			return img7.src
		}
		
				var t8
		var s8
		var orient8
		var count8 = 0
		var tick8 = 0
		 rImg8 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img8 = new Image(IMGLEN, IMGLEN)
				
		function setOrient8(or)
		{
			orient8 = or;
		}		
		function size8(Xfact)
		{
			if ( orient8 == LANDSCAPE )
				document.pic8.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic8.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand8()
		{
			if ( tick8 < MAXFACTOR) 
			{
				if ( count8 > DELAY )
					tick8 ++
				else
					count8 ++
				
				size8(tick8 )	
				t8 = setTimeout("expand8()", STEP )
			}
		}
		function epdImg8 (imgName )
		{
			clearTimeout(s8)
			rImg8.src = imgName
			return rImg8.src
		}		
		function shrink8()
		{
			if ( tick8 >= DCVALUE) 
			{
				size8(tick8);
				if ( tick8 > DCVALUE )
					tick8 = tick8 - 1
					
				s8 = setTimeout("shrink8()", STEP )
			}
			if ( tick8 == DCVALUE )
				count8 = DCVALUE
		}	
		function shkImg8(imgName)
		{
			clearTimeout(t8)
			img8.src = imgName
			return img8.src
		}
		
				var t9
		var s9
		var orient9
		var count9 = 0
		var tick9 = 0
		 rImg9 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img9 = new Image(IMGLEN, IMGLEN)
				
		function setOrient9(or)
		{
			orient9 = or;
		}		
		function size9(Xfact)
		{
			if ( orient9 == LANDSCAPE )
				document.pic9.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic9.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand9()
		{
			if ( tick9 < MAXFACTOR) 
			{
				if ( count9 > DELAY )
					tick9 ++
				else
					count9 ++
				
				size9(tick9 )	
				t9 = setTimeout("expand9()", STEP )
			}
		}
		function epdImg9 (imgName )
		{
			clearTimeout(s9)
			rImg9.src = imgName
			return rImg9.src
		}		
		function shrink9()
		{
			if ( tick9 >= DCVALUE) 
			{
				size9(tick9);
				if ( tick9 > DCVALUE )
					tick9 = tick9 - 1
					
				s9 = setTimeout("shrink9()", STEP )
			}
			if ( tick9 == DCVALUE )
				count9 = DCVALUE
		}	
		function shkImg9(imgName)
		{
			clearTimeout(t9)
			img9.src = imgName
			return img9.src
		}
		
				var t10
		var s10
		var orient10
		var count10 = 0
		var tick10 = 0
		 rImg10 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img10 = new Image(IMGLEN, IMGLEN)
				
		function setOrient10(or)
		{
			orient10 = or;
		}		
		function size10(Xfact)
		{
			if ( orient10 == LANDSCAPE )
				document.pic10.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic10.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand10()
		{
			if ( tick10 < MAXFACTOR) 
			{
				if ( count10 > DELAY )
					tick10 ++
				else
					count10 ++
				
				size10(tick10 )	
				t10 = setTimeout("expand10()", STEP )
			}
		}
		function epdImg10 (imgName )
		{
			clearTimeout(s10)
			rImg10.src = imgName
			return rImg10.src
		}		
		function shrink10()
		{
			if ( tick10 >= DCVALUE) 
			{
				size10(tick10);
				if ( tick10 > DCVALUE )
					tick10 = tick10 - 1
					
				s10 = setTimeout("shrink10()", STEP )
			}
			if ( tick10 == DCVALUE )
				count10 = DCVALUE
		}	
		function shkImg10(imgName)
		{
			clearTimeout(t10)
			img10.src = imgName
			return img10.src
		}
		
				var t11
		var s11
		var orient11
		var count11 = 0
		var tick11 = 0
		 rImg11 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img11 = new Image(IMGLEN, IMGLEN)
				
		function setOrient11(or)
		{
			orient11 = or;
		}		
		function size11(Xfact)
		{
			if ( orient11 == LANDSCAPE )
				document.pic11.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic11.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand11()
		{
			if ( tick11 < MAXFACTOR) 
			{
				if ( count11 > DELAY )
					tick11 ++
				else
					count11 ++
				
				size11(tick11 )	
				t11 = setTimeout("expand11()", STEP )
			}
		}
		function epdImg11 (imgName )
		{
			clearTimeout(s11)
			rImg11.src = imgName
			return rImg11.src
		}		
		function shrink11()
		{
			if ( tick11 >= DCVALUE) 
			{
				size11(tick11);
				if ( tick11 > DCVALUE )
					tick11 = tick11 - 1
					
				s11 = setTimeout("shrink11()", STEP )
			}
			if ( tick11 == DCVALUE )
				count11 = DCVALUE
		}	
		function shkImg11(imgName)
		{
			clearTimeout(t11)
			img11.src = imgName
			return img11.src
		}
		
				var t12
		var s12
		var orient12
		var count12 = 0
		var tick12 = 0
		 rImg12 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img12 = new Image(IMGLEN, IMGLEN)
				
		function setOrient12(or)
		{
			orient12 = or;
		}		
		function size12(Xfact)
		{
			if ( orient12 == LANDSCAPE )
				document.pic12.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic12.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand12()
		{
			if ( tick12 < MAXFACTOR) 
			{
				if ( count12 > DELAY )
					tick12 ++
				else
					count12 ++
				
				size12(tick12 )	
				t12 = setTimeout("expand12()", STEP )
			}
		}
		function epdImg12 (imgName )
		{
			clearTimeout(s12)
			rImg12.src = imgName
			return rImg12.src
		}		
		function shrink12()
		{
			if ( tick12 >= DCVALUE) 
			{
				size12(tick12);
				if ( tick12 > DCVALUE )
					tick12 = tick12 - 1
					
				s12 = setTimeout("shrink12()", STEP )
			}
			if ( tick12 == DCVALUE )
				count12 = DCVALUE
		}	
		function shkImg12(imgName)
		{
			clearTimeout(t12)
			img12.src = imgName
			return img12.src
		}
		
				var t13
		var s13
		var orient13
		var count13 = 0
		var tick13 = 0
		 rImg13 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img13 = new Image(IMGLEN, IMGLEN)
				
		function setOrient13(or)
		{
			orient13 = or;
		}		
		function size13(Xfact)
		{
			if ( orient13 == LANDSCAPE )
				document.pic13.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic13.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand13()
		{
			if ( tick13 < MAXFACTOR) 
			{
				if ( count13 > DELAY )
					tick13 ++
				else
					count13 ++
				
				size13(tick13 )	
				t13 = setTimeout("expand13()", STEP )
			}
		}
		function epdImg13 (imgName )
		{
			clearTimeout(s13)
			rImg13.src = imgName
			return rImg13.src
		}		
		function shrink13()
		{
			if ( tick13 >= DCVALUE) 
			{
				size13(tick13);
				if ( tick13 > DCVALUE )
					tick13 = tick13 - 1
					
				s13 = setTimeout("shrink13()", STEP )
			}
			if ( tick13 == DCVALUE )
				count13 = DCVALUE
		}	
		function shkImg13(imgName)
		{
			clearTimeout(t13)
			img13.src = imgName
			return img13.src
		}
		
				var t14
		var s14
		var orient14
		var count14 = 0
		var tick14 = 0
		 rImg14 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img14 = new Image(IMGLEN, IMGLEN)
				
		function setOrient14(or)
		{
			orient14 = or;
		}		
		function size14(Xfact)
		{
			if ( orient14 == LANDSCAPE )
				document.pic14.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic14.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand14()
		{
			if ( tick14 < MAXFACTOR) 
			{
				if ( count14 > DELAY )
					tick14 ++
				else
					count14 ++
				
				size14(tick14 )	
				t14 = setTimeout("expand14()", STEP )
			}
		}
		function epdImg14 (imgName )
		{
			clearTimeout(s14)
			rImg14.src = imgName
			return rImg14.src
		}		
		function shrink14()
		{
			if ( tick14 >= DCVALUE) 
			{
				size14(tick14);
				if ( tick14 > DCVALUE )
					tick14 = tick14 - 1
					
				s14 = setTimeout("shrink14()", STEP )
			}
			if ( tick14 == DCVALUE )
				count14 = DCVALUE
		}	
		function shkImg14(imgName)
		{
			clearTimeout(t14)
			img14.src = imgName
			return img14.src
		}
		
				var t15
		var s15
		var orient15
		var count15 = 0
		var tick15 = 0
		 rImg15 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img15 = new Image(IMGLEN, IMGLEN)
				
		function setOrient15(or)
		{
			orient15 = or;
		}		
		function size15(Xfact)
		{
			if ( orient15 == LANDSCAPE )
				document.pic15.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic15.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand15()
		{
			if ( tick15 < MAXFACTOR) 
			{
				if ( count15 > DELAY )
					tick15 ++
				else
					count15 ++
				
				size15(tick15 )	
				t15 = setTimeout("expand15()", STEP )
			}
		}
		function epdImg15 (imgName )
		{
			clearTimeout(s15)
			rImg15.src = imgName
			return rImg15.src
		}		
		function shrink15()
		{
			if ( tick15 >= DCVALUE) 
			{
				size15(tick15);
				if ( tick15 > DCVALUE )
					tick15 = tick15 - 1
					
				s15 = setTimeout("shrink15()", STEP )
			}
			if ( tick15 == DCVALUE )
				count15 = DCVALUE
		}	
		function shkImg15(imgName)
		{
			clearTimeout(t15)
			img15.src = imgName
			return img15.src
		}
				var t16
		var s16
		var orient16
		var count16 = 0
		var tick16 = 0
		 rImg16 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img16 = new Image(IMGLEN, IMGLEN)
				
		function setOrient16(or)
		{
			orient16 = or;
		}		
		function size16(Xfact)
		{
			if ( orient16 == LANDSCAPE )
				document.pic16.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic16.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand16()
		{
			if ( tick16 < MAXFACTOR) 
			{
				if ( count16 > DELAY )
					tick16 ++
				else
					count16 ++
				
				size16(tick16 )	
				t16 = setTimeout("expand16()", STEP )
			}
		}
		function epdImg16 (imgName )
		{
			clearTimeout(s16)
			rImg16.src = imgName
			return rImg16.src
		}		
		function shrink16()
		{
			if ( tick16 >= DCVALUE) 
			{
				size16(tick16);
				if ( tick16 > DCVALUE )
					tick16 = tick16 - 1
					
				s16 = setTimeout("shrink16()", STEP )
			}
			if ( tick16 == DCVALUE )
				count16 = DCVALUE
		}	
		function shkImg16(imgName)
		{
			clearTimeout(t16)
			img16.src = imgName
			return img16.src
		}
		
				var t17
		var s17
		var orient17
		var count17 = 0
		var tick17 = 0
		 rImg17 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img17 = new Image(IMGLEN, IMGLEN)
				
		function setOrient17(or)
		{
			orient17 = or;
		}		
		function size17(Xfact)
		{
			if ( orient17 == LANDSCAPE )
				document.pic17.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic17.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand17()
		{
			if ( tick17 < MAXFACTOR) 
			{
				if ( count17 > DELAY )
					tick17 ++
				else
					count17 ++
				
				size17(tick17 )	
				t17 = setTimeout("expand17()", STEP )
			}
		}
		function epdImg17 (imgName )
		{
			clearTimeout(s17)
			rImg17.src = imgName
			return rImg17.src
		}		
		function shrink17()
		{
			if ( tick17 >= DCVALUE) 
			{
				size17(tick17);
				if ( tick17 > DCVALUE )
					tick17 = tick17 - 1
					
				s17 = setTimeout("shrink17()", STEP )
			}
			if ( tick17 == DCVALUE )
				count17 = DCVALUE
		}	
		function shkImg17(imgName)
		{
			clearTimeout(t17)
			img17.src = imgName
			return img17.src
		}
		
				var t18
		var s18
		var orient18
		var count18 = 0
		var tick18 = 0
		 rImg18 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img18 = new Image(IMGLEN, IMGLEN)
				
		function setOrient18(or)
		{
			orient18 = or;
		}		
		function size18(Xfact)
		{
			if ( orient18 == LANDSCAPE )
				document.pic18.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic18.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand18()
		{
			if ( tick18 < MAXFACTOR) 
			{
				if ( count18 > DELAY )
					tick18 ++
				else
					count18 ++
				
				size18(tick18 )	
				t18 = setTimeout("expand18()", STEP )
			}
		}
		function epdImg18 (imgName )
		{
			clearTimeout(s18)
			rImg18.src = imgName
			return rImg18.src
		}		
		function shrink18()
		{
			if ( tick18 >= DCVALUE) 
			{
				size18(tick18);
				if ( tick18 > DCVALUE )
					tick18 = tick18 - 1
					
				s18 = setTimeout("shrink18()", STEP )
			}
			if ( tick18 == DCVALUE )
				count18 = DCVALUE
		}	
		function shkImg18(imgName)
		{
			clearTimeout(t18)
			img18.src = imgName
			return img18.src
		}
		
				var t19
		var s19
		var orient19
		var count19 = 0
		var tick19 = 0
		 rImg19 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img19 = new Image(IMGLEN, IMGLEN)
				
		function setOrient19(or)
		{
			orient19 = or;
		}		
		function size19(Xfact)
		{
			if ( orient19 == LANDSCAPE )
				document.pic19.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic19.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand19()
		{
			if ( tick19 < MAXFACTOR) 
			{
				if ( count19 > DELAY )
					tick19 ++
				else
					count19 ++
				
				size19(tick19 )	
				t19 = setTimeout("expand19()", STEP )
			}
		}
		function epdImg19 (imgName )
		{
			clearTimeout(s19)
			rImg19.src = imgName
			return rImg19.src
		}		
		function shrink19()
		{
			if ( tick19 >= DCVALUE) 
			{
				size19(tick19);
				if ( tick19 > DCVALUE )
					tick19 = tick19 - 1
					
				s19 = setTimeout("shrink19()", STEP )
			}
			if ( tick19 == DCVALUE )
				count19 = DCVALUE
		}	
		function shkImg19(imgName)
		{
			clearTimeout(t19)
			img19.src = imgName
			return img19.src
		}
		
				var t20
		var s20
		var orient20
		var count20 = 0
		var tick20 = 0
		 rImg20 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img20 = new Image(IMGLEN, IMGLEN)
				
		function setOrient20(or)
		{
			orient20 = or;
		}		
		function size20(Xfact)
		{
			if ( orient20 == LANDSCAPE )
				document.pic20.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic20.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand20()
		{
			if ( tick20 < MAXFACTOR) 
			{
				if ( count20 > DELAY )
					tick20 ++
				else
					count20 ++
				
				size20(tick20 )	
				t20 = setTimeout("expand20()", STEP )
			}
		}
		function epdImg20 (imgName )
		{
			clearTimeout(s20)
			rImg20.src = imgName
			return rImg20.src
		}		
		function shrink20()
		{
			if ( tick20 >= DCVALUE) 
			{
				size20(tick20);
				if ( tick20 > DCVALUE )
					tick20 = tick20 - 1
					
				s20 = setTimeout("shrink20()", STEP )
			}
			if ( tick20 == DCVALUE )
				count20 = DCVALUE
		}	
		function shkImg20(imgName)
		{
			clearTimeout(t20)
			img20.src = imgName
			return img20.src
		}
		
				var t21
		var s21
		var orient21
		var count21 = 0
		var tick21 = 0
		 rImg21 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img21 = new Image(IMGLEN, IMGLEN)
				
		function setOrient21(or)
		{
			orient21 = or;
		}		
		function size21(Xfact)
		{
			if ( orient21 == LANDSCAPE )
				document.pic21.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic21.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand21()
		{
			if ( tick21 < MAXFACTOR) 
			{
				if ( count21 > DELAY )
					tick21 ++
				else
					count21 ++
				
				size21(tick21 )	
				t21 = setTimeout("expand21()", STEP )
			}
		}
		function epdImg21 (imgName )
		{
			clearTimeout(s21)
			rImg21.src = imgName
			return rImg21.src
		}		
		function shrink21()
		{
			if ( tick21 >= DCVALUE) 
			{
				size21(tick21);
				if ( tick21 > DCVALUE )
					tick21 = tick21 - 1
					
				s21 = setTimeout("shrink21()", STEP )
			}
			if ( tick21 == DCVALUE )
				count21 = DCVALUE
		}	
		function shkImg21(imgName)
		{
			clearTimeout(t21)
			img21.src = imgName
			return img21.src
		}
		
				var t22
		var s22
		var orient22
		var count22 = 0
		var tick22 = 0
		 rImg22 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img22 = new Image(IMGLEN, IMGLEN)
				
		function setOrient22(or)
		{
			orient22 = or;
		}		
		function size22(Xfact)
		{
			if ( orient22 == LANDSCAPE )
				document.pic22.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic22.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand22()
		{
			if ( tick22 < MAXFACTOR) 
			{
				if ( count22 > DELAY )
					tick22 ++
				else
					count22 ++
				
				size22(tick22 )	
				t22 = setTimeout("expand22()", STEP )
			}
		}
		function epdImg22 (imgName )
		{
			clearTimeout(s22)
			rImg22.src = imgName
			return rImg22.src
		}		
		function shrink22()
		{
			if ( tick22 >= DCVALUE) 
			{
				size22(tick22);
				if ( tick22 > DCVALUE )
					tick22 = tick22 - 1
					
				s22 = setTimeout("shrink22()", STEP )
			}
			if ( tick22 == DCVALUE )
				count22 = DCVALUE
		}	
		function shkImg22(imgName)
		{
			clearTimeout(t22)
			img22.src = imgName
			return img22.src
		}
		
				var t23
		var s23
		var orient23
		var count23 = 0
		var tick23 = 0
		 rImg23 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img23 = new Image(IMGLEN, IMGLEN)
				
		function setOrient23(or)
		{
			orient23 = or;
		}		
		function size23(Xfact)
		{
			if ( orient23 == LANDSCAPE )
				document.pic23.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic23.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand23()
		{
			if ( tick23 < MAXFACTOR) 
			{
				if ( count23 > DELAY )
					tick23 ++
				else
					count23 ++
				
				size23(tick23 )	
				t23 = setTimeout("expand23()", STEP )
			}
		}
		function epdImg23 (imgName )
		{
			clearTimeout(s23)
			rImg23.src = imgName
			return rImg23.src
		}		
		function shrink23()
		{
			if ( tick23 >= DCVALUE) 
			{
				size23(tick23);
				if ( tick23 > DCVALUE )
					tick23 = tick23 - 1
					
				s23 = setTimeout("shrink23()", STEP )
			}
			if ( tick23 == DCVALUE )
				count23 = DCVALUE
		}	
		function shkImg23(imgName)
		{
			clearTimeout(t23)
			img23.src = imgName
			return img23.src
		}
		
				var t24
		var s24
		var orient24
		var count24 = 0
		var tick24 = 0
		 rImg24 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img24 = new Image(IMGLEN, IMGLEN)
				
		function setOrient24(or)
		{
			orient24 = or;
		}		
		function size24(Xfact)
		{
			if ( orient24 == LANDSCAPE )
				document.pic24.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic24.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand24()
		{
			if ( tick24 < MAXFACTOR) 
			{
				if ( count24 > DELAY )
					tick24 ++
				else
					count24 ++
				
				size24(tick24 )	
				t24 = setTimeout("expand24()", STEP )
			}
		}
		function epdImg24 (imgName )
		{
			clearTimeout(s24)
			rImg24.src = imgName
			return rImg24.src
		}		
		function shrink24()
		{
			if ( tick24 >= DCVALUE) 
			{
				size24(tick24);
				if ( tick24 > DCVALUE )
					tick24 = tick24 - 1
					
				s24 = setTimeout("shrink24()", STEP )
			}
			if ( tick24 == DCVALUE )
				count24 = DCVALUE
		}	
		function shkImg24(imgName)
		{
			clearTimeout(t24)
			img24.src = imgName
			return img24.src
		}
		
				var t25
		var s25
		var orient25
		var count25 = 0
		var tick25 = 0
		 rImg25 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img25 = new Image(IMGLEN, IMGLEN)
				
		function setOrient25(or)
		{
			orient25 = or;
		}		
		function size25(Xfact)
		{
			if ( orient25 == LANDSCAPE )
				document.pic25.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic25.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand25()
		{
			if ( tick25 < MAXFACTOR) 
			{
				if ( count25 > DELAY )
					tick25 ++
				else
					count25 ++
				
				size25(tick25 )	
				t25 = setTimeout("expand25()", STEP )
			}
		}
		function epdImg25 (imgName )
		{
			clearTimeout(s25)
			rImg25.src = imgName
			return rImg25.src
		}		
		function shrink25()
		{
			if ( tick25 >= DCVALUE) 
			{
				size25(tick25);
				if ( tick25 > DCVALUE )
					tick25 = tick25 - 1
					
				s25 = setTimeout("shrink25()", STEP )
			}
			if ( tick25 == DCVALUE )
				count25 = DCVALUE
		}	
		function shkImg25(imgName)
		{
			clearTimeout(t25)
			img25.src = imgName
			return img25.src
		}
		
				var t26
		var s26
		var orient26
		var count26 = 0
		var tick26 = 0
		 rImg26 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img26 = new Image(IMGLEN, IMGLEN)
				
		function setOrient26(or)
		{
			orient26 = or;
		}		
		function size26(Xfact)
		{
			if ( orient26 == LANDSCAPE )
				document.pic26.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic26.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand26()
		{
			if ( tick26 < MAXFACTOR) 
			{
				if ( count26 > DELAY )
					tick26 ++
				else
					count26 ++
				
				size26(tick26 )	
				t26 = setTimeout("expand26()", STEP )
			}
		}
		function epdImg26 (imgName )
		{
			clearTimeout(s26)
			rImg26.src = imgName
			return rImg26.src
		}		
		function shrink26()
		{
			if ( tick26 >= DCVALUE) 
			{
				size26(tick26);
				if ( tick26 > DCVALUE )
					tick26 = tick26 - 1
					
				s26 = setTimeout("shrink26()", STEP )
			}
			if ( tick26 == DCVALUE )
				count26 = DCVALUE
		}	
		function shkImg26(imgName)
		{
			clearTimeout(t26)
			img26.src = imgName
			return img26.src
		}
		
				var t27
		var s27
		var orient27
		var count27 = 0
		var tick27 = 0
		 rImg27 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img27 = new Image(IMGLEN, IMGLEN)
				
		function setOrient27(or)
		{
			orient27 = or;
		}		
		function size27(Xfact)
		{
			if ( orient27 == LANDSCAPE )
				document.pic27.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic27.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand27()
		{
			if ( tick27 < MAXFACTOR) 
			{
				if ( count27 > DELAY )
					tick27 ++
				else
					count27 ++
				
				size27(tick27 )	
				t27 = setTimeout("expand27()", STEP )
			}
		}
		function epdImg27 (imgName )
		{
			clearTimeout(s27)
			rImg27.src = imgName
			return rImg27.src
		}		
		function shrink27()
		{
			if ( tick27 >= DCVALUE) 
			{
				size27(tick27);
				if ( tick27 > DCVALUE )
					tick27 = tick27 - 1
					
				s27 = setTimeout("shrink27()", STEP )
			}
			if ( tick27 == DCVALUE )
				count27 = DCVALUE
		}	
		function shkImg27(imgName)
		{
			clearTimeout(t27)
			img27.src = imgName
			return img27.src
		}
		
				var t28
		var s28
		var orient28
		var count28 = 0
		var tick28 = 0
		 rImg28 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img28 = new Image(IMGLEN, IMGLEN)
				
		function setOrient28(or)
		{
			orient28 = or;
		}		
		function size28(Xfact)
		{
			if ( orient28 == LANDSCAPE )
				document.pic28.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic28.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand28()
		{
			if ( tick28 < MAXFACTOR) 
			{
				if ( count28 > DELAY )
					tick28 ++
				else
					count28 ++
				
				size28(tick28 )	
				t28 = setTimeout("expand28()", STEP )
			}
		}
		function epdImg28 (imgName )
		{
			clearTimeout(s28)
			rImg28.src = imgName
			return rImg28.src
		}		
		function shrink28()
		{
			if ( tick28 >= DCVALUE) 
			{
				size28(tick28);
				if ( tick28 > DCVALUE )
					tick28 = tick28 - 1
					
				s28 = setTimeout("shrink28()", STEP )
			}
			if ( tick28 == DCVALUE )
				count28 = DCVALUE
		}	
		function shkImg28(imgName)
		{
			clearTimeout(t28)
			img28.src = imgName
			return img28.src
		}
		
				var t29
		var s29
		var orient29
		var count29 = 0
		var tick29 = 0
		 rImg29 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img29 = new Image(IMGLEN, IMGLEN)
				
		function setOrient29(or)
		{
			orient29 = or;
		}		
		function size29(Xfact)
		{
			if ( orient29 == LANDSCAPE )
				document.pic29.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic29.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand29()
		{
			if ( tick29 < MAXFACTOR) 
			{
				if ( count29 > DELAY )
					tick29 ++
				else
					count29 ++
				
				size29(tick29 )	
				t29 = setTimeout("expand29()", STEP )
			}
		}
		function epdImg29 (imgName )
		{
			clearTimeout(s29)
			rImg29.src = imgName
			return rImg29.src
		}		
		function shrink29()
		{
			if ( tick29 >= DCVALUE) 
			{
				size29(tick29);
				if ( tick29 > DCVALUE )
					tick29 = tick29 - 1
					
				s29 = setTimeout("shrink29()", STEP )
			}
			if ( tick29 == DCVALUE )
				count29 = DCVALUE
		}	
		function shkImg29(imgName)
		{
			clearTimeout(t29)
			img29.src = imgName
			return img29.src
		}
		
				var t30
		var s30
		var orient30
		var count30 = 0
		var tick30 = 0
		 rImg30 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img30 = new Image(IMGLEN, IMGLEN)
				
		function setOrient30(or)
		{
			orient30 = or;
		}		
		function size30(Xfact)
		{
			if ( orient30 == LANDSCAPE )
				document.pic30.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic30.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand30()
		{
			if ( tick30 < MAXFACTOR) 
			{
				if ( count30 > DELAY )
					tick30 ++
				else
					count30 ++
				
				size30(tick30 )	
				t30 = setTimeout("expand30()", STEP )
			}
		}
		function epdImg30 (imgName )
		{
			clearTimeout(s30)
			rImg30.src = imgName
			return rImg30.src
		}		
		function shrink30()
		{
			if ( tick30 >= DCVALUE) 
			{
				size30(tick30);
				if ( tick30 > DCVALUE )
					tick30 = tick30 - 1
					
				s30 = setTimeout("shrink30()", STEP )
			}
			if ( tick30 == DCVALUE )
				count30 = DCVALUE
		}	
		function shkImg30(imgName)
		{
			clearTimeout(t30)
			img30.src = imgName
			return img30.src
		}
		
				var t31
		var s31
		var orient31
		var count31 = 0
		var tick31 = 0
		 rImg31 = new Image(MAXIMGLEN, MAXIMGLEN)
		 img31 = new Image(IMGLEN, IMGLEN)
				
		function setOrient31(or)
		{
			orient31 = or;
		}		
		function size31(Xfact)
		{
			if ( orient31 == LANDSCAPE )
				document.pic31.height = IMGLEN + (Xfact * FACTOR)
			else
				document.pic31.width = IMGLEN + (Xfact * FACTOR)
		}		
		function expand31()
		{
			if ( tick31 < MAXFACTOR) 
			{
				if ( count31 > DELAY )
					tick31 ++
				else
					count31 ++
				
				size31(tick31 )	
				t31 = setTimeout("expand31()", STEP )
			}
		}
		function epdImg31 (imgName )
		{
			clearTimeout(s31)
			rImg31.src = imgName
			return rImg31.src
		}		
		function shrink31()
		{
			if ( tick31 >= DCVALUE) 
			{
				size31(tick31);
				if ( tick31 > DCVALUE )
					tick31 = tick31 - 1
					
				s31 = setTimeout("shrink31()", STEP )
			}
			if ( tick31 == DCVALUE )
				count31 = DCVALUE
		}	
		function shkImg31(imgName)
		{
			clearTimeout(t31)
			img31.src = imgName
			return img31.src
		}
		// End hiding script from old browser -->