function ExtLoad(){
	function submitExtendedSearch(){
		formfields['action'].setValue('extendedSearch');
		formfields['redirect'].setValue(Ext.agent.Locale['form.extendedRedirect']);
		form.submit(true);
	}

	function isSameCities(){
		if (formfields.departure0.getValue() && formfields.departure0.getValue() == formfields.arrival0.getValue()){
			Ext.get(fs + '.error').show();
			return Ext.get(fs + '.error').update('<DIV>' + Ext.agent.Error['same-cities'] + '</DIV>');
		}
		Ext.get(fs + '.error').setDisplayed(false);
		Ext.get(fs + '.error').update();
	}

	function showHints(html, formfields, showDatesHint){
		var hints = {};

		if (formfields.isReturnTicket.getValue()){
			dh.append(html.direction, {cls: 'clear'});
			hints.direction = dh.insertAfter(html.direction, {
				cls: 'hint-field',
				cn: {
					cn: [
						{
							tag: 'img',
							cls: 'arrow',
							src: Ext.agent.IMG['hint'].src,
							style: 'left: 534px;'
						},
						{
							tag: 'span',
							html: Ext.agent.Locale['hint.direction']
						}
					]
				}
			}, true);
		}

		if (showDatesHint){
			dh.append(html.datetime, {cls: 'clear'});
			hints.datetime = dh.insertAfter(html.datetime, {
				cls: 'hint-field',
				cn: {
					cn: [
						{
							tag: 'img',
							cls: 'arrow',
							src: Ext.agent.IMG['hint'].src,
							style: 'left: 45px;'
						},
						{
							tag: 'img',
							cls: 'arrow',
							src: Ext.agent.IMG['hint'].src,
							style: 'left: 313px;' + (showDatesHint == 1 ? 'display: none;' : '')
						},
						{
							tag: 'span',
							html: showDatesHint == 2 ? Ext.agent.Locale['hint.datetime'] : Ext.agent.Locale['hint.date']
						}
					]
				}
			}, true);
		}

		if (defaultValues['totalPassengers'] > 1){
			dh.append(html.passengers, {cls: 'clear'});
			hints.passengers = dh.insertAfter(html.passengers, {
				cls: 'hint-field',
				cn: {
					cn: [
						{
							tag: 'img',
							cls: 'arrow',
							src: Ext.agent.IMG['hint'].src,
							style: 'left: 173px;'
						},
						{
							tag: 'span',
							html: Ext.agent.Locale['hint.passengers']
						}
					]
				}
			}, true);
		}

		if (((defaultValues['ticketType'] == '1')||(defaultValues['ticketType'] == '2'))&&(!formfields.ticketType.disabled)){
			dh.append(html.ticketType, {cls: 'clear'});
			hints.ticketType = dh.insertAfter(html.ticketType, {
				cls: 'hint-field',
				cn: {
					cn: [
						{
							tag: 'img',
							cls: 'arrow',
							src: Ext.agent.IMG['hint'].src,
							style: 'left: 45px;'
						},
						{
							tag: 'span',
							html: Ext.agent.Locale['hint.tickettype']
						}
					]
				}
			}, true);
		}
		
		for (var i in hints){
			hints[i].slideIn();
		}

		return hints;
	}

	function createCityCombo(index, direction, fields, src) {
		var fieldId = fs + 'field.segment[' + index + '].' + direction + 'PointID';
		var fieldName = fs + '.segment[' + index + '].' + direction + 'PointID';

		var html = dh.append(src, {
			tag: 'div',
			cls: 'unit' + (direction == 'arrival' ? ' indent' : ''),
			cn: {
				tag: 'label',
				html: Ext.agent.Locale['form.' + direction],
				htmlFor: fieldId
			}
		});

		var source = dh.append(html, {
			tag: 'div',
			cls: 'x-form-element x-combobox'
		});

		var store = new Ext.data.Store({
			proxy: new Ext.data.DWRProxy(ajaxReference.getCitiesByLetters),
			reader: new Ext.data.MapReader(),
			listeners: {
				load: function(){
					this.sort(combo.displayField, 'ASC');
				}
			}
		});

		var combo = new Ext.form.ComboBox({
			unit: html,
			id: fieldId,
			allowBlank: !enablePreferences,
			dwr: true,
			disableKeyFilter: false,
//		dependent: direction == 'departure' ? fieldId.replace('departure','arrival') : fieldId.replace('arrival','departure'),
			autoLoad: false,
			store: store,
			validationDelay: 0,
			queryDelay: 0,
			displayField: 'value',
			hiddenName: fieldName,
			name: fieldName,
			typeAhead: false,
			emptyText: '',
			forceSelection: true,
			selectOnFocus: true,
			renderTo: source,
			hideTrigger: true,
			notfoundText: Ext.agent.Error['field.cityNotFound'],
			loadingText: Ext.agent.Locale['search'],
			valueField: 'key',
			minChars: 1,
			tpl: new Ext.XTemplate('<tpl for="."><div class="x-combo-list-item">{value}</div></tpl>'),
			itemSelector: 'div.x-combo-list-item',
			vtype: 'city',
			width: 250,
			listeners: {
				change: function(){
					if (displayHints && hints.direction){
						hints.direction.slideOut('t', {useDisplay: true});
					}
				}
			}
		});

/*
		if (enablePreferences){
			combo.on('select', isSameCities);
		}
*/

		store.proxy.listeners = {
			errorHandler: globalError
		}

		if (defaultValues['segment' + index + '.' + direction + 'ID']){
			var comboStore = {};
			comboStore[defaultValues['segment' + index + '.' + direction + 'ID']] = defaultValues['segment' + index + '.' + direction];
			combo.store.loadData(comboStore);
			combo.setValue(defaultValues['segment' + index + '.' + direction + 'ID']);
		}
		
		if (defaultValues['segment' + index + '.' + direction + 'Name'] && defaultValues['segment' + index + '.' + direction + 'ID']==''){
			//combo.initList();
			//combo.initQuery();
			combo.setRawValue(defaultValues['segment' + index + '.' + direction + 'Name']);
			combo.markInvalid(Ext.agent.Error['field.cityNotFound']);
			//combo.doQuery(defaultValues['segment' + index + '.' + direction + 'Name']);
		}
		
		formfields[direction + index] = combo;
	}

	function createDate(index, formfields, src, dates){

		var fieldId = fs + '.date' + index;
		var html = {};

		html.clear = dh.append(src, {
			tag: 'div',
			cls: 'unit' + (index == 1 ? ' indent' : '')
		}, true);

		html.date = dh.append(html.clear, {
			tag: 'div',
			cls: 'unit',
			cn: {
				tag: 'label',
				htmlFor: fieldId,
				html: Ext.agent.Locale['form.date' + index]
			}
		});

		html.wrap = dh.append(html.date, {
			tag: 'div',
			cls: 'clear'
		});

		html.dateField = dh.append(html.wrap, {
			tag: 'div',
			cls: 'unit'
		});

		html.calendarField = dh.append(html.wrap, {
			tag: 'div',
			cls: 'unit indent'
		}, true);

		html.calendarIcon = dh.append(html.calendarField, {
			tag: 'img',
			cls: 'calendarLink',
			src: Ext.agent.Calendar.ICONS['default'].src
		}, true);

		var date = new Ext.form.DateField({
			msgTarget: enablePreferences ? 'blue2' : 'title',
			id: fieldId,
			width: 101,
			renderTo: html.dateField,
			value: dates['value'],
			field: html.calendarField,
			format: dates['format'],
			name: fs + '.segment[' + index + '].date',
			emptyText: dates['value'].format(dates['format']),
			preventMark: true,
			preventMarkOnSetValue: true,
			hideTrigger: true,
			vtype: 'date',
			disableKeyFilter: false,
			listeners: {
				disable: function(){
					calendar.disable();
				},
				enable: function(){
					calendar.enable();
				}
			}
		});

		Ext.apply(date, {
			minTime: dates['minTime'].clone(),
			minTimeInterval: dates['minInterval'].clone(),
			minValue: dates['minInterval'].clone().clearTime(),
			maxValue: dates['maxInterval'].clone()
		});

		Ext.apply(date, {
			invalidText: Ext.agent.Locale['date.invalid'],
			minText: (index == 0) ? String.format(Ext.agent.Locale['date.invalidMin'], date['minTime'].format('j F Y, G:i')) : String.format(Ext.agent.Locale['date.min'], dates['minTime'].format('j F Y, G:i')),
			maxText: String.format(Ext.agent.Locale['date.max'], dates['maxInterval'].format('j F Y'))
		});

		var calendar = new Ext.agent.Calendar({
			minValue: dates['minInterval'].clone().clearTime(),
			maxValue: dates['maxInterval'].clone().clearTime(),
			initial: dates['minInterval'].clone().clearTime(),
			clickclose: true,
			today: dates['today'],
			animate: false,
			field: date,
			obj: html.calendarField,
			icon: html.calendarIcon,
			listeners: {
				choose: function(){
					calendar.hide();
				}
			}
		});

		date.calendar = calendar;

		html.time = dh.append(html.clear, {
			tag: 'div',
			cls: 'unit indent',
			cn: {
				tag: 'label',
				html: Ext.agent.Locale['form.time']
			}
		});

		html.timeField = dh.append(html.time, {
			tag: 'div',
			cls: 'x-form-element x-combobox'
		});

		var dateInterval = new Ext.form.ComboBox({
			value: defaultValues['segment' + index + '.intervalID'] ? defaultValues['segment' + index + '.intervalID'] : '1',
			store: new Ext.data.SimpleStore({
				fields: ['value', 'text'],
				data: intervalsRecords
			}),
			renderTo: html.timeField,
			displayField: 'text',
			valueField: 'value',
			hiddenName: fs + '.segment[' + index + '].intervalID',
			triggerAction: 'all',
			editable: false,
			mode: 'local',
			width: 100
		});

		dateInterval.on('expand', function(){
			var tmp = date.getValue().clone();
			if (!tmp) return;
			dateInterval.store.filterBy(function(record){
				tmp = date.getValue().clone();
				switch (record.data['value'].toString()){
					case '1': return true;
					case '2': tmp = tmp.clone().add(Date.HOUR, 0); break;
					case '3': tmp = tmp.clone().add(Date.HOUR, 6); break;
					case '4': tmp = tmp.clone().add(Date.HOUR, 12); break;
					case '5': tmp = tmp.clone().add(Date.HOUR, 18); break;
				}

				if (tmp.getTime() < date.minTimeInterval.getTime()) return false;


				if (tmp.add(Date.HOUR, -6).getTime() >= date.maxValue.getTime()) return false;
				return true;
			});         	
		});

		formfields['date' + index] = date;
		formfields['dateInterval' + index] = dateInterval;

		date.errorContainer = html.clear;
	}

/*
	function createAge(index, formfields, src){
		var html = dh.append(src, {
			tag: 'div',
			cls: 'x-form-element x-combobox'
		});

		var age = new Ext.form.ComboBox({
			value: defaultValues['children'][index] ? defaultValues['children'][index] : 0,
			triggerAction: 'all',
			renderTo: html,
			name: fs + '.children[' + index + ']',
			mode: 'local',
			displayField: 'value',
			valueField: 'value',
			store: new Ext.data.SimpleStore({
				fields: ['value'],
				data: ageRecords
			}),
			editable: false,
			hideTrigger: false,
			width: 46
		});

		formfields['child' + index] = age;
	}
*/

	function createPreferences(formfields, src){
		dh.append(src, {tag: 'h3', html: Ext.agent.Locale['form.preferences'], style: 'margin: 0; padding: 9px 0 11px;'});

		html.classWrap = dh.append(src, {
			tag: 'div',
			cls: 'wrapper'
		});

		html.classUnit = dh.append(html.classWrap, {
			tag: 'div',
			cls: 'unit', cn: {
				tag: 'label',
				html: Ext.agent.Locale['form.bookingClass']
			}
		});

		html.classField = dh.append(html.classUnit, {tag: 'div', cls: 'x-form-element x-combobox'});

		Ext.apply(formfields, {
			bookingClass: new Ext.form.ComboBox({
				store: new Ext.data.SimpleStore({
					fields: ['value', 'text'],
					data: bookingClassesRecords
				}),
				value: defaultValues['bookingClassCode'] ? defaultValues['bookingClassCode'] : bookingClassesRecords[0][0],
				displayField: 'text',
				editable: false,
				valueField: 'value',
				width: 250,
				mode: 'local',
				hiddenName: fs + '.bookingClassCode',
				triggerAction: 'all',
				renderTo: html.classField
			})
		});

		html.aircompany = dh.append(src, {
			tag: 'div',
			cls: 'wrapper'
		});

		html.aircompanyUnit = dh.append(html.aircompany, {
			tag: 'div',
			cls: 'unit',
			cn: {
				tag: 'label',
				html: Ext.agent.Locale['form.aircompany']
			}
		});

		html.aircompanyField = dh.append(html.aircompanyUnit, {
			tag: 'div',
				cls: 'x-form-element x-combobox'
		});

		Ext.apply(formfields, {
			aircompany: new Ext.form.ComboBox({
				store: new Ext.data.SimpleStore({
					fields: ['value', 'text'],
					data: aircompaniesRecords
				}),
				value: defaultValues['aircompanyId'] ? defaultValues['aircompanyId'] : aircompaniesRecords[0][0],
				displayField: 'text',
				editable: false,
				valueField: 'value',
				width: 250,
				mode: 'local',
				hiddenName: fs + '.aircompanyId',
				triggerAction: 'all',
				renderTo: html.aircompanyField
			})
		});

		html.ticketType = dh.append(src, {
			tag: 'div',
			cls: 'wrapper'
		}, true);

		html.ticketTypeUnit = dh.append(html.ticketType, {
			tag: 'div',
			cls: 'unit',
			cn: {
				tag: 'label',
				html: Ext.agent.Locale['form.ticketType']
			}
		});

		html.ticketTypeField = dh.append(html.ticketTypeUnit, {
			tag: 'div',
				cls: 'x-form-element x-combobox'
		});

		Ext.apply(formfields, {
			ticketType: new Ext.form.ComboBox({
				store: new Ext.data.SimpleStore({
					fields: ['value', 'text'],
					data: ticketTypeRecords
				}),
				value: defaultValues['ticketType'] ? defaultValues['ticketType'] : ticketTypeRecords[0][0],
				displayField: 'text',
				editable: false,
				valueField: 'value',
				width: 250,
				mode: 'local',
				hiddenName: fs + '.ticketType',
				triggerAction: 'all',
				renderTo: html.ticketTypeField,
				listeners: {
					select: hideTicketTypeHint
				}
			})
		});
		
		html.ticketType.setDisplayed(!isLegal);
/*
		dh.append(src, {
			tag: 'div',
			cls: 'wrapper',
			cn: {
				tag: 'div',
				cls: 'unit',
				cn: [
					{tag: 'input', type: 'checkbox', id: fs + '.showHandyTariffs', name: fs + '.showHandyTariffs', value: 'true'},
					{tag: 'label', html: Ext.agent.Locale['form.showHandyTariffs'], htmlFor: fs + '.showHandyTariffs'}
				]
			}
		});

		Ext.apply(formfields, {
			showHandyTariffs: new Ext.form.Checkbox({
				applyTo: fs + '.showHandyTariffs'
			})
		});

		formfields['showHandyTariffs'].setValue(defaultValues['showHandyTariffs']);
*/

/*
		dh.append(src, {
			tag: 'div',
			cls: 'wrapper',
			cn: {
				tag: 'div',
				cls: 'unit',
				cn: [
					{tag: 'input', type: 'checkbox', id: fs + '.nonEtOnly', name: fs + '.nonEtOnly', value: 'true'},
					{tag: 'label', html: Ext.agent.Locale['form.nonEtOnly'], htmlFor: fs + '.nonEtOnly'}
				]
			}
		});

		Ext.apply(formfields, {
			nonEtOnly: new Ext.form.Checkbox({
				applyTo: fs + '.nonEtOnly'
			})
		});

		formfields['nonEtOnly'].setValue(defaultValues['nonEtOnly']);
*//*
		dh.append(src, {
			tag: 'h3',
			html: Ext.agent.Locale['form.receiptCity'],
			style: 'margin: 0; padding: 9px 0 11px;'
		});

		html.receiptCity = dh.append(html.form, {
			tag: 'div',
			cls: 'wrapper'
		});
		html.receiptCityUnit = dh.append(html.receiptCity, {
			tag: 'div',
			cls: 'unit'
		});
		html.receiptCityField = dh.append(html.receiptCityUnit, {
			tag: 'div',
			cls: 'x-form-element x-combobox'
		});

		html.receiptCityClear = dh.append(html.form, {cls: 'clear'});

		html.receiptCityHint = dh.insertAfter(html.receiptCityClear, {
			cls: 'hint-field',
			cn: {
				cn: [
*//*
					{
						tag: 'img',
						cls: 'arrow',
						src: Ext.agent.IMG['hint'].src,
						style: 'left: 173px;'
					},
*//*
					{
						tag: 'span',
						html: Ext.agent.Locale['hint.otherCity']
					}
				]
			}
		}, true);

		Ext.apply(formfields, {
			receiptCity: new Ext.form.ComboBox({
				store: new Ext.data.SimpleStore({
					fields: ['value', 'text'],
					data: receiptCitiesRecords
				}),
				value: defaultValues['recieptCityId'] ? defaultValues['recieptCityId'] : receiptCitiesRecords[0][0],
				displayField: 'text',
				editable: false,
				valueField: 'value',
				width: 250,
				mode: 'local',
				hiddenName: fs + '.recieptCityId',
				triggerAction: 'all',
				renderTo: html.receiptCityField,
				listeners: {
					select: function(){
						if (formfields['ticketType']){
							if (this.getValue() == '-1'){
								formfields.ticketType.setValue(2);
								formfields.ticketType.disable();
								hideTicketTypeHint();
							} else if (formfields.ticketType.disabled) {
								formfields.ticketType.enable();
								formfields.ticketType.setValue(0);
							}
						}
					}
				}
			})
		});

		formfields.receiptCity.fireEvent('select');
*/
	}

	function hideTicketTypeHint(){
		if (displayHints && hints && hints.ticketType && hints.ticketType.isDisplayed() && !hints.ticketType.hasActiveFx()){
			if ((formfields.ticketType.getValue() == '0')||(formfields.ticketType.disabled)){
				hints.ticketType.slideOut('t', {useDisplay: true});
			}
		}
	}
	
	function copyLocations(formfields){
		formfields['departure1'].setRawValue(formfields['arrival0'].hiddenField.value);
		formfields['arrival1'].setRawValue(formfields['departure0'].hiddenField.value);
	}

	function validateDates(form){
		var preventMark = this.preventMark ? [true, true] : [false, false];
		var preventChange = [false, false];

		if (!formfields) form.stopMonitoring();
		var valid0 = true;
		var valid1 = true;
		var format = formfields['date0'].format;
		var date0 = Date.parseDate(formfields['date0'].getRawValue().toString(), format) ? Date.parseDate(formfields['date0'].getRawValue().toString(), format).clearTime() : false;
		var date1 = Date.parseDate(formfields['date1'].getRawValue().toString(), format) ? Date.parseDate(formfields['date1'].getRawValue().toString(), format).clearTime() : false;

// invalid format

		if (!date0 && !formfields['date0'].hasFocus){
			if (!preventMark[0]){
				preventMark[0] = true;
				formfields['date0'].markInvalid(formfields['date0'].invalidText);
			}
			if (!preventChange[0]) {
				preventChange[0] = true;
				formfields['date0'].setValue(formfields['date0'].minValue);
				formfields['dateInterval0'].setValue(1);
			}
			valid0 = false;
		}

		if (!date1 && !formfields['date1'].hasFocus && !formfields['date1'].disabled){
			if (!preventMark[1]){
				preventMark[1] = true;
				formfields['date1'].markInvalid(formfields['date1'].invalidText);
			}
			if (!preventChange[1]) {
				preventChange[1] = true;
				formfields['date1'].setValue(formfields['date1'].minValue);
				formfields['dateInterval1'].setValue(1);
			}
			valid1 = false;
		}

		if (!(date0 && date1)){
			return false;
		}

		if (date0.between(dates['today'],dates['tomorrow'])){
			formfields['dateInterval0'].setValue(1);
			formfields['dateInterval0'].disable();
		} else {
			formfields['dateInterval0'].enable();
		}
		
		if (!formfields['date1'].disabled) {
			if (date1.between(dates['today'],dates['tomorrow'])){
				formfields['dateInterval1'].setValue(1);
				formfields['dateInterval1'].disable();
			} else {
				formfields['dateInterval1'].enable();
			}
		}
		
		var interval0 = formfields['dateInterval0'].getValue().toString();
		var interval1 = formfields['dateInterval1'].getValue().toString();

		var currentDate0 = date1.clone().clearTime();
		var currentDate1 = date1.clone().clearTime();
		var currentInterval0 = interval1;
		var currentInterval1 = interval1;

// sum date and interval 
		switch (interval0){
			case '1': date0 = date0.add(Date.HOUR, 18); break;
			case '2': date0 = date0.add(Date.HOUR, 0); break;
			case '3': date0 = date0.add(Date.HOUR, 6); break;
			case '4': date0 = date0.add(Date.HOUR, 12); break;
			case '5': date0 = date0.add(Date.HOUR, 18); break;
		}

		switch (interval1){
			case '1': date1 = date1.add(Date.HOUR, 18); break;
			case '2': date1 = date1.add(Date.HOUR, 0); break;
			case '3': date1 = date1.add(Date.HOUR, 6); break;
			case '4': date1 = date1.add(Date.HOUR, 12); break;
			case '5': date1 = date1.add(Date.HOUR, 18); break;
		}

// first date => second date

		var compare0 = date0.clone();
		var compare1 = date1.clone();

		if (interval0 == '1'){
			compare0 = compare0.add(Date.HOUR, -18);
			if (compare0.getTime() < formfields['date0'].minTimeInterval.getTime()){
				compare0 = compare0.add(Date.HOUR, formfields['date0'].minTimeInterval.getHours());
			}
		}

		if (formfields['ticketType']){
			var etcheck0 = date0.clone();
			var etcheck1 = formfields['date0'].minTimeInterval.clone().add(Date.DAY, 3).clearTime();

			if ((etcheck0.getTime() < etcheck1.getTime())/* || (formfields.receiptCity && formfields.receiptCity.getValue() == '-1')*/){
				formfields['ticketType'].setValue(2);
				formfields['ticketType'].disable();
				hideTicketTypeHint();
			} else if (formfields['ticketType'].disabled){
				formfields['ticketType'].enable();
				formfields['ticketType'].setValue(0);
			}
		}

		/*var gmt1check0 = date0.clone();
		var gmt1check1 = formfields['date0'].minTimeInterval.clone().add(Date.HOUR, 24);

		var gmt2check0 = date1.clone();
		var gmt2check1 = formfields['date1'].minTimeInterval.clone().add(Date.HOUR, 24);

		if (gmt1check0.getTime() < gmt1check1.getTime()){
			if (!formfields['dateInterval0'].disabled) formfields['dateInterval0'].disable();
		} else {
			if (formfields['dateInterval0'].disabled) formfields['dateInterval0'].enable();
		}

		if (gmt2check0.getTime() < gmt2check1.getTime()){
			if (!formfields['date1'].disabled && !formfields['dateInterval1'].disabled)formfields['dateInterval1'].disable();
		} else {
			if (!formfields['date1'].disabled && formfields['dateInterval1'].disabled) formfields['dateInterval1'].enable();
		}*/
		
		

		if (!formfields['date1'].disabled && compare0.getTime() >= compare1.getTime()){
			if (!preventMark[1]){
				preventMark[1] = true;
				formfields['date1'].markInvalid(Ext.agent.Locale['date.arrival']);
			}

			if (!preventChange[1]){
				preventChange[1] = true;
				if (date1.getTime() > formfields['date1'].maxValue.getTime()){
					formfields['date1'].setValue(formfields['date1'].maxValue);
					formfields['dateInterval1'].setValue(1);
				} else {
					formfields['date1'].setValue(
						(
							date0.clone().clearTime().getTime() != date1.clone().clearTime().getTime() &&
							currentInterval1 == lastInterval1 &&
							currentDate1.getTime() == lastDate1.getTime()
						)
						?	date0.add(Date.DAY, dates['defaultInterval']).clearTime()
						: compare0.add(Date.HOUR, 6).clearTime()
					);
				}
			}
			valid1 = false;
		}

// test min date
		if (date0.getTime() < formfields['date0'].minTimeInterval.getTime()){
			if (!preventMark[0]){
				preventMark[0] = true;
				formfields['date0'].markInvalid(formfields['date0'].minText);
			}
			if (!preventChange[0]){
				preventChange[0] = true;
				formfields['date0'].setValue(formfields['date0'].minValue);
				formfields['dateInterval0'].setValue(1);
			}
			valid0 = false;
		}

		if (!formfields['date1'].disabled && (date1.getTime() < formfields['date1'].minTimeInterval.getTime() || date1.getTime() < formfields['date0'].minTimeInterval.add(Date.HOUR, 6))){
			if (!preventMark[1]){
				preventMark[1] = true;
				formfields['date1'].markInvalid(formfields['date1'].minText);
			}
			if (!preventChange[1]){
				formfields['date1'].setValue(formfields['date1'].minValue);
				formfields['dateInterval1'].setValue(1);
			}
			valid1 = false;
		}

// test max date
		if (interval0 == '1'){
			date0 = date0.add(Date.HOUR, -12);
		}
		if (interval1 == '1'){
			date1 = date1.add(Date.HOUR, -12);
		}

		if (date0.getTime() > formfields['date0'].maxValue.getTime()){
			if (!preventMark[0]){
				preventMark[0] = true;
				formfields['date0'].markInvalid(formfields['date0'].maxText);
			}
			if (!preventChange[0]){
				preventChange[0] = true;
				formfields['date0'].setValue(formfields['date0'].maxValue);
				formfields['dateInterval0'].setValue(1);
			}
			valid0 = false;
		}

		if (date1.getTime() > formfields['date1'].maxValue.getTime() && !formfields['date1'].disabled){
			if (!preventMark[1]){
				preventMark[1] = true;
				formfields['date1'].markInvalid(formfields['date1'].maxText);
			}
			if (!preventChange[1]){
				preventChange[1] = true;
				formfields['date1'].setValue(formfields['date1'].maxValue);
				formfields['dateInterval1'].setValue(1);
			}
			valid1 = false;
		}

		if (date0.clone().clearTime().getTime() == date1.clone().clearTime().getTime() && !formfields['date1'].disabled){
			if (interval0 == '1' && interval1 != '1' && !preventMark[0]){
				formfields['date0'].markInvalid(Ext.agent.Locale['date.interval']);
				valid0 = false;
				preventMark = true;
			}
			if (interval0 != '1' && interval1 == '1' && !preventMark[1]){
				formfields['date1'].markInvalid(Ext.agent.Locale['date.interval']);
				valid1 = false;
				preventMark = true;
			}
		}

// clears invalid
		if (valid0 && formfields['date0'].errorStatus){
			formfields['date0'].clearInvalid(true);
		}
		if ((valid1 || formfields['date1'].disabled) && formfields['date1'].errorStatus){
			formfields['date1'].clearInvalid(true);
		}

// hides hint
		if (!preventMark[0] && !preventMark[1] && displayHints){
			if (defaultValues['segment0.date'] && formfields['date0'].getValue().clone().getTime() != defaultValues['segment0.date'].clone().clearTime().getTime()){
				if (hints.datetime && hints.datetime.isDisplayed() && !hints.datetime.hasActiveFx()) hints.datetime.slideOut('t', {useDisplay: true});
			}
			if (defaultValues['segment1.date'] && formfields['date1'].getValue().clone().getTime() != defaultValues['segment1.date'].clone().clearTime().getTime()){
				if (hints.datetime && hints.datetime.isDisplayed() && !hints.datetime.hasActiveFx()) hints.datetime.slideOut('t', {useDisplay: true});
			}
		}

// sets min date for second calendar 
		var tmpMinDate1 = date0.clone();

		if (interval0 == '1'){
			tmpMinDate1 = tmpMinDate1.add(Date.HOUR, -18);
		}

		if (tmpMinDate1.getTime() < formfields['date0'].minTimeInterval.getTime()){
			formfields['date1'].minTimeInterval = formfields['date0'].minTimeInterval.add(Date.HOUR, 6);
		} else {
			var minHours1 = 6;

			switch (interval0){
				case '3': minHours1 = 12; break;
				case '4': minHours1 = 18; break;
				case '5': minHours1 = 24; break;
			}

			formfields['date1'].minTimeInterval = date0.clone().clearTime().add(Date.HOUR, minHours1);
		}

		formfields['date1'].calendar.cfg.minValue = formfields['date1'].minTimeInterval.clone().clearTime();

		lastDate0 = currentDate0;
		lastDate1 = currentDate1;
		lastInterval0 = currentInterval0;
		lastInterval1 = currentInterval1;
		return (valid0 && valid1);
	}

	var html = {};
	var formfields = {};

	html.form = Ext.get(fs);
	html.form.hide();

	html.direction = dh.append(html.form, {tag: 'div', cls: 'wrapper'}, true);
	html.datetime = dh.append(html.form, {tag: 'div', cls: 'wrapper', style: 'z-index: 1'}, true);

	if (enablePreferences){
		dh.append(html.form, {tag: 'h3', html: Ext.agent.Locale['form.passengers'], style: 'margin: 0; padding: 9px 0 18px;'});
	} else {
		dh.append(html.form, {tag: 'h3', html: Ext.agent.Locale['form.passengers'], style: 'margin: 0; padding: 9px 0 11px;'});
	}

	if (enablePreferences){
		html.passengers = dh.append(html.form, {tag: 'div', cls: 'passengers-search'}, true);
		html.adults = dh.append(html.passengers, {
			cls: 'wrapper',
			cn: [
				{
					cls: 'unit label',
					cn: {
						tag: 'label',
						html: Ext.agent.Locale['form.adults']
					}
				},
				{
					cls: 'unit',
					cn: {
						cls: 'x-form-element',
						id: fs + '.field.adults'
					}
				}
			]
		});

		html.children = dh.append(html.passengers, {
			cls: 'wrapper',
			cn: [
				{
					cls: 'unit label',
					cn: {
						tag: 'label',
						html: Ext.agent.Locale['form.children']
					}
				},
				{
					cls: 'unit',
					cn: {
						cls: 'x-form-element',
						id: fs + '.field.children'
					}
				}
			]
		});
		html.infantsWithoutSeat = dh.append(html.passengers, {
			cls: 'wrapper',
			cn: [
				{
					cls: 'unit label',
					cn: {
						tag: 'label',
						html: Ext.agent.Locale['form.infantsWithoutSeat']
					}
				},
				{
					cls: 'unit',
					cn: {
						cls: 'x-form-element',
						id: fs + '.field.infantsWithoutSeat'
					}
				}
			]
		});
		html.infantsWithSeat = dh.append(html.passengers, {
			cls: 'wrapper',
			cn: [
				{
					cls: 'unit label',
					cn: {
						tag: 'label',
						html: Ext.agent.Locale['form.infantsWithSeat']
					}
				},
				{
					cls: 'unit',
					cn: {
						cls: 'x-form-element',
						id: fs + '.field.infantsWithSeat'
					}
				}
			]
		});
	} else {
		html.passengers = dh.append(html.form, {tag: 'div', cls: 'wrapper'}, true);
		html.adults = dh.append(html.passengers, {
			cls: 'unit',
			cn: [
				{
					cls: 'label',
					cn: {
						tag: 'label',
						html: Ext.agent.Locale['form.adults']
					}
				},
				{
					cls: 'x-form-element',
					id: fs + '.field.adults'
				}
			]
		});
	}

	if (enablePreferences){
		createPreferences(formfields, html.form);
	}

	dh.append(html.form, {tag: 'div', cls: 'clear'});
	html.submitButtonWrap = dh.append(html.form, {tag: 'div', cls: 'buttons', cn: {tag: 'div'}}, true);
	html.submitButton = dh.append(html.submitButtonWrap.first(), {tag: 'img', id: 'findFlightsButton', src: Ext.agent.IMG['submit'].src, cls: 'submit'}, true);

	if (!enablePreferences){
		html.extendedSearch = dh.append(html.submitButtonWrap, {
			cls: 'button-text',
			cn: {
				tag: 'a',
				cls: 'white',
				onfocus: 'this.blur()',
				html: Ext.agent.Locale['form.advanced']
			}
		}, true);

		html.extendedSearch.first().on('click', submitExtendedSearch);
	}

	function specialValidate(){
		return dates['now'].between(new Date('6/26/2009 11:00:00 PM GMT+0400'),new Date('6/27/2009 00:00:00 AM GMT+0400'));
	}
	
	function toggleSubmit(form, valid, checkPrefs){
		if (!validateDates(form)) valid = false;
		if (enablePreferences && !countPassengers()) valid = false;

		if ((valid || (!enablePreferences && checkPrefs !== true)) && !specialValidate()) {
			form.isCorrect = true;
			if (html.submitButton.dom.src != Ext.agent.IMG['submit'].src) html.submitButton.dom.src = Ext.agent.IMG['submit'].src;
			html.submitButton.removeClass('disabled');
		} else {
			form.isCorrect = false;
			if (html.submitButton.dom.src != Ext.agent.IMG['submit-disabled'].src) html.submitButton.dom.src = Ext.agent.IMG['submit-disabled'].src;
			html.submitButton.addClass('disabled');
		}
	}

	function focusField(field){
		Ext.get(document.documentElement).scrollTo('t', 0, true);
		if (enablePreferences){
			field.validate();
		}
		field.focus();
	}

	var form = new Ext.form.BasicForm(html.form, {
		method: 'POST',
		submitting: false,
		submit: function(force){
			if (force !== true && (form.submitting || !form.isCorrect)){
				return false;
			}

			if (force !== true && !formfields.departure0.getValue()){
				focusField(formfields.departure0);
				return false;
			}

			if (force !== true && !formfields.arrival0.getValue()){
				focusField(formfields.arrival0);
				return false;
			}

			form.submitting = true;
			copyLocations(formfields);
			form.stopMonitoring();
			toggleSubmit(form, false, true);
			if (formfields['ticketType']){
				try {
					formfields['ticketType'].hiddenField.disabled = false;
				} catch (e) {
					formfields['ticketType'].enable();
				}
				if (isLegal) formfields.ticketType.setValue(2);
			}
			form.getEl().dom.submit();
/*
			maskBody(true, true, function(){
				form.getEl().dom.submit();
			});
*/
		},
		listeners: {
			clientvalidation: toggleSubmit
		}
	});

	html.submitButton.on('click', form.submit);


	Ext.apply(formfields, {
		action: new Ext.form.Hidden({
			name: fs + '.action',
			value: 'search',
			renderTo: form.getEl()
		}),
		redirect: new Ext.form.Hidden({
			name: fs + '.redirect',
			value: Ext.agent.Locale['form.redirect'],
			renderTo: form.getEl()
		})
	});

	createCityCombo(0, 'departure', formfields, html.direction);
	createCityCombo(0, 'arrival', formfields, html.direction);

	dh.append(html.direction, {
		tag: 'div',
		cls: 'unit',
		style: 'padding: 18px 0 0 6px;',
		cn: [
			{tag: 'input', type: 'checkbox', id: fs + '.is-return-ticket'},
			{tag: 'label', html: Ext.agent.Locale['form.return'], htmlFor: fs + '.is-return-ticket'}
		]
	});

	Ext.apply(formfields, {
		isReturnTicket: new Ext.form.Checkbox({
			name: fs + '.is-return-ticket',
			applyTo: fs + '.is-return-ticket',
			listeners: {
				check: isReturn
			}
		})
	});

	formfields['isReturnTicket'].setValue(defaultValues['segment0.departureID'] ? (defaultValues['segment1.departureID'] ? true : false) : true);

	var dates = {};
	dates['now'] = currentDate.clone();
	dates['defaultMinHours'] = Ext.agent.Locale['defaultHoursInterval'];
	dates['defaultInterval'] = 7;
	dates['today'] = currentDate.clone().clearTime();
	dates['tomorrow'] = dates['today'].clone().add(Date.DAY, 1);
	dates['minTime'] = currentDate.add(Date.HOUR, dates['defaultMinHours']);
	dates['minInterval'] = currentDate.clone().clearTime().add(Date.HOUR, dates['defaultMinHours']).add(Date.HOUR, Math.floor((currentDate.getHours()) / 6) * 6);
	dates['maxInterval'] = currentDate.clone().clearTime().add(Date.MONTH, 6).add(Date.HOUR, 23);
	dates['date0'] = defaultValues['segment0.date'] ? new Date(defaultValues['segment0.date']) : dates['minInterval'];
	dates['date1'] = defaultValues['segment1.date'] ? new Date(defaultValues['segment1.date']) : dates['minInterval'].add(Date.DAY, dates.defaultInterval);
	dates['format'] = 'd.m.Y';

	createDate(0, formfields, html.datetime, {
		'today': dates['today'],
		'minTime': dates['minTime'],
		'minInterval': dates['minInterval'],
		'maxInterval': dates['maxInterval'],
		'value': dates['date0'],
		'format': dates['format']
	});

	createDate(1, formfields, html.datetime, {
		'today': dates['today'].add(Date.HOUR, 6).clearTime(),
		'minTime': dates['minTime'].add(Date.HOUR, 6),
		'minInterval': dates['minInterval'].add(Date.HOUR, 6),
		'maxInterval': dates['maxInterval'].add(Date.HOUR, 24),
		'value': dates['date1'],
		'format': dates['format']
	});

	var lastDate0 = formfields['date0'].getValue();
	var lastDate1 = formfields['date1'].getValue();
	var lastInterval0 = formfields['dateInterval0'].getValue().toString();
	var lastInterval1 = formfields['dateInterval1'].getValue().toString();

	Ext.apply(formfields, {
		departure1: new Ext.form.Hidden({
			name: fs + '.segment[1].departurePointID',
			renderTo: form.getEl()
		}),
		arrival1: new Ext.form.Hidden({
			name: fs + '.segment[1].arrivalPointID',
			renderTo: form.getEl()
		}),
		segmentsCount: new Ext.form.Hidden({
			name: fs + '.segmentsCount',
			renderTo: form.getEl()
		}),
		type: new Ext.form.Hidden({
			name: fs + '.type',
			value: 'simple',
			renderTo: form.getEl()
		})
	});

	if (!enablePreferences){
		Ext.apply(formfields, {
			ticketType: new Ext.form.Hidden({
				name: fs + '.ticketType',
				renderTo: form.getEl(),
				value: '0'
			})
		});
	}

	Ext.apply(formfields, {
		adults: new Ext.form.ComboBox({
			value: defaultValues['passengers']['adult'] ? defaultValues['passengers']['adult'] : 1,
			store: new Ext.data.SimpleStore({
				fields: ['value', 'text'],
				data: adultsRecords
			}),
			preventValidationEventChange: true,
			displayField: 'text',
			hiddenName: fs + '.categories[adult]',
			valueField: 'value',
			renderTo: fs + '.field.adults',
			mode: 'local',
			defaultValue: defaultValues['passengers']['adult'],
			triggerAction: 'all',
			editable: false,
			width: enablePreferences ? 139 : 113,
			listeners: {
				select: enablePreferences ? changeLastSelectedCategory : Ext.emptyFn
			}
		})
	});

	if (enablePreferences){
		Ext.apply(formfields, {
			children: new Ext.form.ComboBox({
				value: defaultValues['passengers']['child'] ? defaultValues['passengers']['child'] : 0,
				store: new Ext.data.SimpleStore({
					fields: ['value', 'text'],
					data: childrenRecords
				}),
				defaultValue: defaultValues['passengers']['child'],
				preventValidationEventChange: true,
				displayField: 'text',
				hiddenName: fs + '.categories[child]',
				valueField: 'value',
				renderTo: fs + '.field.children',
				mode: 'local',
				triggerAction: 'all',
				editable: false,
				width: 139,
				listeners: {
					select: changeLastSelectedCategory
				}
			}),
			infantsWithoutSeat: new Ext.form.ComboBox({
				value: defaultValues['passengers']['infantWithoutSeat'] ? defaultValues['passengers']['infantWithoutSeat'] : 0,
				store: new Ext.data.SimpleStore({
					fields: ['value', 'text'],
					data: childrenRecords
				}),
				defaultValue: defaultValues['passengers']['infantWithoutSeat'],
				preventValidationEventChange: true,
				displayField: 'text',
				hiddenName: fs + '.categories[infantWithoutSeat]',
				valueField: 'value',
				renderTo: fs + '.field.infantsWithoutSeat',
				mode: 'local',
				triggerAction: 'all',
				editable: false,
				width: 139,
				listeners: {
					select: changeLastSelectedCategory,
					expand: function(){
						this.store.filterBy(function(record, id){
							var current = record;
							if (record.data['value'] <= formfields['adults'].getValue()){
								return true;
							};
						});
					}
				}
			}),
			infantsWithSeat: new Ext.form.ComboBox({
				value: defaultValues['passengers']['infantWithSeat'] ? defaultValues['passengers']['infantWithSeat'] : 0,
				store: new Ext.data.SimpleStore({
					fields: ['value', 'text'],
					data: childrenRecords
				}),
				defaultValue: defaultValues['passengers']['infantWithSeat'],
				preventValidationEventChange: true,
				displayField: 'text',
				hiddenName: fs + '.categories[infantWithSeat]',
				valueField: 'value',
				renderTo: fs + '.field.infantsWithSeat',
				mode: 'local',
				triggerAction: 'all',
				editable: false,
				width: 139,
				listeners: {
					select: changeLastSelectedCategory
				}
			})
		});

		formfields['adults'].on('select', checkInfantsWithoutSeat);
		formfields['infantsWithoutSeat'].on('select', checkInfantsWithoutSeat);
	}


	function checkInfantsWithoutSeat(){
		if (parseInt(formfields['infantsWithoutSeat'].getValue()) > parseInt(formfields['adults'].getValue())){
			formfields['infantsWithoutSeat'].setValue(formfields['adults'].getValue());
		}
	}

	var lastSelectedCategory;

	function hidePassengerHint(){
		if (this.defaultValue != this.getValue()){
			hints.passengers.slideOut('t', {useDisplay: true});
		}
	}

	function changeLastSelectedCategory(field){
		lastSelectedCategory = field;

		if (displayHints && hints.passengers && hints.passengers.isDisplayed() && !hints.passengers.hasActiveFx()){
			hidePassengerHint.call(this);
		}
		return false;
	}

	function countPassengers(){
		if (!lastSelectedCategory) return true;

		function clearCategories(all){
			for (var i = 0; i < fields.length; i++){
				if (all || (fields[i] != lastSelectedCategory && fields[i].errorEl)){
					fields[i].clearInvalid();
				}
			}
		}

		var fields = [
			formfields['adults'],
			formfields['children'],
			formfields['infantsWithoutSeat'],
			formfields['infantsWithSeat']
		]

		var count = 0;

		for (var i = 0; i < fields.length; i++){
			count += parseInt(fields[i].getValue());
		}

		checkInfantsWithoutSeat();		

		if (count > passengersLimit){
			if (parseInt(lastSelectedCategory.getValue()) == 0){
				if (lastSelectedCategory.errorEl){
					lastSelectedCategory.clearInvalid();
				}

				for (var i = 0; i < fields.length; i++){
					if (parseInt(fields[i].getValue()) > 0){
						lastSelectedCategory = fields[i];
					}
				}

				if (!lastSelectedCategory.errorEl){
					lastSelectedCategory.markInvalid(Ext.agent.Locale['categories.limit']);
				}
			} else if (!lastSelectedCategory.errorEl){
				lastSelectedCategory.markInvalid(Ext.agent.Locale['categories.limit']);
			}
			clearCategories();
			return;
		} else {
			clearCategories(true);
		}
		return true;
	}

	function isReturn(init) {
		if (!formfields['date1']) return;

		var show = formfields.isReturnTicket.getValue();
		if (!show) {
			formfields['departure1'].disable();
			formfields['arrival1'].disable();
			formfields['date1'].disable();
			formfields['dateInterval1'].disable();
			formfields['segmentsCount'].setValue('1');

			if (displayHints && hints.direction && hints.direction.isDisplayed()){
				hints.direction.slideOut('t', {useDisplay: true});
			}
		}
		else {
			if (formfields['date0'].getValue() && init !== true && formfields['date1'].getValue() && formfields['date1'].getValue().clone().clearTime().getTime() < formfields['date0'].getValue().clone().clearTime().getTime()){
				if (formfields['date1'].maxValue){
					if (formfields['date0'].getValue().add(Date.DAY, dates['defaultInterval']).getTime() < formfields['date1'].maxValue.getTime()){
						formfields['date1'].setValue(formfields['date0'].getValue().add(Date.DAY, dates['defaultInterval']));
					} else {
						formfields['date1'].setValue(formfields['date1'].maxValue);
					}
				}
			}

			formfields['departure1'].enable();
			formfields['arrival1'].enable();
			formfields['date1'].enable();
			formfields['dateInterval1'].enable();
			formfields['segmentsCount'].setValue('2');
		}
	}

	function initStores(){
		formfields['dateInterval0'].doQuery('', true);
		formfields['dateInterval1'].doQuery('', true);
		formfields['adults'].doQuery('', true);

		if (enablePreferences){
			formfields['bookingClass'].doQuery('', true);
			formfields['aircompany'].doQuery('', true);
			/*formfields['receiptCity'].doQuery('', true);*/
		}
	}

	function checkEnter(field, e){
		var target = Ext.get(e.getTarget());
		if (e.getKey() == 13){
			target.blur();
			form.submit();
		}
	}

	for (var i in formfields){
		if (formfields[i].getXType() == 'textfield' || formfields[i].editable){
			formfields[i].on('specialkey', checkEnter);
		}
		form.add(formfields[i]);
	}

	if (enablePreferences && displayHints && defaultValues['segment0.date']){
		var showDatesHint = validateDates.call({preventMark: true}, form) ? 2 : 0;
		if (!defaultValues['segment1.date']){
			showDatesHint = 1;
		}
		var hints = showHints(html, formfields, showDatesHint);
	}

	isReturn(true);
	initStores();

	html.form.show();
	form.startMonitoring();

	if (enablePreferences && showSameCities){
		isSameCities();
	}
}

Ext.onReady(ExtLoad);