var selectedSchemaFields = '';
	
	/**
	 * Populates selectedSchemaFields variable with comma delimited string of selected match field ids.
	 */
	function setSelectedSchemaFields()
	{
		var match_fields = getObj('match_field[]',true);
	
		selectedSchemaFields = '';
		for(i=0; i< match_fields.length; i++)
		{
			if(match_fields[i].checked == true)
			{
				selectedSchemaFields += match_fields[i].value+',';
			}
		}
		selectedSchemaFields = selectedSchemaFields.substring(0, (selectedSchemaFields.length-1));
	}
	
	/**
	 * Retrieve ALL InventorySchemaField mappings for specific Inventory
	 *
	 * @param updateId
	 * @param inventoryId
	 *
	 */
	function loadInventoryFields(updateElmId, invSelectElmId)
	{
	
		//var invSelect = getObj(invSelectElmId);
		//var invId = invSelect.options[invSelect.selectedIndex].value;
		
		new Ajax.Updater(updateElmId, site_root+'/replacement_rules/edit_by_group_fields/'+invSelectElmId, {onLoading:function(request){loading('edit_standard_field_options_loading');}, onComplete:function(request){complete('edit_standard_field_options_loading');}, asynchronous:true, evalScripts:true, requestHeaders:['X-Update', updateElmId]});
		
		var btnLoadValues = document.getElementById('loadValuesButton');
			btnLoadValues.disabled = false;
	}

	function getInventorySchemaFieldValues( updateId, sender, index )
	{
		// ensure a valid object has bubbled this request
		if(!sender) { return false; }
		
        //if($('inventory_schema_field_id').selectedIndex == 0)
		if(sender.selectedIndex == null)
        {
			alert('WARNING!\r\n\r\nPlease select an inventory field to apply filter for!');
			
			return false;
        }
            
        inventory=true;
         
        if(sender.options[sender.selectedIndex].text.indexOf('.count')>0
           ||sender.options[sender.selectedIndex].text.indexOf('.average')>0
           ||sender.options[sender.selectedIndex].text.indexOf('.highest')>0
           ||sender.options[sender.selectedIndex].text.indexOf('.lowest')>0
        )
        {
            var matchField = document.getElementById('Filter'+index+'MatchValueS');
            
            if(matchField)
            {
                matchField.options.length	= 0;
                matchField.disabled			= true;
            }
            
            inventory =  false;
        }
		
		var postData = new Array();
		       
		// UrlSetFieldFilter specific check; aggregate values cant retrieve InventorySchemaField values
		
		// get reference to filter row
		var senderCell = sender.parentNode;
		
		// retrieve DOM input fields
		var senderInputs = senderCell.getElementsByTagName('input');
		// iterate over input fields appending to data array
		for(i=0; i<senderInputs.length; i++)
		{
			// check for optiongroup
			if(senderInputs[i].id == 'group')
			{
				senderInputs[i].value = sender.options[sender.selectedIndex].parentNode.label;
			}
			
			postData.push(senderInputs[i]);
		}
		
		// retrieve DOM select fields
		var senderSelects = senderCell.getElementsByTagName('select');
		// iterate over select fields appending to data array
		for(i=0; i<senderSelects.length; i++) { postData.push(senderSelects[i]); }
		
		//disableInput(null, null, {opacity:75,color:'white'});
		
		// retrieve InventorySchemaField values
		if(inventory)
		{
		//alert('calling:'+site_root+'/inventory_schema_fields/ajax_matchvalues/'+index);
		new Ajax.Updater(updateId, site_root+'/inventory_schema_fields/ajax_matchvalues/'+index, {onComplete:function(request){enableInput();}, asynchronous:true, evalScripts:true, parameters:Form.serializeElements(postData), requestHeaders:['X-Update', updateId]});
		}
	
		new Ajax.Updater(updateId+'Match', site_root+'/inventory_schema_fields/ajax_match_types/'+index, {onComplete:function(request){enableInput();}, asynchronous:true, evalScripts:true, parameters:Form.serializeElements(postData), requestHeaders:['X-Update', updateId]});
		
	}


	/**
	 * Enables edit mode on an individual ReplacementRule within ReplacementRules::edit_by_group
	 *
	 * @param updateId			DOM element id to update with ajax response
	 * @param inventoryId		Inventory.id to ReplacementRule belongs to
	 * @param ruleIndex			index of ReplacementRule row within parent DOM tbody
	 * @param ruleId			ReplacementRule.id to edit
	 * @param replacementIndex	index of ReplacementRules parent DOM tbody
	 * @param selectableFields	comma delimited string of InventorySchemaField.id(s) used in ReplacementMatchField criteria
	 *
	 */
	function editReplacement( updateId, inventoryId, ruleIndex, ruleId, replacementIndex ) //, selectableFields, selectableFieldValues
	{
		//selectableFieldValues = selectableFieldValues.replace(/\//, '{slash}');
        
        var replacementData = new Array();
        
        var replacementMatchFields = document.getElementsByName('data[ReplacementMatchField'+ruleIndex+'][]');
        var replacementMatchReplacements = document.getElementsByName('data[ReplacementMatchReplacement'+ruleIndex+'][]');
            
        for(i=0; i<replacementMatchFields.length; i++)
            replacementData.push(replacementMatchFields[i]);
        
        for(i=0; i<replacementMatchReplacements.length; i++)
            replacementData.push(replacementMatchReplacements[i]);
        
        // execute ReplacementRules::replacement_edit_by_group
		//new Ajax.Updater(updateId, site_root+'/replacement_rules/replacement_edit_by_group/'+inventoryId+'/'+ruleId+'/'+ruleIndex+'/'+replacementIndex+'/'+selectableFields+'/'+selectableFieldValues, {asynchronous:true, evalScripts:true, requestHeaders:['X-Update', updateId]});
        new Ajax.Updater(updateId, site_root+'/replacement_rules/replacement_edit_by_group/'+inventoryId+'/'+ruleId+'/'+ruleIndex+'/'+replacementIndex, {asynchronous:true, evalScripts:true, parameters:Form.serializeElements(replacementData), requestHeaders:['X-Update', updateId]});
	}
	
	/**
	 * Disables edit mode on an individual ReplacementRule within ReplacementRules::edit_by_group
	 *
	 * @param updateId			DOM element id to update with ajax response
	 * @param ruleIndex			index of ReplacementRule row within parent DOM tbody
	 * @param ruleId			ReplacementRule.id to edit
	 * @param replacementIndex	index of ReplacementRules parent DOM tbody
	 * @param selectableFields	comma delimited string of InventorySchemaField.id(s) used in ReplacementMatchField criteria
	 *
	 */
	function showReplacement( updateId, ruleIndex, ruleId, replacementIndex, selectableFields, selectableFieldValues )
	{
		// execute ReplacementRules::replacement_show_by_group(ReplacementRule.id, DOM tbody.index, DOM tr.index, InventorySchemaField.id(s))
		new Ajax.Updater(updateId, site_root+'/replacement_rules/replacement_show_by_group/'+ruleId+'/'+replacementIndex+'/'+ruleIndex+'/'+selectableFields+'/'+selectableFieldValues, {asynchronous:true, evalScripts:true, requestHeaders:['X-Update', updateId]});
	}
	
	/**
	 * Enables blank edit mode within ReplacementRules::edit_by_group
	 *
	 * @param updateId			DOM element id to update with ajax response
	 * @param inventoryId		Inventory.id to ReplacementRule belongs to
	 * @param replacementIndex	index of ReplacementRules parent DOM tbody
	 * @param selectableFields	comma delimited string of InventorySchemaField.id(s) used in ReplacementMatchField criteria
	 *
	 */
	function newReplacement( rowIndex, inventoryId, selectableFields, selectableFieldValues )
	{
		// retrieve DOM tbody
		var replacementRows	= document.getElementById('ReplacementRulesRow'+rowIndex);
		
		// insert new DOM tr within parent DOM tbody
		var replacementRow		= replacementRows.insertRow(replacementRows.rows.length);
			replacementRow.id	= 'ReplacementRulesRow'+rowIndex+'Rule'+(replacementRows.rows.length-1);
		
		// set appropriate style
		if(replacementRows.rows[0].className == 'row_default')
		{
			replacementRow.className = 'row_default';
		}
		else
		{
			replacementRow.className = 'row_alternate';
		}
	    
        var replacementData = new Array();
        
        var replacementMatchFields = document.getElementsByName('data[ReplacementMatchField'+rowIndex+'][]');
        var replacementMatchReplacements = document.getElementsByName('data[ReplacementMatchReplacement'+rowIndex+'][]');
            
        for(i=0; i<replacementMatchFields.length; i++)
            replacementData.push(replacementMatchFields[i]);
        
        for(i=0; i<replacementMatchReplacements.length; i++)
            replacementData.push(replacementMatchReplacements[i]);

		// execute ReplacementRules::replacement_edit_by_group(Inventory.id, ReplacementRule.id, DOM tr.index, DOM tbody.index, InventorySchemaField.id(s))
        new Ajax.Updater(replacementRow.id, site_root+'/replacement_rules/replacement_edit_by_group/'+inventoryId+'/0/'+(replacementRows.rows.length-2)+'/'+rowIndex, {asynchronous:true, evalScripts:false, parameters:Form.serializeElements(replacementData), requestHeaders:['X-Update', replacementRow.id]});
	}
	
	/**
	 * Removes blank edit mode within ReplacementRules::edit_by_group
	 *
	 * @param replacementId		DOM of ReplacementRules parent DOM tbody
	 *
	 */
	function hideReplacement( replacementRuleRow )
	{
		var replacementRows	= document.getElementById('domReplacementRules');
		
		replacementRows.deleteRow(replacementRuleRow.rowIndex);
	}
	
	/**
	 * Checks for any unsaved data before continuing to next page of results within ReplacementRules::edit_by_group
	 */
	function nextReplacementPage()
	{
		// retrieve DOM table of ReplacementRules
		var replacementTable	= document.getElementById('domReplacementRules');
		var replacementRows		= replacementTable.getElementsByTagName('textarea');
			
		// check if any open ReplacementRules; if a DOM textarea is found, assume unsaved data
		if(replacementRows.length > 0)
		{
			// ask use for confirmation to continue without saving
			if(!confirm('You have open ReplacementRules for editing. Do you wish to continue without saving ?'))
			{
				return false;
			}
			else
			{
				// if allowed to continue without saving; set hidden form field to ensure ReplacementRulesController doesnt attempt to save data
				var saveFlag = document.getElementById('allowsave');
					saveFlag.value = 0;
			}
		}
		
		// disable DOM interaction of ReplacementRules table
		disableInput('domReplacementRules',null,{opacity:75,color:'white'});
			
		// return true; continue to next page
		return true;
	}
	
	/**
	 * Deletes an individual ReplacementRule from DynamicCreative
	 *
	 * @param replacementRow	DOM tr to remove from table
	 * @param replacementId		ReplacementRule.id to delete from DynamicCreative
	 *
	 */
	function deleteReplacementByGroup( replacementRuleRow, ruleId )
	{
		// ensure we have a ReplacementRule
		if(!replacementRuleRow) { return false; }
		
		// disable DOM input
		disableInput('domReplacementRules', null, {opacity:75,color:'white'});
		
		// remove ReplacementRule from table
		var replacementRows = document.getElementById('domReplacementRules');
			replacementRows.deleteRow(replacementRuleRow.rowIndex);
		
		// execute ReplacementRules::delete(ReplacementRule.id)
		new Ajax.Updater('', site_root+'/replacement_rules/delete/'+ruleId, {onComplete:function(request){enableInput()}, asynchronous:true, evalScripts:true});
	}
	
	function deleteReplacement( replacementId )
	{
		if(!replacementId) { return false; }
		
		if(confirm('Are you sure you wish to delete this ReplacementRule No. '+replacementId))
		{
			disableInput('ajaxReplacementRules', null, {opacity:50,color:'white'});
		
			new Ajax.Updater('', site_root+'/replacement_rules/delete/'+replacementId, {onComplete:function(request){viewReplacementsByInventory('ajaxReplacementRules')}, asynchronous:true, evalScripts:true});
		
		}
				
	}
	
	/**
	 * Filters results within ReplacementRules::edit_by_group based on selected InventorySchemaField value
	 *
	 * @param filterColumn	filterColumn
	 * @param url			URL
	 *
	 */
	function filterResults( url )
	{
        if(nextReplacementPage())
		{
			new Ajax.Updater('ajaxInventorySchemaFieldReplacements',site_root+url, {onComplete:function(event){enableInput()}, asynchronous:true, evalScripts:true, parameters:Form.serialize('ajaxFormReplacements'), requestHeaders:['X-Update', 'ajaxInventorySchemaFieldReplacements']});
		}
		else
		{
			return false;
		}
	}

	/**
	 * Saves selected replacements within ReplacementRules::edit_by_group
	 *
	 * @param replacementRow	DOM tr of replacement data to save
	 * @param selectableFields	comma delimited list of InventorySchemaField.id(s) used in ReplacementMatchField criteria
	 *
	 */
	function saveReplacements(replacementRuleRow, selectableFields)//, selectableFieldValues
	{
		var regEx = new RegExp(/replacement_value/);
        
        var invalidFields = new Array();
        var alertMessage = "";
        
        if(!replacementRuleRow){ return false; }
		
		// disable DOM input
		disableInput('domReplacementRules', null, {opacity:75,color:'black'});
		
		// instantiate replacementData collection that will be serialized in AJAX request
		var replacementData	= new Array();
		
		// retrieve ALL hidden & standard text input elements
		var replacementFieldsInput = replacementRuleRow.getElementsByTagName('input');
			// append INPUT.hidden || INPUT.text to collection
			for(i=0;i<replacementFieldsInput.length;i++)
            {
                if(regEx.test(replacementFieldsInput[i].name))
                {
                    if(replacementFieldsInput[i].value == "")
                    {
                        invalidFields.push("- "+replacementFieldsInput[i].id+", requires a Replacement Value");
                    }
                }
                
                replacementData.push(replacementFieldsInput[i]);
            }

        if(invalidFields.length > 0)
        {
            alertMessage = "WARNING!\r\n\r\nAttempting to save ReplacementRule without a specified Replacement Value is not allowed!\r\n";

            for(i=0;i<invalidFields.length;i++)
            {
                alertMessage += "\r\n"+invalidFields[i];
            }           
            
            alert(alertMessage);
            
            enableInput();
            
            return false;
        }

		// retrieve ALL textarea input elements
		var replacementFieldsTextArea	= replacementRuleRow.getElementsByTagName('textarea');
			// append INPUT.textarea to collection
			for(i=0;i<replacementFieldsTextArea.length;i++) { replacementData.push(replacementFieldsTextArea[i]); }
		
		// execute ReplacementRules::save_by_group()
		//new Ajax.Request(site_root+'/replacement_rules/save_by_group/1', {onComplete:function(request){updateView(request.responseText, replacementRuleRow, selectableFields, selectableFieldValues)}, asynchronous:true, evalScripts:true, parameters:Form.serializeElements(replacementData)});
        new Ajax.Request(site_root+'/replacement_rules/save_by_group/1', {onComplete:function(request){updateView(request.responseText, replacementRuleRow, selectableFields)}, asynchronous:true, evalScripts:true, parameters:Form.serializeElements(replacementData)});
	}
	
	/**
	 * Updates replacements view within ReplacementRules::edit_by_group after a replacement has been saved
	 *
	 * @param ajaxResponse		response text from previous ReplacementRules::save_by_group ajax request
	 * @param replacementRow	_something
	 * @param selectableFields	_somethingelse
	 *
	 */
	function updateView(ajaxResponse, replacementRow, selectableFields)//, selectableFieldValues
	{
		var ROW_INDEX	= 1;
		var RULE_ID		= 0;
		var RULE_INDEX	= 2;
			
		// remove CakePHP debug HTML comment
		var response = cleanResponse(ajaxResponse);
		
		// split ReplacementRules
		var replacementRules = response.split('|');
						
		var replacementRule = replacementRules[0].split(',');

		// updated ReplacementRule
		//new Ajax.Updater(replacementRow.id, site_root+'/replacement_rules/replacement_show_by_group/'+replacementRule[RULE_ID]+'/'+replacementRule[RULE_INDEX]+'/'+replacementRule[ROW_INDEX]+'/'+selectableFields+'/'+selectableFieldValues, {asynchronous:true, evalScripts:true, requestHeaders:['X-Update', replacementRow.id]});
        new Ajax.Updater(replacementRow.id, site_root+'/replacement_rules/replacement_show_by_group/'+replacementRule[RULE_ID]+'/'+replacementRule[RULE_INDEX]+'/'+replacementRule[ROW_INDEX]+'/'+selectableFields, {asynchronous:true, evalScripts:true, requestHeaders:['X-Update', replacementRow.id]});
		
		// re-enable DOM input
		enableInput();
						
	}
	
	function overrideReplacement( rowIndex, ruleIndex, replacementIndex )
	{
		var replacementOverrideWarning = document.getElementById('ReplacementOverrideWarning' + rowIndex + ruleIndex + replacementIndex);
			replacementOverrideWarning.style.display = 'none';
		
		var replacementOverridePanel = document.getElementById('ReplacementOverridePanel' + rowIndex + ruleIndex + replacementIndex);
			replacementOverridePanel.style.display = 'block';
			
		var replacementOverrideFlag = document.getElementById('ReplacementRule' + rowIndex + ruleIndex + 'ReplacementRuleOverride' + replacementIndex);
			replacementOverrideFlag.disabled = false;
	}
	
	function viewReplacementsByInventory( updateId )
	{
		if(!updateId) { return false; }
	
		//disableInput(updateId, '', {opacity:75,color:'white'});
		
		new Ajax.Updater(updateId, site_root+'/replacement_rules/view/', {onComplete:function(request){enableInput()}, asynchronous:true, evalScripts:true, requestHeaders:['X-Update', updateId]});
	}
	
	function cleanResponse(html)
	{
		return html.replace(/<!(?:--[\s\S]*?--\s*)?>\s*/g,'');
	}

	function addReplacementByField( inventoryId, replacementRowData )
	{
		var invalid = 0;
		
		var replacementData = new Array();
		
		// retrieve ALL hidden & standard text input elements
		var replacementFieldsInput = replacementRowData.getElementsByTagName('input');
			// append INPUT.hidden || INPUT.text to collection
			for(i=0;i<replacementFieldsInput.length;i++)
			{
				if(replacementFieldsInput[i].name == 'data[_unbound][ReplacementMatchReplacement][replacement_value]')
				{
					if(replacementFieldsInput[i].value == '') { invalid++; }
				}
				
				replacementData.push(replacementFieldsInput[i]);
			}
		// retrieve ALL hidden & standard text input elements
		var replacementFieldsSelect = replacementRowData.getElementsByTagName('select');
			// append INPUT.hidden || INPUT.text to collection
			for(i=0;i<replacementFieldsSelect.length;i++)
			{
				if(replacementFieldsSelect[i].name == 'data[_unbound][ReplacementMatchReplacement][inventory_schema_field_id]')
				{
					if(replacementFieldsSelect[i].options[replacementFieldsSelect[i].selectedIndex].value == '') { invalid++; }
				}

				replacementData.push(replacementFieldsSelect[i]);
			}
		
		if(invalid >= 1) { alert("WARNING!\r\n\r\nAttempting to add ReplacementRule replacement data without a replacment value or field is not allowed!"); return false; }
		
		var replacementRows = document.getElementById('replacements');
		var replacementRow	= replacementRows.insertRow(replacementRows.rows.length);
			replacementRow.id = 'Replacement'+replacementRows.rows.length;
		
		new Ajax.Updater(replacementRow.id, site_root+'/replacement_rules/replacement_edit_by_field/'+inventoryId+'/'+(replacementRows.rows.length-1), {onComplete:function(request){resetForm(replacementRowData);updateActiveReplacementField((replacementRows.rows.length-1))}, asynchronous:true, evalScripts:true, parameters:Form.serializeElements(replacementData), requestHeaders:['X-Update', replacementRow.id]});
		
	}
	
	function addCriteriaByField( inventoryId, replacementRowData )
	{
		// invalid counter
		var invalid = 0;
		
		// instantiate new replacement data array
		var replacementData = new Array();
		
		// retrieve ALL hidden & standard text input elements
		var replacementFieldsInput = replacementRowData.getElementsByTagName('input');
			// append INPUT.hidden || INPUT.text to collection
			for(i=0;i<replacementFieldsInput.length;i++)
			{
				if(replacementFieldsInput[i].name == 'data[_unbound][custom_value]')
				{
					if(replacementFieldsInput[i].value == '') { invalid++; }
				}
				
				replacementData.push(replacementFieldsInput[i]);
			}
		// retrieve ALL hidden & standard text input elements
		var replacementFieldsSelect = replacementRowData.getElementsByTagName('select');
			// append INPUT.hidden || INPUT.text to collection
			for(i=0;i<replacementFieldsSelect.length;i++)
			{
				if(replacementFieldsSelect[i].name == 'data[_unbound][match_value]')
				{
					if(replacementFieldsSelect[i].disabled == true)
                    {
                        invalid++;
                    }
                    else if(replacementFieldsSelect[i].options[replacementFieldsSelect[i].selectedIndex].value == '') { invalid++; }
				}
				else if(replacementFieldsSelect[i].name == 'data[_unbound][inventory_schema_field_id]')
				{
					if(replacementFieldsSelect[i].options[replacementFieldsSelect[i].selectedIndex].value == '') { invalid++; }
				}
				
				replacementData.push(replacementFieldsSelect[i]);				
			}
			
		if(invalid >= 2) { alert("WARNING!\r\n\r\nAttempting to add ReplacementRule match criteria without a match value or field is not allowed!"); return false; }
		
		var replacementRows = document.getElementById('criteria');
		var replacementRow	= replacementRows.insertRow(replacementRows.rows.length);
			replacementRow.id = 'Criteria'+replacementRows.rows.length;
		
		new Ajax.Updater(replacementRow.id, site_root+'/replacement_rules/criteria_edit_by_field/'+inventoryId+'/'+(replacementRows.rows.length-1), {onComplete:function(request){resetForm(replacementRowData)}, asynchronous:true, evalScripts:true, parameters:Form.serializeElements(replacementData), requestHeaders:['X-Update', replacementRow.id]});
		
	}
	
	function checkDuplicateReplacementField( replacementField, replacementIndex )
	{
		// retrieve active replacements collection
		var replacementRows = document.getElementById('replacements');
		// instantiate replacement selection		
		var replacementRowFieldSelect	= null;
		
		for(i=0; i<replacementRows.rows.length; i++)
		{
			// retrieve active replacement InventorySchemaField select & replacement value
			replacementRowFieldSelect	= document.getElementById('ReplacementMatchReplacement'+ i +'InventorySchemaFieldId');
			replacementRowFieldValue	= document.getElementById('ReplacementMatchReplacement'+ i +'ReplacementValue');
			
			// make sure we arent checking the triggering select
			if(replacementRowFieldSelect != replacementField)
			{
				// if trigger select value is already set alert user
				if(replacementRowFieldSelect.options[replacementRowFieldSelect.selectedIndex].value == replacementField.options[replacementField.selectedIndex].value)
				{
					var warningMessage = "WARNING!\n\nThe InventorySchemaField of '" + replacementField.options[replacementField.selectedIndex].innerText + "'";
						warningMessage += " is already being replaced with '" + replacementRowFieldValue.value + "' by replacement No." + (i+1) + ".";
						warningMessage += "\n\nOnly one replacement allowed per-field, per-rule.";
						
					// alert user
					alert(warningMessage);
					
					// reset selection
					if(typeof(replacementIndex) != 'undefined')
					{
						replacementField.selectedIndex = replacementMatchReplacements[replacementIndex];
					}
					else
					{
						replacementField.selectedIndex = 0;
					}
				}
			}
		}
	}
	
	function updateActiveReplacementField( replacementIndex )
	{
		// retrieve active replacement field
		var replacementField = document.getElementById('ReplacementMatchReplacement'+ replacementIndex +'InventorySchemaFieldId');
		
		// update data
		replacementMatchReplacements[replacementIndex] = replacementField.selectedIndex;
		
		// re-enable user input	
		enableInput();	

	}
	
	function updateReplacementMatchField( sender, matchIndex )
	{
		var matchInventorySchemaFieldId = document.getElementById('ReplacementMatchField'+matchIndex+'InventorySchemaFieldId');
			matchInventorySchemaFieldId.value = sender.options[sender.selectedIndex].value;

	}
	
	function resetReplacementFilters( sender, url )
	{
		var senderFilters = sender.getElementsByTagName('select');
		// append INPUT.hidden || INPUT.text to collection
			for(i=0;i<senderFilters.length;i++) { senderFilters[i].selectedIndex = 0; }
			
		filterResults(url);
	}
	
	function removeRow( domRow, domParent )
	{
        var domRows	= document.getElementById(domParent);
        
		domRows.deleteRow(domRow.rowIndex);
	}