/* *****************************************
			*   program: FakeFlash v1.0                *
            *                                          *
			*   Készítette: veghsan, 25/02/2009        *
            *                                          *
            *******************************************/


		
		
/* ********************************************************************
*	LiveFader 
*		dinamikus átlátszóságváltozások kezelése
* */		
			  
	//------------------------------------------------------------
	// Az oldal aktuálisan változásban lévő elemeinek
	// tárolóobjektuma, óraütésre a változtatások
	// eszközölése.
	// Függvények: Add(obj) : LiveFader objektum hozzáadása a
	//                        a változásban lévők listájához
	//             Remove(obj): az objektum eltávolítása a listából
	//             Timer() :  periodikusan meghívja magát, a
	//                        az adott kör beli változtatásokat
	//                        hajtja végre
	LiveFaderContainer = 
	{
		list : Array(),
		fadeThread : false,
		
		Add : function(obj)
		{
			with (LiveFaderContainer)
			{
				if (fadeThread == false)
					SetSpeed(50);
				
				for (var i = 0; i < list.length; i++)
					if (list[i] == obj)
						return;
				list.push(obj);
			}
		},
		
		Remove : function(obj)
		{
			with (LiveFaderContainer)
			{
				for (var i = 0; i < list.length; i++)
					if (list[i] == obj)
					{
						list.splice(i,1);
						i--;
					}
				
				if (list.length == 0)
					SetSpeed(0);
			}
		},
		
		Timer : function()
		{
			var i;
			for (i = 0; i < LiveFaderContainer.list.length; i++)
			{
				var lfobj = LiveFaderContainer.list[i];
				
			    lfobj.curr += lfobj.step;
				if (((lfobj.step > 0) && (lfobj.curr > lfobj.target)) || 
					((lfobj.step < 0) && (lfobj.curr < lfobj.target))) 
						lfobj.curr = lfobj.target; 	
						
				
				if (lfobj.single)
					LiveFader.SetStyle(lfobj.obj, "opacity", lfobj.curr);
				else
					for (var j = 0; j < lfobj.obj.length; j++)
						LiveFader.SetStyle(lfobj.obj[j], "opacity", lfobj.curr);

				if (lfobj.curr == lfobj.target)    
				{
					LiveFaderContainer.Remove(lfobj);
					if (lfobj.target == lfobj.mod.min)
					{
						if (lfobj.mod.offdsp != false)
							if (lfobj.single)
								LiveFader.SetStyle(lfobj.obj, "dsp", lfobj.mod.offdsp);
							else
								for (j = 0; j < lfobj.obj.length; j++)
									LiveFader.SetStyle(lfobj.obj[j], "dsp", lfobj.mod.offdsp);
					}
					if (typeof(lfobj.onFinished) != "undefined")
						eval(lfobj.onFinished);
				}
			}
		},
		
		
		//--------------------------------------------------
		// SetSpeed : beállítja, hogy mennyi időn ként 
		// hívja meg a Timer függvényt a böngésző.
		SetSpeed : function (speed)
		{
			with (LiveFaderContainer)
			{
				if (fadeThread != false)
					clearInterval(fadeThread);
					
				if (speed == 0)
					LiveFaderContainer.fadeThread = false;
				else
					LiveFaderContainer.fadeThread = setInterval("LiveFaderContainer.Timer()", speed);
			}
		}

		
	};


	//---------------------------------------------------------------
	// LiveFader
	// HTML objektumok eltüntetéséhez és megjelenítését segítő
	// burkoló objektumok hozhatók vele létre, és kezelhetők.
	LiveFader =
	{
		fadeTypes : Array(),
		
		//------------------------------------------------------------
		// DefineFadeType : elhalvanyodasi tipus megadasa.
		// paraméterek: - name : a típus neve
		//              - add : bekapcsoláskor körönként ennyit 
		//                  változik az átlátszóság
		//              - sub : kikapcsoláskori körönkénti változás
		//              - min : kikapcsolt állapotban az átlátszóság
		//              - max : bekapcsolt állapotban az átlátszóság
		//              - ondsp : bekapcsolt és köztes állapotban a 
		//                 style.display tulajdonság. 
		//                 Ha false, nincs valtiztatas.
		//              - offdsp : kikapcsolt állapotban a display tul.
		DefineFadeType : function(name, add, sub, min, max, ondsp, offdsp)
		{
			LiveFader.fadeTypes[name] =
			{
				add : add,
				sub : sub,
				min : min,
				max : max,
				ondsp : ondsp,
				offdsp : offdsp
			};
		},
		
		
		//------------------------------------------------------------
		// LiveFader objektum "konstruktora". 
		// Egy csatolt html objektum / objektumtömb dinamikus el / elő-
		// tünését vezérlő adatstruktúra. Tárolja a jelenlegi állapotot,
		// a célállapotot a lehetséges szélső állapotokat, és az
		// aktuális célállapot elérésekor lefuttatandó kódot.
		//
		// Paraméterei: single   - egyetlen objektum / objektumtömb
		//              obj      - a html objektum / az objektumtömb
		//              fadeType - a dinamikus alakítás és végparaméterek
		//                        beállításához az objektum típusa.
		Create: function (single, obj, fadeType)
		{
			var gen = new Object();
			gen.single = single;
			gen.obj = obj;
			gen.onfinished = false;
			
			if (typeof(LiveFader.fadeTypes[fadeType]) == "undefined")
				alert("Error: LiveFader.Create - invalid fadeType (" + fadeType + ")");
			else
				gen.mod = LiveFader.fadeTypes[fadeType];
			
			gen.curr = gen.mod.min;
			return gen;
		},
		
		//----------------------------------------------------
		// SetStyle: egy html objektum átlátszóságának vagy
		// display-jének beállítása
		SetStyle : function (obj, property, val)
		{
			switch (property)
			{
				case "opacity":
					obj.style.opacity = val / 100;                             
					if (val == 100)
						obj.style.filter = "none";          
					else
						obj.style.filter = "alpha(opacity=" + val + ")";          
					break;
				case "dsp":
					obj.style.display = val;
					break;
			}
		},
		
		//----------------------------------------------------
		// LiveFader objektum bekapcsolása: célállapot maximumra
		// állítása, hozzáadás a változó obj.-ok listájához
		On : function(lfobj, onFinished)
		{
			lfobj.onFinished = onFinished;
			lfobj.step = lfobj.mod.add;
			lfobj.target = lfobj.mod.max;    
			
			if (lfobj.mod.ondsp != false)
				if (lfobj.single)
					LiveFader.SetStyle(lfobj.obj, "dsp", lfobj.mod.ondsp);
				else
					for (var i = 0; i < lfobj.obj.length; i++)
						LiveFader.SetStyle(lfobj.obj[i], "dsp", lfobj.mod.ondsp);
			
			LiveFaderContainer.Add(lfobj);
		},
		
		//----------------------------------------------------
		// LiveFader objektum kikapcsolása: célállapot, változási
		// paraméterek beállítása, változó obj. listájához adás
		Off : function(lfobj, onFinished)
		{
			lfobj.onFinished = onFinished;
			lfobj.step = lfobj.mod.sub;                                                                
			lfobj.target = lfobj.mod.min;      
			window.LiveFaderContainer.Add(lfobj);
		},
		
		
		//----------------------------------------------------
		// LiveFader objektum átkapcsolása: ha ki volt kapcsolva,
		// bekapcsoljuk, egyébként kikapcsoljuk.
		// paraméterek: - lfobj : livefader objektum
		Switch : function(lfobj)
		{
			if (lfobj.curr == lfobj.mod.max)
				LiveFader.Off(lfobj, "");
			else
				LiveFader.On(lfobj);
		},
		
		
		//----------------------------------------------------
		// LiveFader objektum azonnali bekapcsolása
		InstantOn : function(lfobj)
		{
			window.LiveFaderContainer.Remove(lfobj);

			lfobj.step = lfobj.mod.add;
			lfobj.target = lfobj.mod.max;
			lfobj.curr = lfobj.target;

			if (lfobj.single)
				LiveFader.SetStyle(lfobj.obj, "opacity", lfobj.curr);
			else
				for (i = 0; i < lfobj.obj.length; i++)
					LiveFader.SetStyle(lfobj.obj[i], "opacity", lfobj.curr);

			if (lfobj.mod.ondsp != false)
				if (lfobj.single)
					LiveFader.SetStyle(lfobj.obj, "dsp", lfobj.mod.ondsp);
				else
					for (i = 0; i < lfobj.obj.length; i++)
						LiveFader.SetStyle(lfobj.obj[i], "dsp", lfobj.mod.ondsp);
		},
		
		//----------------------------------------------------
		// LiveFader objektum azonnali kikapcsolása
		InstantOff : function(lfobj)
		{
			window.LiveFaderContainer.Remove(lfobj);

			lfobj.step = lfobj.mod.sub;
			lfobj.target = lfobj.mod.min;
			lfobj.curr = lfobj.target;

			if (lfobj.single)
				LiveFader.SetStyle(lfobj.obj, "opacity", lfobj.curr);
			else
				for (i = 0; i < lfobj.obj.length; i++)
					LiveFader.SetStyle(lfobj.obj[i], "opacity", lfobj.curr);

			if (lfobj.mod.ondsp != false)
				if (lfobj.single)
					LiveFader.SetStyle(lfobj.obj, "dsp", lfobj.mod.offdsp);
				else
					for (i = 0; i < lfobj.obj.length; i++)
						LiveFader.SetStyle(lfobj.obj[i], "dsp", lfobj.mod.offdsp);
		},
		
		//----------------------------------------------------
		// LiveFader objektum azonnali átkapcsolása
		// paraméterek: - lfobj : livefader objektum
		InstantSwitch : function(lfobj)
		{
			if (lfobj.curr == lfobj.mod.max)
				LiveFader.InstantOff(lfobj);
			else
				LiveFader.InstantOn(lfobj);
		}
	}
	
	
/* ********************************************************************
*	ContentManager
*		A honlap hierarchikus contentrendszerén belüli váltogatás
* */	
	//----------------------------------------------------------
	// ContentHandler
	// Összetett content rendszer kezelését valósítja meg:
	// egy content fa építhető fel benne, melynek mindíg egy
	// csomópontja látható. A csomópontok közti váltást
	// livefaderrel valósítja meg.
	ContentHandler = 
	{
		currentPath : Array("root"),
		revealBuffer : null,
		killBuffer : null,
		
		contentTree : 		
				{
					name : "root",
					obj : null,
					parent: null,
					children: Array()
				},

		//-----------------------------------------------------------
		// AddContentNode : content csomópont hozzáadása a fához.
		// A létrejövő elem automata becsatolja magát a szülőjébe.
		// paraméterek: - nodeName   : a csomópont neve
		//              - parentNode : a szülő csomópont
		//              - obj        : a hozzárendelt HTML objektum
		AddContentNode : function(nodeName, parentNode, obj)
		{
			newNode = 
				{
					name : nodeName,
					obj : LiveFader.Create(true, obj, "content"),
					parent: parentNode,
					children: Array()
				};
			
			parentNode.children.push(newNode);
		},

		//------------------------------------------------------------
		// AddContent : content node hozzáadása. 
		// paraméterek: - path : kívánt elérési út
		//              - obj  : a tartalmat tartalmazó HTML objektum
		AddContent : function(path, obj)
		{
			var nodes = ("root/" + path).split("/");
			
			var curr = ContentHandler.contentTree;
			var prev = null;
			for (var index = 1; curr != null; index++)
			{
				prev = curr;
				curr = null;
				for (var i = 0; i < prev.children.length; i++)
					if (prev.children[i].name == nodes[index])
					{	
						curr = prev.children[i];
						break;
					}
			}
			
			if (prev.name != nodes[nodes.length - 2])
				alert("Error: ContentHandler.AddContent - invalid node path: " + path);
			else
				ContentHandler.AddContentNode(nodes[nodes.length - 1], prev, obj);
		},
		
		
		//-------------------------------------------------------------
		// GetLiveFader : Az adott eleresi utu content node livefader 
		// objektumat adja vissza.
		// paraméterek: - path : a lekérdezett elérési út
		// visszatérés: ha van ilyen elem, akkor a live fader objektuma,
		//              egyébként null
		GetLiveFader : function(path)
		{	
			var nodeList = path.split('/');
			var curr = ContentHandler.contentTree;
			for (var i = 0; i < nodeList.length; i++)
			{
				var selected = false;
				for (var j = 0; j < curr.children.length; j++)
					if (curr.children[j].name == nodeList[i])
					{
						selected = curr.children[j];
						break;
					}
				curr = selected;
				if (curr == false)
					break;
			}
			
			if (curr == false)
				alert('Error: ContentHandler.GetLiveFader - trying to reach invalid path "' + path + '"');
			else
				return curr.obj;
		},
		
		
		//-------------------------------------------------------------
		// RevealBuffer : a revealBuffer elemeit jeleniti meg, 
		// a masodik elemtol mindet bekapcsolja, aztan az elsot elofadeli
		// parameterek : - onFinished : az elotunes vegen lefuttatja 
		//                              ezt a kodot.
		RevealBuffer : function ()
		{
			if (ContentHandler.revealBuffer == null 
				|| ContentHandler.revealBuffer.length == 0)
				return;
				
			for (var i = 1; i < ContentHandler.revealBuffer.length; i++)
				LiveFader.InstantOn(ContentHandler.revealBuffer[i]);
			LiveFader.On(ContentHandler.revealBuffer[0]); 
			ContentHandler.revealBuffer = null;
		},

		//-------------------------------------------------------------
		// KillBuffer : a killBuffer elso elemet elfadeli, aztan
		// az osszes tobbit kikapcsolja
		// parameterek : - onFinished : a vegeztevel ezt lefuttatja
		//               - instantPart : ha true, a masodiktol kezdve
		//                              azonnal bezarja az elemeket,
		//                              torli a killbuffert.
		KillBuffer : function (onFinished, instantPart)
		{
			if (ContentHandler.killBuffer == null 
				|| ContentHandler.killBuffer.length == 0)
				return;

			
			if (instantPart == true)
			{
				for (var i = 1; i < ContentHandler.killBuffer.length; i++)
					LiveFader.InstantOff(ContentHandler.killBuffer[i]);
				ContentHandler.killBuffer = null;
				eval(onFinished);
			}
			else 
				LiveFader.Off(ContentHandler.killBuffer[0], 
					'ContentHandler.KillBuffer("' + onFinished + '", true)');
			
		},

		
		//-------------------------------------------------------------
		// SwitchToContent : valtas a contentek kozt.
		// FONTOS : ha éppen zajlik valamilyen contentváltás, akkor
		// nem csinál semmit. (a kill és reveal bufferek nem üresek)
		// paraméterek: - path : kivant eleresi ut
		SwitchToContent : function (path)
		{
			if (ContentHandler.killBuffer != null && ContentHandler.killBuffer.length != 0 
				|| ContentHandler.revealBuffer != null && ContentHandler.revealBuffer.length != 0)
				return;
			
			var desired = ("root/" + path).split('/');
			var current = ContentHandler.currentPath;
			
			var i;
			for (i = 0; i < desired.length && i < current.length && current[i] == desired[i]; i++)
				;
			
			var j;
			if (i < desired.length)
			{
				ContentHandler.revealBuffer = Array();
				for (j = i; j < desired.length; j++)
					ContentHandler.revealBuffer.push(
						ContentHandler.GetLiveFader(desired.slice(1, j+1).join('/')));
			}

			if (i < current.length)
			{
				ContentHandler.killBuffer = Array();
				for (j = i; j < current.length; j++)
					ContentHandler.killBuffer.push(
						ContentHandler.GetLiveFader(current.slice(1, j+1).join('/')));
				ContentHandler.KillBuffer('ContentHandler.RevealBuffer();', false);
			}
			else
				ContentHandler.RevealBuffer();

			ContentHandler.currentPath = desired;
		},
		
		
		
		//-------------------------------------------------------------
		// RenderContentNode : Debug jellegu funkciok: content tree 
		// serializalasa, kill es reveal bufferek kilistazasa
		// paraméterek: - node   : a renderelés gyökér csomópontja
		//              - prefix : a node csomópont elérési útja
		RenderContentNode : function(node, prefix)
		{
			if (node.children.length == 0)
				return prefix + node.name + '<br/>';
				
			var retVal = "";
			var i;
			for (i = 0; i < node.children.length; i++)
				retVal += ContentHandler.RenderContentNode(node.children[i], prefix + node.name + '/');
			return retVal;
		},
		
		
		//------------------------------------------------------------
		// RenderContentTree : a gyökér kirenderelése
		RenderContentTree : function()
		{
			return ContentHandler.RenderContentNode(ContentHandler.contentTree, "");
		},
		
		
		//------------------------------------------------------------
		// RenderBuffers : visszaadja zoknak a HTML objektum id-knek a
		// listáját, amikre a kill és reveal bufferek hivatkoznak.
		RenderBuffers : function()
		{
			var i;
			var retVal = "killBuffer: ";
			if (ContentHandler.killBuffer != null)
				for (i = 0; i < ContentHandler.killBuffer.length; i++)
					retVal += ' ' + ContentHandler.killBuffer[i].obj.id;
			retVal += " revealBuffer: ";
			if (ContentHandler.revealBuffer != null)
				for (i = 0; i < ContentHandler.revealBuffer.length; i++)
					retVal += ' ' + ContentHandler.revealBuffer[i].obj.id;
			return retVal;
		}
		
	}





/* ********************************************************************
*	PreLoader 
*		Képek előzetes betöltését végző modul
* */
	//---------------------------------------------------------
	// PreLoader
	// Képek letöltését menedzselő objektum
	PreLoader =
	{
		loadThread : false,
		loadStorage : Array(),
		current : false,
		onFinished : false,
		progressCounter : 0,
		onProgress : null,
		
		//-----------------------------------------------------
		// AddImage : kép hozzáadása a letöltési listához.
		// Paraméterek : - imgPath     : a kép elérési útja
		//               - downloadPriority: letöltési prioritás
		//               - relatedTeam: a hozzá tartozó csapat
		//                    pl. gallery/3d/2009
		//               - HTMLArray : azoknak az elemeknek a 
		//                    tömbje, amiknek ez lesz a háttérképe
		//               - imgPathError : ha nem sikerül a letöltés,
		//                    ezt a képet fogják megkapni a
		//                    cél HTML elemek
		//               - onFinishedScript : sikeres letöltéskor 
		//                    lefuttatandó kód
		//               - onErrorScript: sikertelen letöltéskor
		//                    lefuttatandó kód
		AddImage : function (imgPath, downloadPriority, relatedTeam, HTMLArray, imgPathError, onFinishedScript, onErrorScript)
		{
			with (PreLoader)
			{
				loadStorage.push(
						{
							path : imgPath,
							priority: downloadPriority,
							team : relatedTeam.split("/"),
							target : HTMLArray,
							error : imgPathError,
							onFinished : onFinishedScript,
							onError : onErrorScript,
							image : null
						}
					);
				progressCounter++;
				if (loadThread == false)
					SetSpeed(50);
			}
		},
		
		//----------------------------------------------------
		// RemoveIndex : adott indexu kep eltavolitasa
		// a letoltesi listabol.
		// parameterek : - index : a kep indexe
		RemoveIndex : function (index)
		{
			with (PreLoader)
			{
				if (index >= 0 && index < loadStorage.length)
				{
					loadStorage.splice(index,1);
					if (loadStorage.length == 0)
					{
						SetSpeed(0);
						if (onFinished != false)
							eval(onFinished);
						onFinished = false;
					}
				}
			}
		},
		
		//----------------------------------------------------
		// RemoveImage : adott kép eltávolítása a letöltési
		// listából. 
		// paraméterek : - path : a kép elérési útja
		RemoveImage : function (path)
		{
			for (var i = 0; i < PreLoader.loadStorage.length; i++)
				if (PreLoader.loadStorage[i].path == path)
				{
					PreLoader.RemoveIndex(i);
					progressCounter--;
					i--;
				}
		},
		
		
		//----------------------------------------------------
		// RemoveTeam : adott csoport eltávolítása a letöltési
		// listából. 
		// paraméterek : - team : a csoport elérési útja
		RemoveTeam : function (teamPath)
		{
		
			for (var i = 0; i < PreLoader.loadStorage.length; i++)
			{
				with (PreLoader.loadStorage[i])
				{
					var teamPathArr = teamPath.split("/");
					var same = teamPathArr.length <= team.length;
					for (var j = 0; 
						same && j < teamPathArr.length && j < team.length;
						j++)
						
						if (team[j] != teamPathArr[j])
							same = false;
							
					if (same)
					{
						PreLoader.RemoveIndex(i);
						progressCounter--;
						i--;
					}
				}
			}
		},
		
		
		//----------------------------------------------------
		// Reset : törli a kilátásban lévő letöltéseket, és
		// nullázza az eddigi letöltések számát
		Reset : function ()
		{
			PreLoader.onFinished = "";
			PreLoader.loadStorage = Array();
			PreLoader.progressCounter = 0;
		},
		
		//----------------------------------------------------
		// GetProgress : a letöltés előrehaladását adja vissza
		// az eddig hozzáadott képek száma és a jelenlegi 
		// letöltési sor mérete alapján.
		GetProgress : function()
		{
			return 1 - PreLoader.loadStorage.length / PreLoader.progressCounter;
		},
		
		//----------------------------------------------------
		// ChangePriority : a letöltési listában szereplő
		// adott prioritású elemek prioritásának megváltoztatása
		// paraméterek: - oldPriority : a lecserélendő prioritás
		//              - newPriority : az új prioritás
		ChangePriority : function (oldPriority, newPriority)
		{
			for (var i = 0; i < PreLoader.loadStorage.length; i++)
				if (PreLoader.loadStorage[i].priority == oldPriority)
					PreLoader.loadStorage[i].priority = newPriority;
		},
		
		//---------------------------------------------------
		// SetImagePriority : adott elérési utú kép 
		// prioritásának megváltoztatása
		// paraméterek: - path : a kép elérési útja
		//              - priority : az új prioritás
		SetImagePriority : function (path, priority)
		{
			for (var i = 0; i < PreLoader.loadStorage.length; i++)
				if (PreLoader.loadStorage[i].path == path)
				{
					PreLoader.loadStorage[i].priority = priority;
					break;
				}
		},

		//--------------------------------------------------
		// SetTeamPriority : adott csoportba tartozó
		// képek prioritásának megváltoztatása
		// paraméterek: - teamPath : a csoport neve
		//              - priority : a letöltési prioritás
		SetTeamPriority : function (teamPath, priority)
		{
			for (var i = 0; i < PreLoader.loadStorage.length; i++)
			{
				with (PreLoader.loadStorage[i])
				{
					var teamPathArr = teamPath.split("/");
					var same = teamPathArr.length <= team.length;
					for (var j = 0; 
						same && j < teamPathArr.length && j < team.length;
						j++)
						
						if (team[j] != teamPathArr[j])
							same = false;
							
					if (same)
						PreLoader.loadStorage[i].priority = priority;
				}
			}
		},
		
		
		//-------------------------------------------------
		// Timer : időnként meghívott függvény, a képek
		// letöltését kezdi el, figyeli, végzi be
		Timer : function()
		{
			if (PreLoader.loadStorage.length == 0)
				return;
				
			var i;
			if (PreLoader.current !== false)
			{
				with (PreLoader.loadStorage[PreLoader.current])
				{
					var succeed = image.complete;
					var failed = false; // FONTOS : itt lesz hogy ha nem siekrult a betoltes

					if (!succeed && !failed)
						return;
						
					if (target != null)
					{
						for (i = 0; i < target.length; i++)
							target[i].style.backgroundImage = "url(" + (succeed ? path : error) + ")";
					}
					
					PreLoader.RemoveIndex(PreLoader.current,1);
					PreLoader.current = false;
					
					var script = succeed ? onFinished : onError;
					if (typeof(script) != "undefined")
						eval (script);
					if (typeof(PreLoader.onProgress) != "undefined")
						eval (PreLoader.onProgress);
				}
			}

			
			if (PreLoader.current === false && PreLoader.loadStorage.length > 0)
			{
				var bestPriority = PreLoader.loadStorage[0].priority;
				var bestIndex = 0;
				for (var i = 1; i < PreLoader.loadStorage.length; i++)
					if (PreLoader.loadStorage[i].priority < bestPriority)
					{
						bestIndex = i;
						bestPriority = PreLoader.loadStorage[i].priority;
					}
				
				with (PreLoader.loadStorage[bestIndex])
				{	
					image = new Image;
					image.src = path;
				}	
				PreLoader.current = bestIndex;
			}
		},
		
		
		//--------------------------------------------------
		// SetSpeed : beállítja, hogy mennyi időn ként 
		// hívja meg a Timer függvényt a böngésző.
		SetSpeed : function (speed)
		{
			with (PreLoader)
			{
				if (loadThread != false)
					clearInterval(loadThread);
				loadThread = setInterval("PreLoader.Timer()", speed);
			}
		}
	}