application/vnd.gov.sk.e-form+xml
001.Ohlásenie k miestnemu poplatku za komunálne odpady a drobné stavebné odpady
http://data.gov.sk/doc/eform/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1
001.Ohlásenie k miestnemu poplatku za komunálne odpady a drobné stavebné odpady
Civan Richard
ico://sk/00308307
1.1
2015-11-16
2015-11-16
2016-03-08
<?xml version="1.0" encoding="UTF-8"?><xs:schema elementFormDefault="qualified" attributeFormDefault="unqualified" xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1" xmlns="http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1">
<xs:simpleType name="xsdTextCislo">
<xs:restriction base="xs:integer">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdTextBox">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="datum">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdComboTypPobyt">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCiselnikStaty">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCiselnikObce">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCiselnikKraje">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCiselnikOkresy">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdTextPSC">
<xs:restriction base="xs:string">
<xs:maxLength value="6" />
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCheckBox">
<xs:restriction base="xs:boolean">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdRadioTypNotifikacie">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCiselnikTitulyPred">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCiselnikTitulyZa">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdRadioSposobDoruceniaVystupu">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>


<xs:element name="eForm_eGov_001">
<xs:complexType>
<xs:sequence>
<xs:element name="SekciaObec" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="Obec_MsU" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="Obec_Telefon" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="Obec_BankoveSpojenie" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="Obec_ICO" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="Obec_DIC" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="Obec_Email" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaHeader" minOccurs="0">
<xs:complexType>
<xs:sequence>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaZiadatelFO_PhysicalPerson" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="sekciaZiadatelFODetail" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="ZiadatelFODetailTitulPred_PrefixQualificationAffix" type="xsdCiselnikTitulyPred" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODetailMeno_GivenName" type="xsdTextBox" minOccurs="1" />
<xs:element name="ZiadatelFODetailRC" type="xsdTextBox" minOccurs="1" />
<xs:element name="ZiadatelFODetailTitulZa_PostfixQualificationAffix" type="xsdCiselnikTitulyZa" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODetailPriezvisko_FamilyName" type="xsdTextBox" minOccurs="1" />
<xs:element name="ZiadatelFODetailDatumNarodenia_DateOfBirth" type="datum" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="ZiadatelFOTrvalyPobytAdresaStat_Country" type="xsdCiselnikStaty" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaObec_Municipality" type="xsdCiselnikObce" minOccurs="1" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaUlica_StreetName" type="xsdTextBox" minOccurs="1" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaKraj_Region" type="xsdCiselnikKraje" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaCastObce_District" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber" type="xsdTextBox" minOccurs="1" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaOkres_County" type="xsdCiselnikOkresy" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaPSC_PostalCode" type="xsdTextPSC" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaZiadatelFOPrechodnyPobytAdresa" minOccurs="0" maxOccurs="1">
<xs:complexType>
<xs:sequence>
<xs:element name="ZiadatelFOPrechodnyPobytAdresaStat_Country" type="xsdCiselnikStaty" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaObec_Municipality" type="xsdCiselnikObce" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaUlica_StreetName" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaKraj_Region" type="xsdCiselnikKraje" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaCastObce_District" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaOkres_County" type="xsdCiselnikOkresy" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode" type="xsdTextPSC" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaZiadatelFODorucenieAdresa_DeliveryAddress" minOccurs="0" maxOccurs="1">
<xs:complexType>
<xs:sequence>
<xs:element name="ZiadatelFODorucenieAdresaStat_Country" type="xsdCiselnikStaty" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaObec_Municipality" type="xsdCiselnikObce" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaUlica_StreetName" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaKraj_Region" type="xsdCiselnikKraje" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaCastObce_District" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaOkres_County" type="xsdCiselnikOkresy" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaPSC_PostalCode" type="xsdTextPSC" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaOrC_BuildingNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaZiadatelFOKontakt" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="ZiadatelFOKontaktTelCislo_TelephoneAddress" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOKontaktEmailAdresa" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaNehnutelnost" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="NehnutelnostAdresaNehnutelnostiStat_Country" type="xsdCiselnikStaty" minOccurs="0" nillable="true" />
<xs:element name="NehnutelnostAdresaNehnutelnostiObec_Municipality" type="xsdCiselnikObce" minOccurs="1" />
<xs:element name="NehnutelnostAdresaNehnutelnostiUlica_StreetName" type="xsdTextBox" minOccurs="1" />
<xs:element name="NehnutelnostAdresaNehnutelnostiKraj_Region" type="xsdCiselnikKraje" minOccurs="0" nillable="true" />
<xs:element name="NehnutelnostAdresaNehnutelnostiCastObce_District" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber" type="xsdTextBox" minOccurs="1" />
<xs:element name="NehnutelnostAdresaNehnutelnostiOkres_County" type="xsdCiselnikOkresy" minOccurs="0" nillable="true" />
<xs:element name="NehnutelnostAdresaNehnutelnostiPSC_PostalCode" type="xsdTextPSC" minOccurs="0" nillable="true" />
<xs:element name="NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaOsobyUzivajuce" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="sekciaOsobyUzivajucePocet" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="OsobyUzivajucePocet" type="xsdTextCislo" minOccurs="1" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaOsobyUzivajuceZoznam" minOccurs="1" maxOccurs="10">
<xs:complexType>
<xs:sequence>
<xs:element name="OsobyUzivajuceZoznamMeno_GivenName" type="xsdTextBox" minOccurs="1" />
<xs:element name="OsobyUzivajuceZoznamPriezvisko_FamilyName" type="xsdTextBox" minOccurs="1" />
<xs:element name="OsobyUzivajuceZoznamMeno_DateOfBirth" type="datum" minOccurs="0" nillable="true" />
<xs:element name="OsobyUzivajuceZoznamTypPobytu" type="xsdComboTypPobyt" minOccurs="1" />
<xs:element name="sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country" type="xsdCiselnikStaty" minOccurs="0" nillable="true" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality" type="xsdCiselnikObce" minOccurs="1" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName" type="xsdTextBox" minOccurs="1" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region" type="xsdCiselnikKraje" minOccurs="0" nillable="true" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber" type="xsdTextBox" minOccurs="1" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County" type="xsdCiselnikOkresy" minOccurs="0" nillable="true" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode" type="xsdTextPSC" minOccurs="0" nillable="true" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="SekciaOchranaOsobnychUdajov" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="OchranaOsobnychUdajovSuhlas" type="xsdCheckBox" minOccurs="1" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaNotifikacie" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="NotifikacieZasielanie" type="xsdRadioTypNotifikacie" minOccurs="0" nillable="true" />
<xs:element name="NotifikacieKontakt" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaSposobDoruceniaVystupu" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="SposobDoruceniaVystupuTyp" type="xsdRadioSposobDoruceniaVystupu" minOccurs="0" nillable="true" />
<xs:element name="SposobDoruceniaVystupuKontakt" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaFooter" minOccurs="0">
<xs:complexType>
<xs:sequence>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>


Mestský úrad Nitra, Štefánikova trieda 60, 950 06 Nitra
037/65 02 111
SK0409000000005028001139
00308307
2021102853
info@nitra.sk
Slovenská republika
Nitra
Nitriansky kraj
Okres Nitra
Slovenská republika
Nitra
Nitriansky kraj
Okres Nitra
Slovenská republika
Nitra
Nitriansky kraj
Okres Nitra
Slovenská republika
Nitra
Nitriansky kraj
Okres Nitra
0
Slovenská republika
Nitra
Nitriansky kraj
Okres Nitra
0
1
eDesk
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE xsl:stylesheet [ <!ENTITY nbsp "&#xa0;">]>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"  xmlns:egonp="http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1" exclude-result-prefixes="egonp"> 
<xsl:output method="html" doctype-system="http://www.w3.org/TR/html4/loose.dtd" doctype-public="-//W3C//DTD HTML 4.01 Transitional//EN" indent="no" omit-xml-declaration="yes"/>
<xsl:template match="/">
<html>
	<head>
	<meta http-equiv="X-UA-Compatible" content="IE=edge" />
	<title>001.Ohlásenie k miestnemu poplatku za komunálne odpady a drobné stavebné odpady</title>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
	<meta name="language" content="sk-SK" />
		<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/jquery-ui.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/jquery.multiselect.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/jquery.multiselect.filter.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/base.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/ego.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/treeselect.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/chosentree.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/p_upvs.css" rel="stylesheet" type="text/css"/>
	<link href="https://fonts.googleapis.com/css?family=Open+Sans:300,400,400italic,bold,600&amp;subset=latin,latin-ext" rel="stylesheet" type="text/css" />
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery-migrate.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.mask.min.js" type="text/javascript"></script>	
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery-ui.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.dataTables.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery-ui-timepicker-addon.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.multiselect.filter.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.multiselect.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.validate.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.validate.customRules.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/ego.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.form.plugins.js" type="text/javascript"></script>			
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/ego.statusDialog.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.chosentree.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.treeselect.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/fillerSaver.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/wrapper.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/p_upvs.js" type="text/javascript"></script>
		<script type="text/javascript">
		var projectType = 'UPVS';
		
					<xsl:text disable-output-escaping="yes">
								$(function (){
				  $("textarea").each(function () {
				   this.style.height = (this.scrollHeight)+'px';
				  });
				});
					/* <![CDATA[ */
		
		
		
		
		function GetExternalResourceIndex(resourcetype) {
  switch (resourcetype) {
    default:
      return null;
  }
  return null;
}
function GetExternalResource(resourcetype, index) {
  switch (resourcetype) {
    default:
      return null;
  }
  return null;
}

		function SetDefaultValue(key, value) {
  if (value == '' || key == '') {
    return;
	}
}
function GetDefaultValue() {
  var retString = '';
  return retString;
}

				function InitConditionalRules(context, sid) {
			if (sid == null) {

			$(document).ready(function () {
$("[id|='OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode']").mask("Y999 99", {'translation': { Y: {pattern: /[+,-]/, optional: true} }});
$("[id|='NehnutelnostAdresaNehnutelnostiPSC_PostalCode']").mask("Y999 99", {'translation': { Y: {pattern: /[+,-]/, optional: true} }});
$("[id|='ZiadatelFOTrvalyPobytAdresaPSC_PostalCode']").mask("Y999 99", {'translation': { Y: {pattern: /[+,-]/, optional: true} }});
});

			
			
			
			
			}
		}
						

		var validatorObject = null;
		
		function InitValidation() {
			validatorObject = $("#eForm_eGov_001").validate({
							errorLabelContainer: $("#errorsContainer"),
				wrapper: "li",
				onkeyup: false,
				onclick: false,
		        ignore: ".disableValidators",
								rules: {
			  		OsobyUzivajucePocet :
{
required: true
},

OsobyUzivajuceZoznamMeno_GivenName :
{
required: true
},

OsobyUzivajuceZoznamPriezvisko_FamilyName :
{
required: true
},


OsobyUzivajuceZoznamTypPobytu :
{
required: true
},


OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality :
{
required: true
},

OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName :
{
required: true
},

OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber :
{
required: true
},





OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode :
{
maxlength: 6
},


NehnutelnostAdresaNehnutelnostiObec_Municipality :
{
required: true
},

NehnutelnostAdresaNehnutelnostiUlica_StreetName :
{
required: true
},

NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber :
{
required: true
},





NehnutelnostAdresaNehnutelnostiPSC_PostalCode :
{
maxlength: 6
},









OchranaOsobnychUdajovSuhlas :
{
required: true
},













ZiadatelFODorucenieAdresaPSC_PostalCode :
{
maxlength: 5
},


ZiadatelFODetailMeno_GivenName :
{
required: true
},

ZiadatelFODetailRC :
{
required: true
},

ZiadatelFODetailPriezvisko_FamilyName :
{
required: true
},




ZiadatelFOTrvalyPobytAdresaObec_Municipality :
{
required: true
},

ZiadatelFOTrvalyPobytAdresaUlica_StreetName :
{
required: true
},

ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber :
{
required: true
},





ZiadatelFOTrvalyPobytAdresaPSC_PostalCode :
{
maxlength: 6
},









ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode :
{
maxlength: 5
}
			  	},
				messages: {			
			   		OsobyUzivajucePocet :
{
required: "Položka 'Počet osôb, ktoré využívajú nehnuteľnosť, resp. majú prihlásený trvalý alebo prechodný pobyt, majú právo užívať nehnuteľnosť na uvedenej adrese' musí byť vyplnená"
},

OsobyUzivajuceZoznamMeno_GivenName :
{
required: "Položka 'Meno' musí byť vyplnená"
},

OsobyUzivajuceZoznamPriezvisko_FamilyName :
{
required: "Položka 'Priezvisko' musí byť vyplnená"
},

OsobyUzivajuceZoznamMeno_DateOfBirth :
{
date: "Položka 'Dátum narodenia' má neplatný formát"
},

OsobyUzivajuceZoznamTypPobytu :
{
required: "Položka 'Označenie pobytu' musí byť vyplnená"
},


OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality :
{
required: "Položka 'Obec' musí byť vyplnená"
},

OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName :
{
required: "Položka 'Ulica' musí byť vyplnená"
},

OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber :
{
required: "Položka 'Súp.č.' musí byť vyplnená"
},





OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 6 znakov"
},


NehnutelnostAdresaNehnutelnostiObec_Municipality :
{
required: "Položka 'Obec' musí byť vyplnená"
},

NehnutelnostAdresaNehnutelnostiUlica_StreetName :
{
required: "Položka 'Ulica' musí byť vyplnená"
},

NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber :
{
required: "Položka 'Súp.č.' musí byť vyplnená"
},





NehnutelnostAdresaNehnutelnostiPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 6 znakov"
},









OchranaOsobnychUdajovSuhlas :
{
required: "Položka 'Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona.' musí byť vyplnená"
},













ZiadatelFODorucenieAdresaPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 5 znakov"
},


ZiadatelFODetailMeno_GivenName :
{
required: "Položka 'Meno' musí byť vyplnená"
},

ZiadatelFODetailRC :
{
required: "Položka 'Rodné číslo' musí byť vyplnená"
},

ZiadatelFODetailPriezvisko_FamilyName :
{
required: "Položka 'Priezvisko' musí byť vyplnená"
},


ZiadatelFODetailDatumNarodenia_DateOfBirth :
{
date: "Položka 'Dátum narodenia' má neplatný formát"
},


ZiadatelFOTrvalyPobytAdresaObec_Municipality :
{
required: "Položka 'Obec' musí byť vyplnená"
},

ZiadatelFOTrvalyPobytAdresaUlica_StreetName :
{
required: "Položka 'Ulica' musí byť vyplnená"
},

ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber :
{
required: "Položka 'Súp.č.' musí byť vyplnená"
},





ZiadatelFOTrvalyPobytAdresaPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 6 znakov"
},









ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 5 znakov"
}	  	
			  	}
			});
	  	}
	/* ]]> */
					</xsl:text>
			</script>
	<style type="text/css">
		.infoIcon {display:none;}
.logo img {width:100px; height:120px;}
.LabelBold{font-weight: bold;}
.VecNazovFrm {font-size:26px;font-weight:bold;text-align: center;text-transform: uppercase;}
.OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country_internal{width:110px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality_internal{width:110px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber_internal{width:50px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region_internal{width:110px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber_internal{width:50px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County_internal{width:110px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode_internal{width:50px;}.NehnutelnostAdresaNehnutelnostiStat_Country_internal{width:110px;}.NehnutelnostAdresaNehnutelnostiObec_Municipality_internal{width:110px;}.NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber_internal{width:50px;}.NehnutelnostAdresaNehnutelnostiKraj_Region_internal{width:110px;}.NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber_internal{width:50px;}.NehnutelnostAdresaNehnutelnostiOkres_County_internal{width:110px;}.NehnutelnostAdresaNehnutelnostiPSC_PostalCode_internal{width:50px;}.HeaderNazov_internal{width:500px;}.ZiadatelFODorucenieAdresaStat_Country_internal{width:110px;}.ZiadatelFODorucenieAdresaObec_Municipality_internal{width:110px;}.ZiadatelFODorucenieAdresaKraj_Region_internal{width:110px;}.ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber_internal{width:50px;}.ZiadatelFODorucenieAdresaOrC_BuildingNumber_internal{width:50px;}.ZiadatelFODorucenieAdresaOkres_County_internal{width:110px;}.ZiadatelFODorucenieAdresaPSC_PostalCode_internal{width:50px;}.ZiadatelFODetailTitulPred_PrefixQualificationAffix_internal{width:60px;}.ZiadatelFODetailTitulZa_PostfixQualificationAffix_internal{width:60px;}.ZiadatelFOTrvalyPobytAdresaStat_Country_internal{width:110px;}.ZiadatelFOTrvalyPobytAdresaObec_Municipality_internal{width:110px;}.ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber_internal{width:50px;}.ZiadatelFOTrvalyPobytAdresaKraj_Region_internal{width:110px;}.ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber_internal{width:50px;}.ZiadatelFOTrvalyPobytAdresaOkres_County_internal{width:110px;}.ZiadatelFOTrvalyPobytAdresaPSC_PostalCode_internal{width:50px;}.ZiadatelFOPrechodnyPobytAdresaStat_Country_internal{width:110px;}.ZiadatelFOPrechodnyPobytAdresaObec_Municipality_internal{width:110px;}.ZiadatelFOPrechodnyPobytAdresaKraj_Region_internal{width:110px;}.ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber_internal{width:50px;}.ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber_internal{width:50px;}.ZiadatelFOPrechodnyPobytAdresaOkres_County_internal{width:110px;}.ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode_internal{width:50px;}.ZiadatelFOKontaktEmailAdresa_internal{width:220px;}.SposobDoruceniaVystupuKontakt_internal{width:210px;}
	</style>
</head>
<body>
	<noscript><p class="noscript">Pre kompletnú funkčnosť aplikácie je potrebné povoliť JavaScript</p></noscript>
	<div id="errorsContainerDiv" class="errorsContainerDiv"> <ul id="errorsContainer" class="errorsContainer"><li/></ul> </div>
	<form id="eForm_eGov_001" action="">
		<div id="main" class="layoutMain ui-widget-content">	
						 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:SekciaObec">		
		<div id="layoutRow9892" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="SekciaObec" />
				<div id="layoutRowContentlayoutRow9892" class="columns">
				
				<div id="layoutColumn18618" class="column first"  style="width:150px;">
											
<div id="layoutCell48466" class="cell  logo" >		
			
		<span class="fieldContent" style="display: none"><img src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Images/Logo" alt="" title=""/></span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18619" class="column "  style="width:500px;">
											
<div id="layoutCell48467" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_MsU"  style="width:450px;"><xsl:text disable-output-escaping="yes">Mesto Nitra: Mestský úrad Nitra, Štefánikova trieda 60, 950 06 Nitra </xsl:text> </label><span class="fieldContent" style="display: none"><input id="Obec_MsU" name="Obec_MsU" title="" type="text" class="xsd_string textBox "  maxlength="400" size="340"  disabled="disabled"  alt="" value="Mestský úrad Nitra, Štefánikova trieda 60, 950 06 Nitra" ><xsl:if test="boolean(./*[name() = 'Obec_MsU']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'Obec_MsU']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'Obec_MsU']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Mesto Nitra: Mestský úrad Nitr" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48468" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_Telefon"  style="width:250px;"><xsl:text disable-output-escaping="yes">Telefón: 037/65 02 111 </xsl:text> </label><span class="fieldContent" style="display: none"><input id="Obec_Telefon" name="Obec_Telefon" title="" type="text" class="xsd_string textBox "  maxlength="400" size="150"  disabled="disabled"  alt="" value="037/65 02 111" ><xsl:if test="boolean(./*[name() = 'Obec_Telefon']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'Obec_Telefon']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'Obec_Telefon']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Telefón: 037/65 02 111" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48469" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_BankoveSpojenie"  style="width:290px;"><xsl:text disable-output-escaping="yes">IBAN: SK0409000000005028001139 </xsl:text> </label><span class="fieldContent" style="display: none"><input id="Obec_BankoveSpojenie" name="Obec_BankoveSpojenie" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  disabled="disabled"  alt="" value="SK0409000000005028001139" ><xsl:if test="boolean(./*[name() = 'Obec_BankoveSpojenie']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'Obec_BankoveSpojenie']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'Obec_BankoveSpojenie']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "IBAN: SK0409000000005028001139" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18620" class="column "  style="width:150px;">
											
<div id="layoutCell48471" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_ICO"  style="width:150px;"><xsl:text disable-output-escaping="yes">IČO: 00308307 </xsl:text> </label><span class="fieldContent" style="display: none"><input id="Obec_ICO" name="Obec_ICO" title="" type="text" class="xsd_string textBox "  maxlength="400" size="100"  disabled="disabled"  alt="" value="00308307" ><xsl:if test="boolean(./*[name() = 'Obec_ICO']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'Obec_ICO']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'Obec_ICO']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "IČO: 00308307" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48472" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_DIC"  style="width:150px;"><xsl:text disable-output-escaping="yes">DIČ: 2021102853 </xsl:text> </label><span class="fieldContent" style="display: none"><input id="Obec_DIC" name="Obec_DIC" title="" type="text" class="xsd_string textBox "  maxlength="400" size="100"  disabled="disabled"  alt="" value="2021102853" ><xsl:if test="boolean(./*[name() = 'Obec_DIC']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'Obec_DIC']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'Obec_DIC']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "DIČ: 2021102853" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48470" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_Email"  style="width:150px;"><xsl:text disable-output-escaping="yes">E-mail: info@nitra.sk </xsl:text> </label><span class="fieldContent" style="display: none"><input id="Obec_Email" name="Obec_Email" title="" type="text" class="xsd_string textBox "  maxlength="400" size="100"  disabled="disabled"  alt="" value="info@nitra.sk" ><xsl:if test="boolean(./*[name() = 'Obec_Email']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'Obec_Email']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'Obec_Email']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "E-mail: info@nitra.sk" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaHeader">		
		<div id="layoutRow9893" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="sekciaHeader" />
				<div id="layoutRowContentlayoutRow9893" class="columns">
				
				<div id="layoutColumn18621" class="column first" >
											
<div id="layoutCell48474" class="cell  VecNazovFrm" >		
			
		<span class="fieldLabel" title=""   style="width:850px;"><xsl:text disable-output-escaping="yes">Ohlásenie k miestnemu poplatku za komunálne odpady a drobné stavebné odpady pre vlastníka resp. užívateľa nehnuteľnosti určenej na bývanie </xsl:text>  </span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson">		
		<div id="layoutRow9897" class="layoutRow ui-tabs ui-widget-content   NezobrazovatInfoIkonuRemoteLookup "   title="" >
						<input type="hidden" name="sekciaZiadatelFO_PhysicalPerson" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Meno a priezvisko užívateľa resp. vlastníka nehnuteľnosti určenej na bývanie - (FO):">Meno a priezvisko užívateľa resp. vlastníka nehnuteľnosti určenej na bývanie - (FO):			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9897" class="columns">
				
				<div id="layoutColumn18626" class="column first" >
											
<div id="layoutCell48494" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail">		
		<div id="layoutRow9899" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="sekciaZiadatelFODetail" />
				<div id="layoutRowContentlayoutRow9899" class="columns">
				
				<div id="layoutColumn18630" class="column first"  style="width:400px;">
											
<div id="layoutCell48496" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailTitulPred_PrefixQualificationAffix"  style="width:125px;"><xsl:text disable-output-escaping="yes">Titul pred menom </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFODetailTitulPred_PrefixQualificationAffix" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFODetailTitulPred_PrefixQualificationAffix" class="xsd_string remoteLookup ZiadatelFODetailTitulPred_PrefixQualificationAffix_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODetailTitulPred_PrefixQualificationAffix']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODetailTitulPred_PrefixQualificationAffix']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODetailTitulPred_PrefixQualificationAffix']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulPred_PrefixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0062</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Titul pred menom" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulPred_PrefixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0062</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48497" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailMeno_GivenName"  style="width:125px;"><xsl:text disable-output-escaping="yes">Meno </xsl:text> <em>*</em></label><span class="fieldContent"><input id="ZiadatelFODetailMeno_GivenName" name="ZiadatelFODetailMeno_GivenName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODetailMeno_GivenName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODetailMeno_GivenName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODetailMeno_GivenName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Meno" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48498" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailRC"  style="width:125px;"><xsl:text disable-output-escaping="yes">Rodné číslo </xsl:text> <em>*</em></label><span class="fieldContent"><input id="ZiadatelFODetailRC" name="ZiadatelFODetailRC" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODetailRC']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODetailRC']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODetailRC']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Rodné číslo" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18631" class="column "  style="width:400px;">
											
<div id="layoutCell48500" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailTitulZa_PostfixQualificationAffix"  style="width:125px;"><xsl:text disable-output-escaping="yes">Titul za menom </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFODetailTitulZa_PostfixQualificationAffix" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFODetailTitulZa_PostfixQualificationAffix" class="xsd_string remoteLookup ZiadatelFODetailTitulZa_PostfixQualificationAffix_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODetailTitulZa_PostfixQualificationAffix']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODetailTitulZa_PostfixQualificationAffix']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODetailTitulZa_PostfixQualificationAffix']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulZa_PostfixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0063</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Titul za menom" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulZa_PostfixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0063</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48499" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailPriezvisko_FamilyName"  style="width:125px;"><xsl:text disable-output-escaping="yes">Priezvisko </xsl:text> <em>*</em></label><span class="fieldContent"><input id="ZiadatelFODetailPriezvisko_FamilyName" name="ZiadatelFODetailPriezvisko_FamilyName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODetailPriezvisko_FamilyName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODetailPriezvisko_FamilyName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODetailPriezvisko_FamilyName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Priezvisko" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48501" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailDatumNarodenia_DateOfBirth"  style="width:125px;"><xsl:text disable-output-escaping="yes">Dátum narodenia </xsl:text> </label><span class="fieldContent"><input alt="" id="ZiadatelFODetailDatumNarodenia_DateOfBirth" name="ZiadatelFODetailDatumNarodenia_DateOfBirth" title="" type="text" class="xsd_string date datepicker " value="" maxlength="14" size="160"  disabled="disabled"  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODetailDatumNarodenia_DateOfBirth']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODetailDatumNarodenia_DateOfBirth']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODetailDatumNarodenia_DateOfBirth']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Dátum narodenia" hodnotu v tvare "deň.mesiac.rok" ("DD.MM.RRRR") alebo vyberte z ponuky.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48502" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress">		
		<div id="layoutRow9900" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa trvalého pobytu">Adresa trvalého pobytu			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9900" class="columns">
				
				<div id="layoutColumn18632" class="column first"  style="width:290px;">
											
<div id="layoutCell48503" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaStat_Country"  style="width:45px;"><xsl:text disable-output-escaping="yes">Štát </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOTrvalyPobytAdresaStat_Country" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFOTrvalyPobytAdresaStat_Country" class="xsd_string remoteLookup ZiadatelFOTrvalyPobytAdresaStat_Country_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaStat_Country']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaStat_Country']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaStat_Country']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48504" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaObec_Municipality"  style="width:45px;"><xsl:text disable-output-escaping="yes">Obec </xsl:text> <em>*</em></label><div class="fieldContent">
<input id="ZiadatelFOTrvalyPobytAdresaObec_Municipality" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFOTrvalyPobytAdresaObec_Municipality" class="xsd_string remoteLookup ZiadatelFOTrvalyPobytAdresaObec_Municipality_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaObec_Municipality']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaObec_Municipality']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaObec_Municipality']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48505" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaUlica_StreetName"  style="width:45px;"><xsl:text disable-output-escaping="yes">Ulica </xsl:text> <em>*</em></label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaUlica_StreetName" name="ZiadatelFOTrvalyPobytAdresaUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaUlica_StreetName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaUlica_StreetName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaUlica_StreetName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18633" class="column "  style="width:280px;">
											
<div id="layoutCell48507" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaKraj_Region"  style="width:20px;"><xsl:text disable-output-escaping="yes">Kraj </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOTrvalyPobytAdresaKraj_Region" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFOTrvalyPobytAdresaKraj_Region" class="xsd_string remoteLookup ZiadatelFOTrvalyPobytAdresaKraj_Region_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaKraj_Region']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaKraj_Region']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaKraj_Region']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48508" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaCastObce_District"  style="width:60px;"><xsl:text disable-output-escaping="yes">Časť obce </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaCastObce_District" name="ZiadatelFOTrvalyPobytAdresaCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="150"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaCastObce_District']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaCastObce_District']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaCastObce_District']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48506" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber"  style="width:60px;"><xsl:text disable-output-escaping="yes">Súp.č. </xsl:text> <em>*</em></label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber" name="ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18634" class="column "  style="width:280px;">
											
<div id="layoutCell48510" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaOkres_County"  style="width:20px;"><xsl:text disable-output-escaping="yes">Okres </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOTrvalyPobytAdresaOkres_County" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFOTrvalyPobytAdresaOkres_County" class="xsd_string remoteLookup ZiadatelFOTrvalyPobytAdresaOkres_County_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaOkres_County']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaOkres_County']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaOkres_County']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48511" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaPSC_PostalCode"  style="width:20px;"><xsl:text disable-output-escaping="yes">PSČ </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaPSC_PostalCode" name="ZiadatelFOTrvalyPobytAdresaPSC_PostalCode" title="" type="text" class="xsd_string textBox ZiadatelFOTrvalyPobytAdresaPSC_PostalCode_internal"  maxlength="6" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaPSC_PostalCode']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaPSC_PostalCode']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaPSC_PostalCode']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48509" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber"  style="width:20px;"><xsl:text disable-output-escaping="yes">Or.č. </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber" name="ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber" title="" type="text" class="xsd_string textBox ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber_internal"  maxlength="400" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48515" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa">		
		<div id="layoutRow9902" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaZiadatelFOPrechodnyPobytAdresa" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9902" class="columns">
				
				<div id="layoutColumn18637" class="column first"  style="width:290px;">
											
<div id="layoutCell48516" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaStat_Country"  style="width:45px;"><xsl:text disable-output-escaping="yes">Štát </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOPrechodnyPobytAdresaStat_Country" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFOPrechodnyPobytAdresaStat_Country" class="xsd_string remoteLookup ZiadatelFOPrechodnyPobytAdresaStat_Country_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaStat_Country']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaStat_Country']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaStat_Country']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48517" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaObec_Municipality"  style="width:45px;"><xsl:text disable-output-escaping="yes">Obec </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOPrechodnyPobytAdresaObec_Municipality" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFOPrechodnyPobytAdresaObec_Municipality" class="xsd_string remoteLookup ZiadatelFOPrechodnyPobytAdresaObec_Municipality_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaObec_Municipality']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaObec_Municipality']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaObec_Municipality']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48518" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaUlica_StreetName"  style="width:45px;"><xsl:text disable-output-escaping="yes">Ulica </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaUlica_StreetName" name="ZiadatelFOPrechodnyPobytAdresaUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaUlica_StreetName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaUlica_StreetName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaUlica_StreetName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18638" class="column "  style="width:280px;">
											
<div id="layoutCell48519" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaKraj_Region"  style="width:20px;"><xsl:text disable-output-escaping="yes">Kraj </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOPrechodnyPobytAdresaKraj_Region" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFOPrechodnyPobytAdresaKraj_Region" class="xsd_string remoteLookup ZiadatelFOPrechodnyPobytAdresaKraj_Region_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaKraj_Region']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaKraj_Region']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaKraj_Region']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48520" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaCastObce_District"  style="width:60px;"><xsl:text disable-output-escaping="yes">Časť obce </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaCastObce_District" name="ZiadatelFOPrechodnyPobytAdresaCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaCastObce_District']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaCastObce_District']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaCastObce_District']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48521" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber"  style="width:60px;"><xsl:text disable-output-escaping="yes">Súp.č. </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber" name="ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18639" class="column "  style="width:280px;">
											
<div id="layoutCell48523" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaOkres_County"  style="width:20px;"><xsl:text disable-output-escaping="yes">Okres </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOPrechodnyPobytAdresaOkres_County" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFOPrechodnyPobytAdresaOkres_County" class="xsd_string remoteLookup ZiadatelFOPrechodnyPobytAdresaOkres_County_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaOkres_County']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaOkres_County']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaOkres_County']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48524" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode"  style="width:20px;"><xsl:text disable-output-escaping="yes">PSČ </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode" name="ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode" title="" type="text" class="xsd_string textBox ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode_internal"  maxlength="5" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48522" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber"  style="width:20px;"><xsl:text disable-output-escaping="yes">Or.č. </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber" name="ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber" title="" type="text" class="xsd_string textBox ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber_internal"  maxlength="400" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
					<div id="repetitionCommandslayoutRow9902" class="sectionPager">
						<xsl:if test="position() != last()"><xsl:attribute name="style"><xsl:text>display:none;</xsl:text></xsl:attribute></xsl:if>
							</div>
			</div>	
			</xsl:for-each>	
			
		<xsl:if test="normalize-space(/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa) = ''">
						<xsl:if test="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/@notInFormData">
				<script type="text/javascript">$(document).ready(function () { initRepetitionSection(0, 1, 'layoutRow9902') })</script>
					</xsl:if>
				    </xsl:if>
		
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48484" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress">		
		<div id="layoutRow9898" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaZiadatelFODorucenieAdresa_DeliveryAddress" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9898" class="columns">
				
				<div id="layoutColumn18627" class="column first"  style="width:290px;">
											
<div id="layoutCell48485" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaStat_Country"  style="width:45px;"><xsl:text disable-output-escaping="yes">Štát </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFODorucenieAdresaStat_Country" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFODorucenieAdresaStat_Country" class="xsd_string remoteLookup ZiadatelFODorucenieAdresaStat_Country_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaStat_Country']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaStat_Country']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaStat_Country']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48486" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaObec_Municipality"  style="width:45px;"><xsl:text disable-output-escaping="yes">Obec </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFODorucenieAdresaObec_Municipality" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFODorucenieAdresaObec_Municipality" class="xsd_string remoteLookup ZiadatelFODorucenieAdresaObec_Municipality_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaObec_Municipality']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaObec_Municipality']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaObec_Municipality']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48487" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaUlica_StreetName"  style="width:45px;"><xsl:text disable-output-escaping="yes">Ulica </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaUlica_StreetName" name="ZiadatelFODorucenieAdresaUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaUlica_StreetName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaUlica_StreetName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaUlica_StreetName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18628" class="column "  style="width:280px;">
											
<div id="layoutCell48488" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaKraj_Region"  style="width:20px;"><xsl:text disable-output-escaping="yes">Kraj </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFODorucenieAdresaKraj_Region" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFODorucenieAdresaKraj_Region" class="xsd_string remoteLookup ZiadatelFODorucenieAdresaKraj_Region_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaKraj_Region']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaKraj_Region']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaKraj_Region']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48489" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaCastObce_District"  style="width:60px;"><xsl:text disable-output-escaping="yes">Časť obce </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaCastObce_District" name="ZiadatelFODorucenieAdresaCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaCastObce_District']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaCastObce_District']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaCastObce_District']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48490" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber"  style="width:60px;"><xsl:text disable-output-escaping="yes">Súp.č. </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber" name="ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18629" class="column "  style="width:280px;">
											
<div id="layoutCell48492" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaOkres_County"  style="width:20px;"><xsl:text disable-output-escaping="yes">Okres </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFODorucenieAdresaOkres_County" type="text"  disabled="disabled"  value="" alt="" name="ZiadatelFODorucenieAdresaOkres_County" class="xsd_string remoteLookup ZiadatelFODorucenieAdresaOkres_County_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaOkres_County']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaOkres_County']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaOkres_County']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48493" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaPSC_PostalCode"  style="width:20px;"><xsl:text disable-output-escaping="yes">PSČ </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaPSC_PostalCode" name="ZiadatelFODorucenieAdresaPSC_PostalCode" title="" type="text" class="xsd_string textBox ZiadatelFODorucenieAdresaPSC_PostalCode_internal"  maxlength="5" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaPSC_PostalCode']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaPSC_PostalCode']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaPSC_PostalCode']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48491" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaOrC_BuildingNumber"  style="width:20px;"><xsl:text disable-output-escaping="yes">Or.č. </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaOrC_BuildingNumber" name="ZiadatelFODorucenieAdresaOrC_BuildingNumber" title="" type="text" class="xsd_string textBox ZiadatelFODorucenieAdresaOrC_BuildingNumber_internal"  maxlength="400" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaOrC_BuildingNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaOrC_BuildingNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaOrC_BuildingNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
					<div id="repetitionCommandslayoutRow9898" class="sectionPager">
						<xsl:if test="position() != last()"><xsl:attribute name="style"><xsl:text>display:none;</xsl:text></xsl:attribute></xsl:if>
							</div>
			</div>	
			</xsl:for-each>	
			
		<xsl:if test="normalize-space(/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress) = ''">
						<xsl:if test="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/@notInFormData">
				<script type="text/javascript">$(document).ready(function () { initRepetitionSection(0, 1, 'layoutRow9898') })</script>
					</xsl:if>
				    </xsl:if>
		
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell67219" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOKontakt">		
		<div id="layoutRow13986" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaZiadatelFOKontakt" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Kontakt">Kontakt			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow13986" class="columns">
				
				<div id="layoutColumn26417" class="column first"  style="width:400px;">
											
<div id="layoutCell67220" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOKontaktTelCislo_TelephoneAddress"  style="width:125px;"><xsl:text disable-output-escaping="yes">Telefónne číslo </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOKontaktTelCislo_TelephoneAddress" name="ZiadatelFOKontaktTelCislo_TelephoneAddress" title="" type="text" class="xsd_string textBox "  maxlength="400" size="100"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOKontaktTelCislo_TelephoneAddress']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOKontaktTelCislo_TelephoneAddress']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOKontaktTelCislo_TelephoneAddress']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Telefónne číslo" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn26418" class="column "  style="width:400px;">
											
<div id="layoutCell67221" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOKontaktEmailAdresa"  style="width:120px;"><xsl:text disable-output-escaping="yes">E-mailová adresa </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOKontaktEmailAdresa" name="ZiadatelFOKontaktEmailAdresa" title="" type="text" class="xsd_string textBox ZiadatelFOKontaktEmailAdresa_internal"  maxlength="400" size="220"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOKontaktEmailAdresa']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOKontaktEmailAdresa']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOKontaktEmailAdresa']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "E-mailová adresa" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaNehnutelnost">		
		<div id="layoutRow5343" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaNehnutelnost" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Nehnuteľnosť">Nehnuteľnosť			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow5343" class="columns">
				
				<div id="layoutColumn9892" class="column first" >
											
<div id="layoutCell48536" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress">		
		<div id="layoutRow9905" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa nehnuteľnosti">Adresa nehnuteľnosti			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9905" class="columns">
				
				<div id="layoutColumn18644" class="column first"  style="width:290px;">
											
<div id="layoutCell48537" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiStat_Country"  style="width:45px;"><xsl:text disable-output-escaping="yes">Štát </xsl:text> </label><div class="fieldContent">
<input id="NehnutelnostAdresaNehnutelnostiStat_Country" type="text"  disabled="disabled"  value="" alt="" name="NehnutelnostAdresaNehnutelnostiStat_Country" class="xsd_string remoteLookup NehnutelnostAdresaNehnutelnostiStat_Country_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiStat_Country']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiStat_Country']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiStat_Country']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48538" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiObec_Municipality"  style="width:45px;"><xsl:text disable-output-escaping="yes">Obec </xsl:text> <em>*</em></label><div class="fieldContent">
<input id="NehnutelnostAdresaNehnutelnostiObec_Municipality" type="text"  disabled="disabled"  value="" alt="" name="NehnutelnostAdresaNehnutelnostiObec_Municipality" class="xsd_string remoteLookup NehnutelnostAdresaNehnutelnostiObec_Municipality_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiObec_Municipality']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiObec_Municipality']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiObec_Municipality']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48539" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiUlica_StreetName"  style="width:45px;"><xsl:text disable-output-escaping="yes">Ulica </xsl:text> <em>*</em></label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiUlica_StreetName" name="NehnutelnostAdresaNehnutelnostiUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiUlica_StreetName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiUlica_StreetName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiUlica_StreetName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18645" class="column "  style="width:280px;">
											
<div id="layoutCell48541" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiKraj_Region"  style="width:20px;"><xsl:text disable-output-escaping="yes">Kraj </xsl:text> </label><div class="fieldContent">
<input id="NehnutelnostAdresaNehnutelnostiKraj_Region" type="text"  disabled="disabled"  value="" alt="" name="NehnutelnostAdresaNehnutelnostiKraj_Region" class="xsd_string remoteLookup NehnutelnostAdresaNehnutelnostiKraj_Region_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiKraj_Region']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiKraj_Region']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiKraj_Region']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48542" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiCastObce_District"  style="width:60px;"><xsl:text disable-output-escaping="yes">Časť obce </xsl:text> </label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiCastObce_District" name="NehnutelnostAdresaNehnutelnostiCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="150"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiCastObce_District']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiCastObce_District']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiCastObce_District']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48540" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber"  style="width:60px;"><xsl:text disable-output-escaping="yes">Súp.č. </xsl:text> <em>*</em></label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber" name="NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18646" class="column "  style="width:280px;">
											
<div id="layoutCell48544" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiOkres_County"  style="width:20px;"><xsl:text disable-output-escaping="yes">Okres </xsl:text> </label><div class="fieldContent">
<input id="NehnutelnostAdresaNehnutelnostiOkres_County" type="text"  disabled="disabled"  value="" alt="" name="NehnutelnostAdresaNehnutelnostiOkres_County" class="xsd_string remoteLookup NehnutelnostAdresaNehnutelnostiOkres_County_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiOkres_County']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiOkres_County']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiOkres_County']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48545" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiPSC_PostalCode"  style="width:20px;"><xsl:text disable-output-escaping="yes">PSČ </xsl:text> </label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiPSC_PostalCode" name="NehnutelnostAdresaNehnutelnostiPSC_PostalCode" title="" type="text" class="xsd_string textBox NehnutelnostAdresaNehnutelnostiPSC_PostalCode_internal"  maxlength="6" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiPSC_PostalCode']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiPSC_PostalCode']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiPSC_PostalCode']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48543" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber"  style="width:20px;"><xsl:text disable-output-escaping="yes">Or.č. </xsl:text> </label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber" name="NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber" title="" type="text" class="xsd_string textBox NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber_internal"  maxlength="400" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce">		
		<div id="layoutRow3122" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="sekciaOsobyUzivajuce" />
				<div id="layoutRowContentlayoutRow3122" class="columns">
				
				<div id="layoutColumn5795" class="column first" >
											
<div id="layoutCell14386" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajucePocet">		
		<div id="layoutRow3121" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaOsobyUzivajucePocet" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Počet osôb užívajúcich nehnuteľnosť">Počet osôb užívajúcich nehnuteľnosť			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow3121" class="columns">
				
				<div id="layoutColumn5794" class="column first" >
											
<div id="layoutCell14384" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajucePocet"  style="width:900px;"><xsl:text disable-output-escaping="yes">Počet osôb, ktoré využívajú nehnuteľnosť, resp. majú prihlásený trvalý alebo prechodný pobyt, majú právo užívať nehnuteľnosť na uvedenej adrese </xsl:text> <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajucePocet" name="OsobyUzivajucePocet" title="" type="text" class="xsd_integer textBox " maxlength="400" size="190"  disabled="disabled"  alt="" value="0" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajucePocet']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajucePocet']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajucePocet']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Počet osôb, ktoré využívajú ne" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell14387" class="cell " >		
			 
			<xsl:for-each select="./egonp:sekciaOsobyUzivajuceZoznam">		
		<div id="layoutRow3123" class="layoutRow ui-tabs ui-widget-content   "   title="" >
				
				<xsl:variable name= "nRowslayoutRow3123" select="position()"/>
		<xsl:attribute name="id">layoutRow3123<xsl:if test="position() > 1"><xsl:text>_Repeating_</xsl:text><xsl:value-of select="position()-1"/></xsl:if></xsl:attribute>
		<xsl:attribute name="class">layoutRow ui-tabs ui-widget-content   <xsl:if test="position() > 1"><xsl:text> repeatingSection</xsl:text></xsl:if></xsl:attribute>
				<input type="hidden" name="sekciaOsobyUzivajuceZoznam" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Prihlásená osoba">Prihlásená osoba			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow3123" class="columns">
				
				<div id="layoutColumn5796" class="column first"  style="width:220px;">
											
<div id="layoutCell22555" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamMeno_GivenName" ><xsl:text disable-output-escaping="yes">Meno </xsl:text> <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajuceZoznamMeno_GivenName" name="OsobyUzivajuceZoznamMeno_GivenName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamMeno_GivenName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamMeno_GivenName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamMeno_GivenName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Meno" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn5797" class="column "  style="width:220px;">
											
<div id="layoutCell22558" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamPriezvisko_FamilyName" ><xsl:text disable-output-escaping="yes">Priezvisko </xsl:text> <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajuceZoznamPriezvisko_FamilyName" name="OsobyUzivajuceZoznamPriezvisko_FamilyName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamPriezvisko_FamilyName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamPriezvisko_FamilyName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamPriezvisko_FamilyName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Priezvisko" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn5798" class="column "  style="width:220px;">
											
<div id="layoutCell22559" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamMeno_DateOfBirth" ><xsl:text disable-output-escaping="yes">Dátum narodenia </xsl:text> </label><span class="fieldContent"><input alt="" id="OsobyUzivajuceZoznamMeno_DateOfBirth" name="OsobyUzivajuceZoznamMeno_DateOfBirth" title="" type="text" class="xsd_string date datepicker " value="" maxlength="14" size="160"  disabled="disabled"  ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamMeno_DateOfBirth']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamMeno_DateOfBirth']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamMeno_DateOfBirth']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Dátum narodenia" hodnotu v tvare "deň.mesiac.rok" ("DD.MM.RRRR") alebo vyberte z ponuky.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn5799" class="column "  style="width:150px;">
											
<div id="layoutCell22560" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTypPobytu" ><xsl:text disable-output-escaping="yes">Označenie pobytu </xsl:text> <em>*</em></label><span class="fieldContent"><select id="OsobyUzivajuceZoznamTypPobytu" name="OsobyUzivajuceZoznamTypPobytu" class="xsd_string comboBox " title=""  disabled="disabled"  ><option value=""></option><option value="TP" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTypPobytu']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTypPobytu']='TP'"><xsl:attribute name="selected">selected</xsl:attribute></xsl:if>Trval&#253;</option><option value="PP" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTypPobytu']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTypPobytu']='PP'"><xsl:attribute name="selected">selected</xsl:attribute></xsl:if>Prechodn&#253;</option><option value="U" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTypPobytu']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTypPobytu']='U'"><xsl:attribute name="selected">selected</xsl:attribute></xsl:if>Už&#237;vateľ</option><option value="PU" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTypPobytu']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTypPobytu']='PU'"><xsl:attribute name="selected">selected</xsl:attribute></xsl:if>Pr&#225;vo už&#237;vať</option></select><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Označenie pobytu" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18640" class="column " >
											
<div id="layoutCell48526" class="cell " >		
			 
			<xsl:for-each select="./egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress">		
		<div id="layoutRow9904" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa trvalého pobytu">Adresa trvalého pobytu			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9904" class="columns">
				
				<div id="layoutColumn18641" class="column first"  style="width:290px;">
											
<div id="layoutCell48527" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country"  style="width:45px;"><xsl:text disable-output-escaping="yes">Štát </xsl:text> </label><div class="fieldContent">
<input id="OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country" type="text"  disabled="disabled"  value="" alt="" name="OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country" class="xsd_string remoteLookup OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48528" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality"  style="width:45px;"><xsl:text disable-output-escaping="yes">Obec </xsl:text> <em>*</em></label><div class="fieldContent">
<input id="OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality" type="text"  disabled="disabled"  value="" alt="" name="OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality" class="xsd_string remoteLookup OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48529" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName"  style="width:45px;"><xsl:text disable-output-escaping="yes">Ulica </xsl:text> <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName" name="OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18642" class="column "  style="width:280px;">
											
<div id="layoutCell48531" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region"  style="width:20px;"><xsl:text disable-output-escaping="yes">Kraj </xsl:text> </label><div class="fieldContent">
<input id="OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region" type="text"  disabled="disabled"  value="" alt="" name="OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region" class="xsd_string remoteLookup OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48532" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District"  style="width:60px;"><xsl:text disable-output-escaping="yes">Časť obce </xsl:text> </label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District" name="OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="150"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48530" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber"  style="width:60px;"><xsl:text disable-output-escaping="yes">Súp.č. </xsl:text> <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber" name="OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18643" class="column "  style="width:280px;">
											
<div id="layoutCell48534" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County"  style="width:20px;"><xsl:text disable-output-escaping="yes">Okres </xsl:text> </label><div class="fieldContent">
<input id="OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County" type="text"  disabled="disabled"  value="" alt="" name="OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County" class="xsd_string remoteLookup OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48535" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode"  style="width:20px;"><xsl:text disable-output-escaping="yes">PSČ </xsl:text> </label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode" name="OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode" title="" type="text" class="xsd_string textBox OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode_internal"  maxlength="6" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48533" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber"  style="width:20px;"><xsl:text disable-output-escaping="yes">Or.č. </xsl:text> </label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber" name="OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber" title="" type="text" class="xsd_string textBox OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber_internal"  maxlength="400" size="50"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
					<div id="repetitionCommandslayoutRow3123" class="sectionPager">
						<xsl:if test="position() != last()"><xsl:attribute name="style"><xsl:text>display:none;</xsl:text></xsl:attribute></xsl:if>
							</div>
			</div>	
			</xsl:for-each>	
			
		<xsl:if test="normalize-space(./egonp:sekciaOsobyUzivajuceZoznam) = ''">
						<xsl:if test="./egonp:sekciaOsobyUzivajuceZoznam/@notInFormData">
				<script type="text/javascript">$(document).ready(function () { initRepetitionSection(1, 10, 'layoutRow3123') })</script>
					</xsl:if>
				    </xsl:if>
		
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:SekciaOchranaOsobnychUdajov">		
		<div id="layoutRow9894" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="SekciaOchranaOsobnychUdajov" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Ochrana osobných údajov">Ochrana osobných údajov			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9894" class="columns">
				
				<div id="layoutColumn18622" class="column first" >
											
<div id="layoutCell48476" class="cell " >		
			
		<input id="OchranaOsobnychUdajovSuhlas" name="OchranaOsobnychUdajovSuhlas" title="" type="checkbox" class="xsd_boolean checkBox " value="Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona." alt=""  disabled="disabled"   ><xsl:if test="boolean(./*[name() = 'OchranaOsobnychUdajovSuhlas']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OchranaOsobnychUdajovSuhlas']='1'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="OchranaOsobnychUdajovSuhlas" class="checkBoxLabel">Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona.</label><br />
	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaNotifikacie">		
		<div id="layoutRow9895" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaNotifikacie" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Notifikácie">Notifikácie			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9895" class="columns">
				
				<div id="layoutColumn18623" class="column first"  style="width:550px;">
											
<div id="layoutCell48478" class="cell " >		
			
		<span class="fieldLabel" title=""  ><xsl:text disable-output-escaping="yes">Zasielanie upozornení </xsl:text>  <div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Vyberte jednu z možností.</span></p></p></div></div></span><fieldset><legend></legend><div class="xsd_string radioButtonList "><span><input id="NotifikacieZasielanie" name="NotifikacieZasielanie" class="xsd_string radioButtonList " title="" type="radio" alt="1" value="1"   disabled="disabled"  ><xsl:attribute name="name">NotifikacieZasielanie</xsl:attribute><xsl:if test="boolean(./*[name() = 'NotifikacieZasielanie']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NotifikacieZasielanie']='1'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="NotifikacieZasielanie" class="optionLabel">Žiadne</label></span><span><input id="NotifikacieZasielaniePostfixList1" name="NotifikacieZasielanie" class="xsd_string radioButtonList " title="" type="radio" alt="2" value="2"   disabled="disabled"  ><xsl:attribute name="name">NotifikacieZasielanie</xsl:attribute><xsl:if test="boolean(./*[name() = 'NotifikacieZasielanie']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NotifikacieZasielanie']='2'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="NotifikacieZasielaniePostfixList1" class="optionLabel">eDesk</label></span><span><input id="NotifikacieZasielaniePostfixList2" name="NotifikacieZasielanie" class="xsd_string radioButtonList " title="" type="radio" alt="3" value="3"   disabled="disabled"  ><xsl:attribute name="name">NotifikacieZasielanie</xsl:attribute><xsl:if test="boolean(./*[name() = 'NotifikacieZasielanie']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NotifikacieZasielanie']='3'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="NotifikacieZasielaniePostfixList2" class="optionLabel">SMS</label></span><span><input id="NotifikacieZasielaniePostfixList3" name="NotifikacieZasielanie" class="xsd_string radioButtonList " title="" type="radio" alt="4" value="4"   disabled="disabled"  ><xsl:attribute name="name">NotifikacieZasielanie</xsl:attribute><xsl:if test="boolean(./*[name() = 'NotifikacieZasielanie']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NotifikacieZasielanie']='4'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="NotifikacieZasielaniePostfixList3" class="optionLabel">E-mail</label></span></div></fieldset>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18624" class="column "  style="width:300px;">
											
<div id="layoutCell48479" class="cell " >		
			
		<label class="fieldLabel" title="" for="NotifikacieKontakt"  style="width:70px;"><xsl:text disable-output-escaping="yes">Kontakt </xsl:text> </label><span class="fieldContent"><input id="NotifikacieKontakt" name="NotifikacieKontakt" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'NotifikacieKontakt']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NotifikacieKontakt']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NotifikacieKontakt']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kontakt" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaSposobDoruceniaVystupu">		
		<div id="layoutRow14230" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaSposobDoruceniaVystupu" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Spôsob doručenia výstupu">Spôsob doručenia výstupu			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow14230" class="columns">
				
				<div id="layoutColumn26874" class="column first"  style="width:300px;">
											
<div id="layoutCell67920" class="cell " >		
			
		<span class="fieldLabel" title=""  ><xsl:text disable-output-escaping="yes">Spôsob doručenia výstupu </xsl:text>  <div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Vyberte jednu z možností.</span></p></p></div></div></span><fieldset><legend></legend><div class="xsd_string radioButtonList "><span><input id="SposobDoruceniaVystupuTyp" name="SposobDoruceniaVystupuTyp" class="xsd_string radioButtonList " title="" type="radio" alt="eDesk" value="eDesk"   disabled="disabled"  ><xsl:attribute name="name">SposobDoruceniaVystupuTyp</xsl:attribute><xsl:if test="boolean(./*[name() = 'SposobDoruceniaVystupuTyp']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'SposobDoruceniaVystupuTyp']='eDesk'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="SposobDoruceniaVystupuTyp" class="optionLabel">eDesk</label></span><span><input id="SposobDoruceniaVystupuTypPostfixList1" name="SposobDoruceniaVystupuTyp" class="xsd_string radioButtonList " title="" type="radio" alt="osobne" value="osobne"   disabled="disabled"  ><xsl:attribute name="name">SposobDoruceniaVystupuTyp</xsl:attribute><xsl:if test="boolean(./*[name() = 'SposobDoruceniaVystupuTyp']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'SposobDoruceniaVystupuTyp']='osobne'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="SposobDoruceniaVystupuTypPostfixList1" class="optionLabel">osobne</label></span><span><input id="SposobDoruceniaVystupuTypPostfixList2" name="SposobDoruceniaVystupuTyp" class="xsd_string radioButtonList " title="" type="radio" alt="poštou" value="poštou"   disabled="disabled"  ><xsl:attribute name="name">SposobDoruceniaVystupuTyp</xsl:attribute><xsl:if test="boolean(./*[name() = 'SposobDoruceniaVystupuTyp']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'SposobDoruceniaVystupuTyp']='poštou'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="SposobDoruceniaVystupuTypPostfixList2" class="optionLabel">poštou</label></span></div></fieldset>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn26875" class="column "  style="width:550px;">
											
<div id="layoutCell67921" class="cell " >		
			
		<label class="fieldLabel" title="" for="SposobDoruceniaVystupuKontakt"  style="width:270px;"><xsl:text disable-output-escaping="yes">Kontakt v prípade doručenia osobne / poštou </xsl:text> </label><span class="fieldContent"><input id="SposobDoruceniaVystupuKontakt" name="SposobDoruceniaVystupuKontakt" title="" type="text" class="xsd_string textBox SposobDoruceniaVystupuKontakt_internal"  maxlength="400" size="210"  disabled="disabled"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'SposobDoruceniaVystupuKontakt']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'SposobDoruceniaVystupuKontakt']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'SposobDoruceniaVystupuKontakt']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kontakt v prípade doručenia os" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaFooter">		
		<div id="layoutRow9896" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="sekciaFooter" />
				<div id="layoutRowContentlayoutRow9896" class="columns">
				
				<div id="layoutColumn18625" class="column first" >
											
<div id="layoutCell48481" class="cell " >		
			
		<span class="fieldContent"><a href="http://www.nitra.sk" class="xsd_string hyperLink " target="_blank" >Copyright © 2015, Mesto Nitra - Všetky práva vyhradené</a>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48482" class="cell " >		
			
		<span class="fieldLabel" title=""   style="width:400px;"><xsl:text disable-output-escaping="yes">NITRA je moderné a otvorené mesto pre všetkých </xsl:text>  </span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
			<div id="buttonsPlaceholder">
								<input id="cancelForm" type="button" class="button ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only" value="Zrušiť"  alt="Zrušiť" accesskey="Z" />			
			</div>		
		</div>
		<div id="statusDialog" title="Status">
			<img id="statusLoader" src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Images/ajax-loader.png" alt="Čakajte prosím" />
			<p id="statusMessage" class="statusMessage"></p>
		</div>
		<div id="savedFormsContainer" class="layoutMain ui-widget-content" style="display:none">
		  <div id="savedFormsContainerRow" class="layoutRow ui-tabs ui-widget-content"  title="" >
			<input type="hidden" name="Basic" />
			<div class="caption ui-widget-header">
			  <div class="headercorrection" title="Uložené formuláre">Uložené formuláre</div>
			  <span class="arrow ui-icon ui-icon-carat-1-n"></span>
			</div>
			<div id="layoutRowSavedForms" class="columns">
			  <div id="lcolumnSavedForms" class="column first" >
				<div id="lcellSavedForms" class="cell">          				  
				</div>				
			  </div>
			  <div class="clear"> </div>
			</div>
		  </div>
		</div>
		<div id="mtd_formMetaData" style="display:none"><span id="mtd_version">1.1</span><span id="mtd_idp">2149</span><span id="mtd_namespace">http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1</span></div>
	</form>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

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
PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz48TWFwcGluZ0RhdGE+PE4yRSAvPjwvTWFwcGluZ0RhdGE+
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE xsl:stylesheet [ <!ENTITY nbsp "&#xa0;">]>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"  xmlns:egonp="http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1" exclude-result-prefixes="egonp"> 
<xsl:output method="html" doctype-system="http://www.w3.org/TR/html4/loose.dtd" doctype-public="-//W3C//DTD HTML 4.01 Transitional//EN" indent="no" omit-xml-declaration="yes"/>
<xsl:template match="/">
<html>
	<head>
	<meta http-equiv="X-UA-Compatible" content="IE=edge" />
	<title>001.Ohlásenie k miestnemu poplatku za komunálne odpady a drobné stavebné odpady</title>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
	<meta name="language" content="sk-SK" />
		<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/jquery-ui.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/jquery.multiselect.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/jquery.multiselect.filter.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/base.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/ego.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/treeselect.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/chosentree.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/p_upvs.css" rel="stylesheet" type="text/css"/>
	<link href="https://fonts.googleapis.com/css?family=Open+Sans:300,400,400italic,bold,600&amp;subset=latin,latin-ext" rel="stylesheet" type="text/css" />
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery-migrate.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.mask.min.js" type="text/javascript"></script>	
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery-ui.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.dataTables.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery-ui-timepicker-addon.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.multiselect.filter.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.multiselect.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.validate.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.validate.customRules.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/ego.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.form.plugins.js" type="text/javascript"></script>			
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/ego.statusDialog.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.chosentree.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.treeselect.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/fillerSaver.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/wrapper.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/p_upvs.js" type="text/javascript"></script>
		<script type="text/javascript">
		var projectType = 'UPVS';
		
					<xsl:text disable-output-escaping="yes">
					/* <![CDATA[ */
		
		
		
		
		function GetExternalResourceIndex(resourcetype) {
  switch (resourcetype) {
    default:
      return null;
  }
  return null;
}
function GetExternalResource(resourcetype, index) {
  switch (resourcetype) {
    default:
      return null;
  }
  return null;
}

		function SetDefaultValue(key, value) {
  if (value == '' || key == '') {
    return;
	}
}
function GetDefaultValue() {
  var retString = '';
  return retString;
}

				function InitConditionalRules(context, sid) {
			if (sid == null) {

			$(document).ready(function () {
$("[id|='OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode']").mask("Y999 99", {'translation': { Y: {pattern: /[+,-]/, optional: true} }});
$("[id|='NehnutelnostAdresaNehnutelnostiPSC_PostalCode']").mask("Y999 99", {'translation': { Y: {pattern: /[+,-]/, optional: true} }});
$("[id|='ZiadatelFOTrvalyPobytAdresaPSC_PostalCode']").mask("Y999 99", {'translation': { Y: {pattern: /[+,-]/, optional: true} }});
});

			
			
			
			
			}
		}
						

		var validatorObject = null;
		
		function InitValidation() {
			validatorObject = $("#eForm_eGov_001").validate({
							errorLabelContainer: $("#errorsContainer"),
				wrapper: "li",
				onkeyup: false,
				onclick: false,
		        ignore: ".disableValidators",
								rules: {
			  		OsobyUzivajucePocet :
{
required: true
},

OsobyUzivajuceZoznamMeno_GivenName :
{
required: true
},

OsobyUzivajuceZoznamPriezvisko_FamilyName :
{
required: true
},


OsobyUzivajuceZoznamTypPobytu :
{
required: true
},


OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality :
{
required: true
},

OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName :
{
required: true
},

OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber :
{
required: true
},





OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode :
{
maxlength: 6
},


NehnutelnostAdresaNehnutelnostiObec_Municipality :
{
required: true
},

NehnutelnostAdresaNehnutelnostiUlica_StreetName :
{
required: true
},

NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber :
{
required: true
},





NehnutelnostAdresaNehnutelnostiPSC_PostalCode :
{
maxlength: 6
},









OchranaOsobnychUdajovSuhlas :
{
required: true
},













ZiadatelFODorucenieAdresaPSC_PostalCode :
{
maxlength: 5
},


ZiadatelFODetailMeno_GivenName :
{
required: true
},

ZiadatelFODetailRC :
{
required: true
},

ZiadatelFODetailPriezvisko_FamilyName :
{
required: true
},




ZiadatelFOTrvalyPobytAdresaObec_Municipality :
{
required: true
},

ZiadatelFOTrvalyPobytAdresaUlica_StreetName :
{
required: true
},

ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber :
{
required: true
},





ZiadatelFOTrvalyPobytAdresaPSC_PostalCode :
{
maxlength: 6
},









ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode :
{
maxlength: 5
}
			  	},
				messages: {			
			   		OsobyUzivajucePocet :
{
required: "Položka 'Počet osôb, ktoré využívajú nehnuteľnosť, resp. majú prihlásený trvalý alebo prechodný pobyt, majú právo užívať nehnuteľnosť na uvedenej adrese' musí byť vyplnená"
},

OsobyUzivajuceZoznamMeno_GivenName :
{
required: "Položka 'Meno' musí byť vyplnená"
},

OsobyUzivajuceZoznamPriezvisko_FamilyName :
{
required: "Položka 'Priezvisko' musí byť vyplnená"
},

OsobyUzivajuceZoznamMeno_DateOfBirth :
{
date: "Položka 'Dátum narodenia' má neplatný formát"
},

OsobyUzivajuceZoznamTypPobytu :
{
required: "Položka 'Označenie pobytu' musí byť vyplnená"
},


OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality :
{
required: "Položka 'Obec' musí byť vyplnená"
},

OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName :
{
required: "Položka 'Ulica' musí byť vyplnená"
},

OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber :
{
required: "Položka 'Súp.č.' musí byť vyplnená"
},





OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 6 znakov"
},


NehnutelnostAdresaNehnutelnostiObec_Municipality :
{
required: "Položka 'Obec' musí byť vyplnená"
},

NehnutelnostAdresaNehnutelnostiUlica_StreetName :
{
required: "Položka 'Ulica' musí byť vyplnená"
},

NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber :
{
required: "Položka 'Súp.č.' musí byť vyplnená"
},





NehnutelnostAdresaNehnutelnostiPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 6 znakov"
},









OchranaOsobnychUdajovSuhlas :
{
required: "Položka 'Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona.' musí byť vyplnená"
},













ZiadatelFODorucenieAdresaPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 5 znakov"
},


ZiadatelFODetailMeno_GivenName :
{
required: "Položka 'Meno' musí byť vyplnená"
},

ZiadatelFODetailRC :
{
required: "Položka 'Rodné číslo' musí byť vyplnená"
},

ZiadatelFODetailPriezvisko_FamilyName :
{
required: "Položka 'Priezvisko' musí byť vyplnená"
},


ZiadatelFODetailDatumNarodenia_DateOfBirth :
{
date: "Položka 'Dátum narodenia' má neplatný formát"
},


ZiadatelFOTrvalyPobytAdresaObec_Municipality :
{
required: "Položka 'Obec' musí byť vyplnená"
},

ZiadatelFOTrvalyPobytAdresaUlica_StreetName :
{
required: "Položka 'Ulica' musí byť vyplnená"
},

ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber :
{
required: "Položka 'Súp.č.' musí byť vyplnená"
},





ZiadatelFOTrvalyPobytAdresaPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 6 znakov"
},









ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 5 znakov"
}	  	
			  	}
			});
	  	}
	/* ]]> */
					</xsl:text>
			</script>
	<style type="text/css">
		.infoIcon {display:none;}
.logo img {width:100px; height:120px;}
.LabelBold{font-weight: bold;}
.VecNazovFrm {font-size:26px;font-weight:bold;text-align: center;text-transform: uppercase;}
.OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country_internal{width:110px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality_internal{width:110px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber_internal{width:50px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region_internal{width:110px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber_internal{width:50px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County_internal{width:110px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode_internal{width:50px;}.NehnutelnostAdresaNehnutelnostiStat_Country_internal{width:110px;}.NehnutelnostAdresaNehnutelnostiObec_Municipality_internal{width:110px;}.NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber_internal{width:50px;}.NehnutelnostAdresaNehnutelnostiKraj_Region_internal{width:110px;}.NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber_internal{width:50px;}.NehnutelnostAdresaNehnutelnostiOkres_County_internal{width:110px;}.NehnutelnostAdresaNehnutelnostiPSC_PostalCode_internal{width:50px;}.HeaderNazov_internal{width:500px;}.ZiadatelFODorucenieAdresaStat_Country_internal{width:110px;}.ZiadatelFODorucenieAdresaObec_Municipality_internal{width:110px;}.ZiadatelFODorucenieAdresaKraj_Region_internal{width:110px;}.ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber_internal{width:50px;}.ZiadatelFODorucenieAdresaOrC_BuildingNumber_internal{width:50px;}.ZiadatelFODorucenieAdresaOkres_County_internal{width:110px;}.ZiadatelFODorucenieAdresaPSC_PostalCode_internal{width:50px;}.ZiadatelFODetailTitulPred_PrefixQualificationAffix_internal{width:60px;}.ZiadatelFODetailTitulZa_PostfixQualificationAffix_internal{width:60px;}.ZiadatelFOTrvalyPobytAdresaStat_Country_internal{width:110px;}.ZiadatelFOTrvalyPobytAdresaObec_Municipality_internal{width:110px;}.ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber_internal{width:50px;}.ZiadatelFOTrvalyPobytAdresaKraj_Region_internal{width:110px;}.ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber_internal{width:50px;}.ZiadatelFOTrvalyPobytAdresaOkres_County_internal{width:110px;}.ZiadatelFOTrvalyPobytAdresaPSC_PostalCode_internal{width:50px;}.ZiadatelFOPrechodnyPobytAdresaStat_Country_internal{width:110px;}.ZiadatelFOPrechodnyPobytAdresaObec_Municipality_internal{width:110px;}.ZiadatelFOPrechodnyPobytAdresaKraj_Region_internal{width:110px;}.ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber_internal{width:50px;}.ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber_internal{width:50px;}.ZiadatelFOPrechodnyPobytAdresaOkres_County_internal{width:110px;}.ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode_internal{width:50px;}.ZiadatelFOKontaktEmailAdresa_internal{width:220px;}.SposobDoruceniaVystupuKontakt_internal{width:210px;}
	</style>
</head>
<body>
	<noscript><p class="noscript">Pre kompletnú funkčnosť aplikácie je potrebné povoliť JavaScript</p></noscript>
	<div id="errorsContainerDiv" class="errorsContainerDiv"> <ul id="errorsContainer" class="errorsContainer"><li/></ul> </div>
	<form id="eForm_eGov_001" action="">
		<div id="main" class="layoutMain ui-widget-content">	
						 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:SekciaObec">		
		<div id="layoutRow9892" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="SekciaObec" />
				<div id="layoutRowContentlayoutRow9892" class="columns">
				
				<div id="layoutColumn18618" class="column first"  style="width:150px;">
											
<div id="layoutCell48466" class="cell  logo" >		
			
		<span class="fieldContent" style="display: none"><img src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Images/Logo" alt="" title=""/></span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18619" class="column "  style="width:500px;">
											
<div id="layoutCell48467" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_MsU"  style="width:450px;"><xsl:text disable-output-escaping="yes">Mesto Nitra: Mestský úrad Nitra, Štefánikova trieda 60, 950 06 Nitra </xsl:text> </label><span class="fieldContent" style="display: none"><input id="Obec_MsU" name="Obec_MsU" title="" type="text" class="xsd_string textBox "  maxlength="400" size="340"  alt="" value="Mestský úrad Nitra, Štefánikova trieda 60, 950 06 Nitra" ><xsl:if test="boolean(./*[name() = 'Obec_MsU']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'Obec_MsU']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'Obec_MsU']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Mesto Nitra: Mestský úrad Nitr" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48468" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_Telefon"  style="width:250px;"><xsl:text disable-output-escaping="yes">Telefón: 037/65 02 111 </xsl:text> </label><span class="fieldContent" style="display: none"><input id="Obec_Telefon" name="Obec_Telefon" title="" type="text" class="xsd_string textBox "  maxlength="400" size="150"  alt="" value="037/65 02 111" ><xsl:if test="boolean(./*[name() = 'Obec_Telefon']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'Obec_Telefon']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'Obec_Telefon']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Telefón: 037/65 02 111" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48469" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_BankoveSpojenie"  style="width:290px;"><xsl:text disable-output-escaping="yes">IBAN: SK0409000000005028001139 </xsl:text> </label><span class="fieldContent" style="display: none"><input id="Obec_BankoveSpojenie" name="Obec_BankoveSpojenie" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="SK0409000000005028001139" ><xsl:if test="boolean(./*[name() = 'Obec_BankoveSpojenie']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'Obec_BankoveSpojenie']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'Obec_BankoveSpojenie']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "IBAN: SK0409000000005028001139" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18620" class="column "  style="width:150px;">
											
<div id="layoutCell48471" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_ICO"  style="width:150px;"><xsl:text disable-output-escaping="yes">IČO: 00308307 </xsl:text> </label><span class="fieldContent" style="display: none"><input id="Obec_ICO" name="Obec_ICO" title="" type="text" class="xsd_string textBox "  maxlength="400" size="100"  alt="" value="00308307" ><xsl:if test="boolean(./*[name() = 'Obec_ICO']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'Obec_ICO']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'Obec_ICO']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "IČO: 00308307" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48472" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_DIC"  style="width:150px;"><xsl:text disable-output-escaping="yes">DIČ: 2021102853 </xsl:text> </label><span class="fieldContent" style="display: none"><input id="Obec_DIC" name="Obec_DIC" title="" type="text" class="xsd_string textBox "  maxlength="400" size="100"  alt="" value="2021102853" ><xsl:if test="boolean(./*[name() = 'Obec_DIC']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'Obec_DIC']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'Obec_DIC']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "DIČ: 2021102853" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48470" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_Email"  style="width:150px;"><xsl:text disable-output-escaping="yes">E-mail: info@nitra.sk </xsl:text> </label><span class="fieldContent" style="display: none"><input id="Obec_Email" name="Obec_Email" title="" type="text" class="xsd_string textBox "  maxlength="400" size="100"  alt="" value="info@nitra.sk" ><xsl:if test="boolean(./*[name() = 'Obec_Email']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'Obec_Email']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'Obec_Email']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "E-mail: info@nitra.sk" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaHeader">		
		<div id="layoutRow9893" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="sekciaHeader" />
				<div id="layoutRowContentlayoutRow9893" class="columns">
				
				<div id="layoutColumn18621" class="column first" >
											
<div id="layoutCell48474" class="cell  VecNazovFrm" >		
			
		<span class="fieldLabel" title=""   style="width:850px;"><xsl:text disable-output-escaping="yes">Ohlásenie k miestnemu poplatku za komunálne odpady a drobné stavebné odpady pre vlastníka resp. užívateľa nehnuteľnosti určenej na bývanie </xsl:text>  </span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson">		
		<div id="layoutRow9897" class="layoutRow ui-tabs ui-widget-content   NezobrazovatInfoIkonuRemoteLookup "   title="" >
						<input type="hidden" name="sekciaZiadatelFO_PhysicalPerson" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Meno a priezvisko užívateľa resp. vlastníka nehnuteľnosti určenej na bývanie - (FO):">Meno a priezvisko užívateľa resp. vlastníka nehnuteľnosti určenej na bývanie - (FO):			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9897" class="columns">
				
				<div id="layoutColumn18626" class="column first" >
											
<div id="layoutCell48494" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail">		
		<div id="layoutRow9899" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="sekciaZiadatelFODetail" />
				<div id="layoutRowContentlayoutRow9899" class="columns">
				
				<div id="layoutColumn18630" class="column first"  style="width:400px;">
											
<div id="layoutCell48496" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailTitulPred_PrefixQualificationAffix"  style="width:125px;"><xsl:text disable-output-escaping="yes">Titul pred menom </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFODetailTitulPred_PrefixQualificationAffix" type="text"  value="" alt="" name="ZiadatelFODetailTitulPred_PrefixQualificationAffix" class="xsd_string remoteLookup ZiadatelFODetailTitulPred_PrefixQualificationAffix_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODetailTitulPred_PrefixQualificationAffix']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODetailTitulPred_PrefixQualificationAffix']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODetailTitulPred_PrefixQualificationAffix']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulPred_PrefixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0062</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Titul pred menom" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulPred_PrefixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0062</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulPred_PrefixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0062</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48497" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailMeno_GivenName"  style="width:125px;"><xsl:text disable-output-escaping="yes">Meno </xsl:text> <em>*</em></label><span class="fieldContent"><input id="ZiadatelFODetailMeno_GivenName" name="ZiadatelFODetailMeno_GivenName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODetailMeno_GivenName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODetailMeno_GivenName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODetailMeno_GivenName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Meno" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48498" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailRC"  style="width:125px;"><xsl:text disable-output-escaping="yes">Rodné číslo </xsl:text> <em>*</em></label><span class="fieldContent"><input id="ZiadatelFODetailRC" name="ZiadatelFODetailRC" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODetailRC']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODetailRC']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODetailRC']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Rodné číslo" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18631" class="column "  style="width:400px;">
											
<div id="layoutCell48500" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailTitulZa_PostfixQualificationAffix"  style="width:125px;"><xsl:text disable-output-escaping="yes">Titul za menom </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFODetailTitulZa_PostfixQualificationAffix" type="text"  value="" alt="" name="ZiadatelFODetailTitulZa_PostfixQualificationAffix" class="xsd_string remoteLookup ZiadatelFODetailTitulZa_PostfixQualificationAffix_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODetailTitulZa_PostfixQualificationAffix']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODetailTitulZa_PostfixQualificationAffix']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODetailTitulZa_PostfixQualificationAffix']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulZa_PostfixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0063</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Titul za menom" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulZa_PostfixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0063</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulZa_PostfixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0063</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48499" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailPriezvisko_FamilyName"  style="width:125px;"><xsl:text disable-output-escaping="yes">Priezvisko </xsl:text> <em>*</em></label><span class="fieldContent"><input id="ZiadatelFODetailPriezvisko_FamilyName" name="ZiadatelFODetailPriezvisko_FamilyName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODetailPriezvisko_FamilyName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODetailPriezvisko_FamilyName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODetailPriezvisko_FamilyName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Priezvisko" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48501" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailDatumNarodenia_DateOfBirth"  style="width:125px;"><xsl:text disable-output-escaping="yes">Dátum narodenia </xsl:text> </label><span class="fieldContent"><input alt="" id="ZiadatelFODetailDatumNarodenia_DateOfBirth" name="ZiadatelFODetailDatumNarodenia_DateOfBirth" title="" type="text" class="xsd_string date datepicker " value="" maxlength="14" size="160"  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODetailDatumNarodenia_DateOfBirth']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODetailDatumNarodenia_DateOfBirth']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODetailDatumNarodenia_DateOfBirth']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Dátum narodenia" hodnotu v tvare "deň.mesiac.rok" ("DD.MM.RRRR") alebo vyberte z ponuky.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48502" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress">		
		<div id="layoutRow9900" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa trvalého pobytu">Adresa trvalého pobytu			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9900" class="columns">
				
				<div id="layoutColumn18632" class="column first"  style="width:290px;">
											
<div id="layoutCell48503" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaStat_Country"  style="width:45px;"><xsl:text disable-output-escaping="yes">Štát </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOTrvalyPobytAdresaStat_Country" type="text"  value="" alt="" name="ZiadatelFOTrvalyPobytAdresaStat_Country" class="xsd_string remoteLookup ZiadatelFOTrvalyPobytAdresaStat_Country_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaStat_Country']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaStat_Country']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaStat_Country']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48504" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaObec_Municipality"  style="width:45px;"><xsl:text disable-output-escaping="yes">Obec </xsl:text> <em>*</em></label><div class="fieldContent">
<input id="ZiadatelFOTrvalyPobytAdresaObec_Municipality" type="text"  value="" alt="" name="ZiadatelFOTrvalyPobytAdresaObec_Municipality" class="xsd_string remoteLookup ZiadatelFOTrvalyPobytAdresaObec_Municipality_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaObec_Municipality']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaObec_Municipality']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaObec_Municipality']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48505" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaUlica_StreetName"  style="width:45px;"><xsl:text disable-output-escaping="yes">Ulica </xsl:text> <em>*</em></label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaUlica_StreetName" name="ZiadatelFOTrvalyPobytAdresaUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaUlica_StreetName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaUlica_StreetName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaUlica_StreetName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18633" class="column "  style="width:280px;">
											
<div id="layoutCell48507" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaKraj_Region"  style="width:20px;"><xsl:text disable-output-escaping="yes">Kraj </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOTrvalyPobytAdresaKraj_Region" type="text"  value="" alt="" name="ZiadatelFOTrvalyPobytAdresaKraj_Region" class="xsd_string remoteLookup ZiadatelFOTrvalyPobytAdresaKraj_Region_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaKraj_Region']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaKraj_Region']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaKraj_Region']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48508" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaCastObce_District"  style="width:60px;"><xsl:text disable-output-escaping="yes">Časť obce </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaCastObce_District" name="ZiadatelFOTrvalyPobytAdresaCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="150"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaCastObce_District']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaCastObce_District']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaCastObce_District']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48506" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber"  style="width:60px;"><xsl:text disable-output-escaping="yes">Súp.č. </xsl:text> <em>*</em></label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber" name="ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18634" class="column "  style="width:280px;">
											
<div id="layoutCell48510" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaOkres_County"  style="width:20px;"><xsl:text disable-output-escaping="yes">Okres </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOTrvalyPobytAdresaOkres_County" type="text"  value="" alt="" name="ZiadatelFOTrvalyPobytAdresaOkres_County" class="xsd_string remoteLookup ZiadatelFOTrvalyPobytAdresaOkres_County_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaOkres_County']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaOkres_County']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaOkres_County']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48511" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaPSC_PostalCode"  style="width:20px;"><xsl:text disable-output-escaping="yes">PSČ </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaPSC_PostalCode" name="ZiadatelFOTrvalyPobytAdresaPSC_PostalCode" title="" type="text" class="xsd_string textBox ZiadatelFOTrvalyPobytAdresaPSC_PostalCode_internal"  maxlength="6" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaPSC_PostalCode']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaPSC_PostalCode']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaPSC_PostalCode']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48509" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber"  style="width:20px;"><xsl:text disable-output-escaping="yes">Or.č. </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber" name="ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber" title="" type="text" class="xsd_string textBox ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber_internal"  maxlength="400" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48515" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa">		
		<div id="layoutRow9902" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaZiadatelFOPrechodnyPobytAdresa" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9902" class="columns">
				
				<div id="layoutColumn18637" class="column first"  style="width:290px;">
											
<div id="layoutCell48516" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaStat_Country"  style="width:45px;"><xsl:text disable-output-escaping="yes">Štát </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOPrechodnyPobytAdresaStat_Country" type="text"  value="" alt="" name="ZiadatelFOPrechodnyPobytAdresaStat_Country" class="xsd_string remoteLookup ZiadatelFOPrechodnyPobytAdresaStat_Country_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaStat_Country']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaStat_Country']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaStat_Country']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48517" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaObec_Municipality"  style="width:45px;"><xsl:text disable-output-escaping="yes">Obec </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOPrechodnyPobytAdresaObec_Municipality" type="text"  value="" alt="" name="ZiadatelFOPrechodnyPobytAdresaObec_Municipality" class="xsd_string remoteLookup ZiadatelFOPrechodnyPobytAdresaObec_Municipality_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaObec_Municipality']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaObec_Municipality']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaObec_Municipality']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48518" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaUlica_StreetName"  style="width:45px;"><xsl:text disable-output-escaping="yes">Ulica </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaUlica_StreetName" name="ZiadatelFOPrechodnyPobytAdresaUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaUlica_StreetName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaUlica_StreetName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaUlica_StreetName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18638" class="column "  style="width:280px;">
											
<div id="layoutCell48519" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaKraj_Region"  style="width:20px;"><xsl:text disable-output-escaping="yes">Kraj </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOPrechodnyPobytAdresaKraj_Region" type="text"  value="" alt="" name="ZiadatelFOPrechodnyPobytAdresaKraj_Region" class="xsd_string remoteLookup ZiadatelFOPrechodnyPobytAdresaKraj_Region_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaKraj_Region']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaKraj_Region']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaKraj_Region']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48520" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaCastObce_District"  style="width:60px;"><xsl:text disable-output-escaping="yes">Časť obce </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaCastObce_District" name="ZiadatelFOPrechodnyPobytAdresaCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaCastObce_District']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaCastObce_District']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaCastObce_District']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48521" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber"  style="width:60px;"><xsl:text disable-output-escaping="yes">Súp.č. </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber" name="ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18639" class="column "  style="width:280px;">
											
<div id="layoutCell48523" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaOkres_County"  style="width:20px;"><xsl:text disable-output-escaping="yes">Okres </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFOPrechodnyPobytAdresaOkres_County" type="text"  value="" alt="" name="ZiadatelFOPrechodnyPobytAdresaOkres_County" class="xsd_string remoteLookup ZiadatelFOPrechodnyPobytAdresaOkres_County_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaOkres_County']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaOkres_County']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaOkres_County']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48524" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode"  style="width:20px;"><xsl:text disable-output-escaping="yes">PSČ </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode" name="ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode" title="" type="text" class="xsd_string textBox ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode_internal"  maxlength="5" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48522" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber"  style="width:20px;"><xsl:text disable-output-escaping="yes">Or.č. </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber" name="ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber" title="" type="text" class="xsd_string textBox ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber_internal"  maxlength="400" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
					<div id="repetitionCommandslayoutRow9902" class="sectionPager">
						<xsl:if test="position() != last()"><xsl:attribute name="style"><xsl:text>display:none;</xsl:text></xsl:attribute></xsl:if>
								<span id="addSectionlayoutRow9902" class="button addRemoveSection" onclick="addSection(0, 1, this)" title="Pridať sekciu Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Pridať</span>
				<span id="removeSectionlayoutRow9902" class="button addRemoveSection" onclick="removeSection(0, this)" title="Odobrať sekciu Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Odobrať</span>	
			</div>
			</div>	
			</xsl:for-each>	
			
		<xsl:if test="normalize-space(/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa) = ''">
						<xsl:if test="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/@notInFormData">
				<script type="text/javascript">$(document).ready(function () { initRepetitionSection(0, 1, 'layoutRow9902') })</script>
					</xsl:if>
				    </xsl:if>
		
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48484" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress">		
		<div id="layoutRow9898" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaZiadatelFODorucenieAdresa_DeliveryAddress" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9898" class="columns">
				
				<div id="layoutColumn18627" class="column first"  style="width:290px;">
											
<div id="layoutCell48485" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaStat_Country"  style="width:45px;"><xsl:text disable-output-escaping="yes">Štát </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFODorucenieAdresaStat_Country" type="text"  value="" alt="" name="ZiadatelFODorucenieAdresaStat_Country" class="xsd_string remoteLookup ZiadatelFODorucenieAdresaStat_Country_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaStat_Country']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaStat_Country']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaStat_Country']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48486" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaObec_Municipality"  style="width:45px;"><xsl:text disable-output-escaping="yes">Obec </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFODorucenieAdresaObec_Municipality" type="text"  value="" alt="" name="ZiadatelFODorucenieAdresaObec_Municipality" class="xsd_string remoteLookup ZiadatelFODorucenieAdresaObec_Municipality_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaObec_Municipality']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaObec_Municipality']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaObec_Municipality']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48487" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaUlica_StreetName"  style="width:45px;"><xsl:text disable-output-escaping="yes">Ulica </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaUlica_StreetName" name="ZiadatelFODorucenieAdresaUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaUlica_StreetName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaUlica_StreetName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaUlica_StreetName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18628" class="column "  style="width:280px;">
											
<div id="layoutCell48488" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaKraj_Region"  style="width:20px;"><xsl:text disable-output-escaping="yes">Kraj </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFODorucenieAdresaKraj_Region" type="text"  value="" alt="" name="ZiadatelFODorucenieAdresaKraj_Region" class="xsd_string remoteLookup ZiadatelFODorucenieAdresaKraj_Region_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaKraj_Region']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaKraj_Region']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaKraj_Region']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48489" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaCastObce_District"  style="width:60px;"><xsl:text disable-output-escaping="yes">Časť obce </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaCastObce_District" name="ZiadatelFODorucenieAdresaCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaCastObce_District']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaCastObce_District']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaCastObce_District']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48490" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber"  style="width:60px;"><xsl:text disable-output-escaping="yes">Súp.č. </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber" name="ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18629" class="column "  style="width:280px;">
											
<div id="layoutCell48492" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaOkres_County"  style="width:20px;"><xsl:text disable-output-escaping="yes">Okres </xsl:text> </label><div class="fieldContent">
<input id="ZiadatelFODorucenieAdresaOkres_County" type="text"  value="" alt="" name="ZiadatelFODorucenieAdresaOkres_County" class="xsd_string remoteLookup ZiadatelFODorucenieAdresaOkres_County_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaOkres_County']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaOkres_County']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaOkres_County']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48493" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaPSC_PostalCode"  style="width:20px;"><xsl:text disable-output-escaping="yes">PSČ </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaPSC_PostalCode" name="ZiadatelFODorucenieAdresaPSC_PostalCode" title="" type="text" class="xsd_string textBox ZiadatelFODorucenieAdresaPSC_PostalCode_internal"  maxlength="5" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaPSC_PostalCode']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaPSC_PostalCode']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaPSC_PostalCode']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48491" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaOrC_BuildingNumber"  style="width:20px;"><xsl:text disable-output-escaping="yes">Or.č. </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaOrC_BuildingNumber" name="ZiadatelFODorucenieAdresaOrC_BuildingNumber" title="" type="text" class="xsd_string textBox ZiadatelFODorucenieAdresaOrC_BuildingNumber_internal"  maxlength="400" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFODorucenieAdresaOrC_BuildingNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFODorucenieAdresaOrC_BuildingNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFODorucenieAdresaOrC_BuildingNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
					<div id="repetitionCommandslayoutRow9898" class="sectionPager">
						<xsl:if test="position() != last()"><xsl:attribute name="style"><xsl:text>display:none;</xsl:text></xsl:attribute></xsl:if>
								<span id="addSectionlayoutRow9898" class="button addRemoveSection" onclick="addSection(0, 1, this)" title="Pridať sekciu Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Pridať</span>
				<span id="removeSectionlayoutRow9898" class="button addRemoveSection" onclick="removeSection(0, this)" title="Odobrať sekciu Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Odobrať</span>	
			</div>
			</div>	
			</xsl:for-each>	
			
		<xsl:if test="normalize-space(/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress) = ''">
						<xsl:if test="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/@notInFormData">
				<script type="text/javascript">$(document).ready(function () { initRepetitionSection(0, 1, 'layoutRow9898') })</script>
					</xsl:if>
				    </xsl:if>
		
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell67219" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOKontakt">		
		<div id="layoutRow13986" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaZiadatelFOKontakt" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Kontakt">Kontakt			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow13986" class="columns">
				
				<div id="layoutColumn26417" class="column first"  style="width:400px;">
											
<div id="layoutCell67220" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOKontaktTelCislo_TelephoneAddress"  style="width:125px;"><xsl:text disable-output-escaping="yes">Telefónne číslo </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOKontaktTelCislo_TelephoneAddress" name="ZiadatelFOKontaktTelCislo_TelephoneAddress" title="" type="text" class="xsd_string textBox "  maxlength="400" size="100"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOKontaktTelCislo_TelephoneAddress']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOKontaktTelCislo_TelephoneAddress']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOKontaktTelCislo_TelephoneAddress']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Telefónne číslo" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn26418" class="column "  style="width:400px;">
											
<div id="layoutCell67221" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOKontaktEmailAdresa"  style="width:120px;"><xsl:text disable-output-escaping="yes">E-mailová adresa </xsl:text> </label><span class="fieldContent"><input id="ZiadatelFOKontaktEmailAdresa" name="ZiadatelFOKontaktEmailAdresa" title="" type="text" class="xsd_string textBox ZiadatelFOKontaktEmailAdresa_internal"  maxlength="400" size="220"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'ZiadatelFOKontaktEmailAdresa']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'ZiadatelFOKontaktEmailAdresa']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'ZiadatelFOKontaktEmailAdresa']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "E-mailová adresa" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaNehnutelnost">		
		<div id="layoutRow5343" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaNehnutelnost" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Nehnuteľnosť">Nehnuteľnosť			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow5343" class="columns">
				
				<div id="layoutColumn9892" class="column first" >
											
<div id="layoutCell48536" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress">		
		<div id="layoutRow9905" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa nehnuteľnosti">Adresa nehnuteľnosti			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9905" class="columns">
				
				<div id="layoutColumn18644" class="column first"  style="width:290px;">
											
<div id="layoutCell48537" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiStat_Country"  style="width:45px;"><xsl:text disable-output-escaping="yes">Štát </xsl:text> </label><div class="fieldContent">
<input id="NehnutelnostAdresaNehnutelnostiStat_Country" type="text"  value="" alt="" name="NehnutelnostAdresaNehnutelnostiStat_Country" class="xsd_string remoteLookup NehnutelnostAdresaNehnutelnostiStat_Country_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiStat_Country']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiStat_Country']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiStat_Country']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48538" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiObec_Municipality"  style="width:45px;"><xsl:text disable-output-escaping="yes">Obec </xsl:text> <em>*</em></label><div class="fieldContent">
<input id="NehnutelnostAdresaNehnutelnostiObec_Municipality" type="text"  value="" alt="" name="NehnutelnostAdresaNehnutelnostiObec_Municipality" class="xsd_string remoteLookup NehnutelnostAdresaNehnutelnostiObec_Municipality_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiObec_Municipality']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiObec_Municipality']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiObec_Municipality']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48539" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiUlica_StreetName"  style="width:45px;"><xsl:text disable-output-escaping="yes">Ulica </xsl:text> <em>*</em></label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiUlica_StreetName" name="NehnutelnostAdresaNehnutelnostiUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiUlica_StreetName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiUlica_StreetName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiUlica_StreetName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18645" class="column "  style="width:280px;">
											
<div id="layoutCell48541" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiKraj_Region"  style="width:20px;"><xsl:text disable-output-escaping="yes">Kraj </xsl:text> </label><div class="fieldContent">
<input id="NehnutelnostAdresaNehnutelnostiKraj_Region" type="text"  value="" alt="" name="NehnutelnostAdresaNehnutelnostiKraj_Region" class="xsd_string remoteLookup NehnutelnostAdresaNehnutelnostiKraj_Region_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiKraj_Region']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiKraj_Region']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiKraj_Region']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48542" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiCastObce_District"  style="width:60px;"><xsl:text disable-output-escaping="yes">Časť obce </xsl:text> </label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiCastObce_District" name="NehnutelnostAdresaNehnutelnostiCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="150"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiCastObce_District']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiCastObce_District']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiCastObce_District']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48540" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber"  style="width:60px;"><xsl:text disable-output-escaping="yes">Súp.č. </xsl:text> <em>*</em></label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber" name="NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18646" class="column "  style="width:280px;">
											
<div id="layoutCell48544" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiOkres_County"  style="width:20px;"><xsl:text disable-output-escaping="yes">Okres </xsl:text> </label><div class="fieldContent">
<input id="NehnutelnostAdresaNehnutelnostiOkres_County" type="text"  value="" alt="" name="NehnutelnostAdresaNehnutelnostiOkres_County" class="xsd_string remoteLookup NehnutelnostAdresaNehnutelnostiOkres_County_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiOkres_County']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiOkres_County']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiOkres_County']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48545" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiPSC_PostalCode"  style="width:20px;"><xsl:text disable-output-escaping="yes">PSČ </xsl:text> </label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiPSC_PostalCode" name="NehnutelnostAdresaNehnutelnostiPSC_PostalCode" title="" type="text" class="xsd_string textBox NehnutelnostAdresaNehnutelnostiPSC_PostalCode_internal"  maxlength="6" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiPSC_PostalCode']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiPSC_PostalCode']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiPSC_PostalCode']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48543" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber"  style="width:20px;"><xsl:text disable-output-escaping="yes">Or.č. </xsl:text> </label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber" name="NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber" title="" type="text" class="xsd_string textBox NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber_internal"  maxlength="400" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce">		
		<div id="layoutRow3122" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="sekciaOsobyUzivajuce" />
				<div id="layoutRowContentlayoutRow3122" class="columns">
				
				<div id="layoutColumn5795" class="column first" >
											
<div id="layoutCell14386" class="cell " >		
			 
			<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajucePocet">		
		<div id="layoutRow3121" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaOsobyUzivajucePocet" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Počet osôb užívajúcich nehnuteľnosť">Počet osôb užívajúcich nehnuteľnosť			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow3121" class="columns">
				
				<div id="layoutColumn5794" class="column first" >
											
<div id="layoutCell14384" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajucePocet"  style="width:900px;"><xsl:text disable-output-escaping="yes">Počet osôb, ktoré využívajú nehnuteľnosť, resp. majú prihlásený trvalý alebo prechodný pobyt, majú právo užívať nehnuteľnosť na uvedenej adrese </xsl:text> <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajucePocet" name="OsobyUzivajucePocet" title="" type="text" class="xsd_integer textBox " maxlength="400" size="190"  alt="" value="0" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajucePocet']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajucePocet']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajucePocet']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Počet osôb, ktoré využívajú ne" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell14387" class="cell " >		
			 
			<xsl:for-each select="./egonp:sekciaOsobyUzivajuceZoznam">		
		<div id="layoutRow3123" class="layoutRow ui-tabs ui-widget-content   "   title="" >
				
				<xsl:variable name= "nRowslayoutRow3123" select="position()"/>
		<xsl:attribute name="id">layoutRow3123<xsl:if test="position() > 1"><xsl:text>_Repeating_</xsl:text><xsl:value-of select="position()-1"/></xsl:if></xsl:attribute>
		<xsl:attribute name="class">layoutRow ui-tabs ui-widget-content   <xsl:if test="position() > 1"><xsl:text> repeatingSection</xsl:text></xsl:if></xsl:attribute>
				<input type="hidden" name="sekciaOsobyUzivajuceZoznam" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Prihlásená osoba">Prihlásená osoba			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow3123" class="columns">
				
				<div id="layoutColumn5796" class="column first"  style="width:220px;">
											
<div id="layoutCell22555" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamMeno_GivenName" ><xsl:text disable-output-escaping="yes">Meno </xsl:text> <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajuceZoznamMeno_GivenName" name="OsobyUzivajuceZoznamMeno_GivenName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamMeno_GivenName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamMeno_GivenName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamMeno_GivenName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Meno" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn5797" class="column "  style="width:220px;">
											
<div id="layoutCell22558" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamPriezvisko_FamilyName" ><xsl:text disable-output-escaping="yes">Priezvisko </xsl:text> <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajuceZoznamPriezvisko_FamilyName" name="OsobyUzivajuceZoznamPriezvisko_FamilyName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamPriezvisko_FamilyName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamPriezvisko_FamilyName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamPriezvisko_FamilyName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Priezvisko" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn5798" class="column "  style="width:220px;">
											
<div id="layoutCell22559" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamMeno_DateOfBirth" ><xsl:text disable-output-escaping="yes">Dátum narodenia </xsl:text> </label><span class="fieldContent"><input alt="" id="OsobyUzivajuceZoznamMeno_DateOfBirth" name="OsobyUzivajuceZoznamMeno_DateOfBirth" title="" type="text" class="xsd_string date datepicker " value="" maxlength="14" size="160"  ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamMeno_DateOfBirth']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamMeno_DateOfBirth']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamMeno_DateOfBirth']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Dátum narodenia" hodnotu v tvare "deň.mesiac.rok" ("DD.MM.RRRR") alebo vyberte z ponuky.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn5799" class="column "  style="width:150px;">
											
<div id="layoutCell22560" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTypPobytu" ><xsl:text disable-output-escaping="yes">Označenie pobytu </xsl:text> <em>*</em></label><span class="fieldContent"><select id="OsobyUzivajuceZoznamTypPobytu" name="OsobyUzivajuceZoznamTypPobytu" class="xsd_string comboBox " title=""  ><option value=""></option><option value="TP" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTypPobytu']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTypPobytu']='TP'"><xsl:attribute name="selected">selected</xsl:attribute></xsl:if>Trval&#253;</option><option value="PP" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTypPobytu']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTypPobytu']='PP'"><xsl:attribute name="selected">selected</xsl:attribute></xsl:if>Prechodn&#253;</option><option value="U" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTypPobytu']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTypPobytu']='U'"><xsl:attribute name="selected">selected</xsl:attribute></xsl:if>Už&#237;vateľ</option><option value="PU" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTypPobytu']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTypPobytu']='PU'"><xsl:attribute name="selected">selected</xsl:attribute></xsl:if>Pr&#225;vo už&#237;vať</option></select><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Označenie pobytu" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18640" class="column " >
											
<div id="layoutCell48526" class="cell " >		
			 
			<xsl:for-each select="./egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress">		
		<div id="layoutRow9904" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa trvalého pobytu">Adresa trvalého pobytu			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9904" class="columns">
				
				<div id="layoutColumn18641" class="column first"  style="width:290px;">
											
<div id="layoutCell48527" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country"  style="width:45px;"><xsl:text disable-output-escaping="yes">Štát </xsl:text> </label><div class="fieldContent">
<input id="OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country" type="text"  value="" alt="" name="OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country" class="xsd_string remoteLookup OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48528" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality"  style="width:45px;"><xsl:text disable-output-escaping="yes">Obec </xsl:text> <em>*</em></label><div class="fieldContent">
<input id="OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality" type="text"  value="" alt="" name="OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality" class="xsd_string remoteLookup OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48529" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName"  style="width:45px;"><xsl:text disable-output-escaping="yes">Ulica </xsl:text> <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName" name="OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18642" class="column "  style="width:280px;">
											
<div id="layoutCell48531" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region"  style="width:20px;"><xsl:text disable-output-escaping="yes">Kraj </xsl:text> </label><div class="fieldContent">
<input id="OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region" type="text"  value="" alt="" name="OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region" class="xsd_string remoteLookup OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48532" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District"  style="width:60px;"><xsl:text disable-output-escaping="yes">Časť obce </xsl:text> </label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District" name="OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="150"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48530" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber"  style="width:60px;"><xsl:text disable-output-escaping="yes">Súp.č. </xsl:text> <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber" name="OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18643" class="column "  style="width:280px;">
											
<div id="layoutCell48534" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County"  style="width:20px;"><xsl:text disable-output-escaping="yes">Okres </xsl:text> </label><div class="fieldContent">
<input id="OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County" type="text"  value="" alt="" name="OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County" class="xsd_string remoteLookup OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County_internal textBox turned" title=""  ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County']"/></xsl:attribute></xsl:if></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48535" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode"  style="width:20px;"><xsl:text disable-output-escaping="yes">PSČ </xsl:text> </label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode" name="OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode" title="" type="text" class="xsd_string textBox OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode_internal"  maxlength="6" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48533" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber"  style="width:20px;"><xsl:text disable-output-escaping="yes">Or.č. </xsl:text> </label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber" name="OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber" title="" type="text" class="xsd_string textBox OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber_internal"  maxlength="400" size="50"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
					<div id="repetitionCommandslayoutRow3123" class="sectionPager">
						<xsl:if test="position() != last()"><xsl:attribute name="style"><xsl:text>display:none;</xsl:text></xsl:attribute></xsl:if>
								<span id="addSectionlayoutRow3123" class="button addRemoveSection" onclick="addSection(1, 10, this)" title="Pridať sekciu Prihlásená osoba">Pridať</span>
				<span id="removeSectionlayoutRow3123" class="button addRemoveSection" onclick="removeSection(1, this)" title="Odobrať sekciu Prihlásená osoba">Odobrať</span>	
			</div>
			</div>	
			</xsl:for-each>	
			
		<xsl:if test="normalize-space(./egonp:sekciaOsobyUzivajuceZoznam) = ''">
						<xsl:if test="./egonp:sekciaOsobyUzivajuceZoznam/@notInFormData">
				<script type="text/javascript">$(document).ready(function () { initRepetitionSection(1, 10, 'layoutRow3123') })</script>
					</xsl:if>
				    </xsl:if>
		
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:SekciaOchranaOsobnychUdajov">		
		<div id="layoutRow9894" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="SekciaOchranaOsobnychUdajov" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Ochrana osobných údajov">Ochrana osobných údajov			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9894" class="columns">
				
				<div id="layoutColumn18622" class="column first" >
											
<div id="layoutCell48476" class="cell " >		
			
		<input id="OchranaOsobnychUdajovSuhlas" name="OchranaOsobnychUdajovSuhlas" title="" type="checkbox" class="xsd_boolean checkBox " value="Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona." alt=""   ><xsl:if test="boolean(./*[name() = 'OchranaOsobnychUdajovSuhlas']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'OchranaOsobnychUdajovSuhlas']='1'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="OchranaOsobnychUdajovSuhlas" class="checkBoxLabel">Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona.</label><br />
	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaNotifikacie">		
		<div id="layoutRow9895" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaNotifikacie" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Notifikácie">Notifikácie			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9895" class="columns">
				
				<div id="layoutColumn18623" class="column first"  style="width:550px;">
											
<div id="layoutCell48478" class="cell " >		
			
		<span class="fieldLabel" title=""  ><xsl:text disable-output-escaping="yes">Zasielanie upozornení </xsl:text>  <div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Vyberte jednu z možností.</span></p></p></div></div></span><fieldset><legend></legend><div class="xsd_string radioButtonList "><span><input id="NotifikacieZasielanie" name="NotifikacieZasielanie" class="xsd_string radioButtonList " title="" type="radio" alt="1" value="1"   ><xsl:attribute name="name">NotifikacieZasielanie</xsl:attribute><xsl:if test="boolean(./*[name() = 'NotifikacieZasielanie']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NotifikacieZasielanie']='1'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="NotifikacieZasielanie" class="optionLabel">Žiadne</label></span><span><input id="NotifikacieZasielaniePostfixList1" name="NotifikacieZasielanie" class="xsd_string radioButtonList " title="" type="radio" alt="2" value="2"   ><xsl:attribute name="name">NotifikacieZasielanie</xsl:attribute><xsl:if test="boolean(./*[name() = 'NotifikacieZasielanie']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NotifikacieZasielanie']='2'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="NotifikacieZasielaniePostfixList1" class="optionLabel">eDesk</label></span><span><input id="NotifikacieZasielaniePostfixList2" name="NotifikacieZasielanie" class="xsd_string radioButtonList " title="" type="radio" alt="3" value="3"   ><xsl:attribute name="name">NotifikacieZasielanie</xsl:attribute><xsl:if test="boolean(./*[name() = 'NotifikacieZasielanie']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NotifikacieZasielanie']='3'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="NotifikacieZasielaniePostfixList2" class="optionLabel">SMS</label></span><span><input id="NotifikacieZasielaniePostfixList3" name="NotifikacieZasielanie" class="xsd_string radioButtonList " title="" type="radio" alt="4" value="4"   ><xsl:attribute name="name">NotifikacieZasielanie</xsl:attribute><xsl:if test="boolean(./*[name() = 'NotifikacieZasielanie']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NotifikacieZasielanie']='4'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="NotifikacieZasielaniePostfixList3" class="optionLabel">E-mail</label></span></div></fieldset>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18624" class="column "  style="width:300px;">
											
<div id="layoutCell48479" class="cell " >		
			
		<label class="fieldLabel" title="" for="NotifikacieKontakt"  style="width:70px;"><xsl:text disable-output-escaping="yes">Kontakt </xsl:text> </label><span class="fieldContent"><input id="NotifikacieKontakt" name="NotifikacieKontakt" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'NotifikacieKontakt']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'NotifikacieKontakt']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'NotifikacieKontakt']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kontakt" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaSposobDoruceniaVystupu">		
		<div id="layoutRow14230" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaSposobDoruceniaVystupu" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Spôsob doručenia výstupu">Spôsob doručenia výstupu			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow14230" class="columns">
				
				<div id="layoutColumn26874" class="column first"  style="width:300px;">
											
<div id="layoutCell67920" class="cell " >		
			
		<span class="fieldLabel" title=""  ><xsl:text disable-output-escaping="yes">Spôsob doručenia výstupu </xsl:text>  <div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Vyberte jednu z možností.</span></p></p></div></div></span><fieldset><legend></legend><div class="xsd_string radioButtonList "><span><input id="SposobDoruceniaVystupuTyp" name="SposobDoruceniaVystupuTyp" class="xsd_string radioButtonList " title="" type="radio" alt="eDesk" value="eDesk"   ><xsl:attribute name="name">SposobDoruceniaVystupuTyp</xsl:attribute><xsl:if test="boolean(./*[name() = 'SposobDoruceniaVystupuTyp']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'SposobDoruceniaVystupuTyp']='eDesk'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="SposobDoruceniaVystupuTyp" class="optionLabel">eDesk</label></span><span><input id="SposobDoruceniaVystupuTypPostfixList1" name="SposobDoruceniaVystupuTyp" class="xsd_string radioButtonList " title="" type="radio" alt="osobne" value="osobne"   ><xsl:attribute name="name">SposobDoruceniaVystupuTyp</xsl:attribute><xsl:if test="boolean(./*[name() = 'SposobDoruceniaVystupuTyp']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'SposobDoruceniaVystupuTyp']='osobne'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="SposobDoruceniaVystupuTypPostfixList1" class="optionLabel">osobne</label></span><span><input id="SposobDoruceniaVystupuTypPostfixList2" name="SposobDoruceniaVystupuTyp" class="xsd_string radioButtonList " title="" type="radio" alt="poštou" value="poštou"   ><xsl:attribute name="name">SposobDoruceniaVystupuTyp</xsl:attribute><xsl:if test="boolean(./*[name() = 'SposobDoruceniaVystupuTyp']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'SposobDoruceniaVystupuTyp']='poštou'"><xsl:attribute name="checked">checked</xsl:attribute></xsl:if></input><label for="SposobDoruceniaVystupuTypPostfixList2" class="optionLabel">poštou</label></span></div></fieldset>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn26875" class="column "  style="width:550px;">
											
<div id="layoutCell67921" class="cell " >		
			
		<label class="fieldLabel" title="" for="SposobDoruceniaVystupuKontakt"  style="width:270px;"><xsl:text disable-output-escaping="yes">Kontakt v prípade doručenia osobne / poštou </xsl:text> </label><span class="fieldContent"><input id="SposobDoruceniaVystupuKontakt" name="SposobDoruceniaVystupuKontakt" title="" type="text" class="xsd_string textBox SposobDoruceniaVystupuKontakt_internal"  maxlength="400" size="210"  alt="" value="" ><xsl:if test="boolean(./*[name() = 'SposobDoruceniaVystupuKontakt']/@isReadOnly = 'true')"><xsl:attribute name="readonly">readonly</xsl:attribute><xsl:attribute name="disabled">disabled</xsl:attribute></xsl:if><xsl:if test="./*[name() = 'SposobDoruceniaVystupuKontakt']"><xsl:attribute name="value"><xsl:value-of select="./*[name() = 'SposobDoruceniaVystupuKontakt']"/></xsl:attribute></xsl:if></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kontakt v prípade doručenia os" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
							<xsl:for-each select="/egonp:eForm_eGov_001/egonp:sekciaFooter">		
		<div id="layoutRow9896" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="sekciaFooter" />
				<div id="layoutRowContentlayoutRow9896" class="columns">
				
				<div id="layoutColumn18625" class="column first" >
											
<div id="layoutCell48481" class="cell " >		
			
		<span class="fieldContent"><a href="http://www.nitra.sk" class="xsd_string hyperLink " target="_blank" >Copyright © 2015, Mesto Nitra - Všetky práva vyhradené</a>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48482" class="cell " >		
			
		<span class="fieldLabel" title=""   style="width:400px;"><xsl:text disable-output-escaping="yes">NITRA je moderné a otvorené mesto pre všetkých </xsl:text>  </span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
			</xsl:for-each>	
					
			<div id="buttonsPlaceholder">
									<input id="validateForm" type="button" class="button ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only" value="Skontrolovať" alt="Skontrolovať" accesskey="S" />
										<input id="clearForm" type="button" class="button ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only" value="Vyčisti"  alt="Vyčisti" accesskey="V" />
					<input id="loadFormXml" type="button" class="button ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only" value="Načítať"  alt="Načítať" accesskey="N" />
					<input id="saveToXml" type="button" class="button ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only" value="Uložiť"  alt="Uložiť" accesskey="U" />
									<input id="cancelForm" type="button" class="button ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only" value="Zrušiť"  alt="Zrušiť" accesskey="Z" />			
			</div>		
		</div>
		<div id="statusDialog" title="Status">
			<img id="statusLoader" src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Images/ajax-loader.png" alt="Čakajte prosím" />
			<p id="statusMessage" class="statusMessage"></p>
		</div>
		<div id="savedFormsContainer" class="layoutMain ui-widget-content" style="display:none">
		  <div id="savedFormsContainerRow" class="layoutRow ui-tabs ui-widget-content"  title="" >
			<input type="hidden" name="Basic" />
			<div class="caption ui-widget-header">
			  <div class="headercorrection" title="Uložené formuláre">Uložené formuláre</div>
			  <span class="arrow ui-icon ui-icon-carat-1-n"></span>
			</div>
			<div id="layoutRowSavedForms" class="columns">
			  <div id="lcolumnSavedForms" class="column first" >
				<div id="lcellSavedForms" class="cell">          				  
				</div>				
			  </div>
			  <div class="clear"> </div>
			</div>
		  </div>
		</div>
		<div id="mtd_formMetaData" style="display:none"><span id="mtd_version">1.1</span><span id="mtd_idp">2149</span><span id="mtd_namespace">http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1</span></div>
	</form>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz48Q29tcGxldGVEaWN0aW9uYXJ5PjxNZXNzYWdlRGljdGlvbmFyeSAvPjxEZWZhdWx0c0RpY3Rpb25hcnkgLz48L0NvbXBsZXRlRGljdGlvbmFyeT4=
﻿<?xml version="1.0" encoding="UTF-8"?><eForm_eGov_001 xmlns="http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><SekciaObec><Obec_MsU>Mestský úrad Nitra, Štefánikova trieda 60, 950 06 Nitra</Obec_MsU><Obec_Telefon>037/65 02 111</Obec_Telefon><Obec_BankoveSpojenie>SK0409000000005028001139</Obec_BankoveSpojenie><Obec_ICO>00308307</Obec_ICO><Obec_DIC>2021102853</Obec_DIC><Obec_Email>info@nitra.sk</Obec_Email></SekciaObec><sekciaHeader></sekciaHeader><sekciaZiadatelFO_PhysicalPerson><sekciaZiadatelFODetail><ZiadatelFODetailTitulPred_PrefixQualificationAffix></ZiadatelFODetailTitulPred_PrefixQualificationAffix><ZiadatelFODetailMeno_GivenName></ZiadatelFODetailMeno_GivenName><ZiadatelFODetailRC></ZiadatelFODetailRC><ZiadatelFODetailTitulZa_PostfixQualificationAffix></ZiadatelFODetailTitulZa_PostfixQualificationAffix><ZiadatelFODetailPriezvisko_FamilyName></ZiadatelFODetailPriezvisko_FamilyName><ZiadatelFODetailDatumNarodenia_DateOfBirth></ZiadatelFODetailDatumNarodenia_DateOfBirth></sekciaZiadatelFODetail><sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress><ZiadatelFOTrvalyPobytAdresaStat_Country>Slovenská republika</ZiadatelFOTrvalyPobytAdresaStat_Country><ZiadatelFOTrvalyPobytAdresaObec_Municipality>Nitra</ZiadatelFOTrvalyPobytAdresaObec_Municipality><ZiadatelFOTrvalyPobytAdresaUlica_StreetName></ZiadatelFOTrvalyPobytAdresaUlica_StreetName><ZiadatelFOTrvalyPobytAdresaKraj_Region>Nitriansky kraj</ZiadatelFOTrvalyPobytAdresaKraj_Region><ZiadatelFOTrvalyPobytAdresaCastObce_District></ZiadatelFOTrvalyPobytAdresaCastObce_District><ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber></ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber><ZiadatelFOTrvalyPobytAdresaOkres_County>Okres Nitra</ZiadatelFOTrvalyPobytAdresaOkres_County><ZiadatelFOTrvalyPobytAdresaPSC_PostalCode></ZiadatelFOTrvalyPobytAdresaPSC_PostalCode><ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber></ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber></sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress><sekciaZiadatelFOPrechodnyPobytAdresa><ZiadatelFOPrechodnyPobytAdresaStat_Country>Slovenská republika</ZiadatelFOPrechodnyPobytAdresaStat_Country><ZiadatelFOPrechodnyPobytAdresaObec_Municipality>Nitra</ZiadatelFOPrechodnyPobytAdresaObec_Municipality><ZiadatelFOPrechodnyPobytAdresaUlica_StreetName></ZiadatelFOPrechodnyPobytAdresaUlica_StreetName><ZiadatelFOPrechodnyPobytAdresaKraj_Region>Nitriansky kraj</ZiadatelFOPrechodnyPobytAdresaKraj_Region><ZiadatelFOPrechodnyPobytAdresaCastObce_District></ZiadatelFOPrechodnyPobytAdresaCastObce_District><ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber></ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber><ZiadatelFOPrechodnyPobytAdresaOkres_County>Okres Nitra</ZiadatelFOPrechodnyPobytAdresaOkres_County><ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode></ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode><ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber></ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber></sekciaZiadatelFOPrechodnyPobytAdresa><sekciaZiadatelFODorucenieAdresa_DeliveryAddress><ZiadatelFODorucenieAdresaStat_Country>Slovenská republika</ZiadatelFODorucenieAdresaStat_Country><ZiadatelFODorucenieAdresaObec_Municipality>Nitra</ZiadatelFODorucenieAdresaObec_Municipality><ZiadatelFODorucenieAdresaUlica_StreetName></ZiadatelFODorucenieAdresaUlica_StreetName><ZiadatelFODorucenieAdresaKraj_Region>Nitriansky kraj</ZiadatelFODorucenieAdresaKraj_Region><ZiadatelFODorucenieAdresaCastObce_District></ZiadatelFODorucenieAdresaCastObce_District><ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber></ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber><ZiadatelFODorucenieAdresaOkres_County>Okres Nitra</ZiadatelFODorucenieAdresaOkres_County><ZiadatelFODorucenieAdresaPSC_PostalCode></ZiadatelFODorucenieAdresaPSC_PostalCode><ZiadatelFODorucenieAdresaOrC_BuildingNumber></ZiadatelFODorucenieAdresaOrC_BuildingNumber></sekciaZiadatelFODorucenieAdresa_DeliveryAddress><sekciaZiadatelFOKontakt><ZiadatelFOKontaktTelCislo_TelephoneAddress></ZiadatelFOKontaktTelCislo_TelephoneAddress><ZiadatelFOKontaktEmailAdresa></ZiadatelFOKontaktEmailAdresa></sekciaZiadatelFOKontakt></sekciaZiadatelFO_PhysicalPerson><sekciaNehnutelnost><sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress><NehnutelnostAdresaNehnutelnostiStat_Country>Slovenská republika</NehnutelnostAdresaNehnutelnostiStat_Country><NehnutelnostAdresaNehnutelnostiObec_Municipality>Nitra</NehnutelnostAdresaNehnutelnostiObec_Municipality><NehnutelnostAdresaNehnutelnostiUlica_StreetName></NehnutelnostAdresaNehnutelnostiUlica_StreetName><NehnutelnostAdresaNehnutelnostiKraj_Region>Nitriansky kraj</NehnutelnostAdresaNehnutelnostiKraj_Region><NehnutelnostAdresaNehnutelnostiCastObce_District></NehnutelnostAdresaNehnutelnostiCastObce_District><NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber></NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber><NehnutelnostAdresaNehnutelnostiOkres_County>Okres Nitra</NehnutelnostAdresaNehnutelnostiOkres_County><NehnutelnostAdresaNehnutelnostiPSC_PostalCode></NehnutelnostAdresaNehnutelnostiPSC_PostalCode><NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber></NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber></sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress></sekciaNehnutelnost><sekciaOsobyUzivajuce><sekciaOsobyUzivajucePocet><OsobyUzivajucePocet>0</OsobyUzivajucePocet></sekciaOsobyUzivajucePocet><sekciaOsobyUzivajuceZoznam><OsobyUzivajuceZoznamMeno_GivenName></OsobyUzivajuceZoznamMeno_GivenName><OsobyUzivajuceZoznamPriezvisko_FamilyName></OsobyUzivajuceZoznamPriezvisko_FamilyName><OsobyUzivajuceZoznamMeno_DateOfBirth></OsobyUzivajuceZoznamMeno_DateOfBirth><OsobyUzivajuceZoznamTypPobytu></OsobyUzivajuceZoznamTypPobytu><sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress><OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country>Slovenská republika</OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country><OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality>Nitra</OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality><OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName></OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName><OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region>Nitriansky kraj</OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region><OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District></OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District><OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber></OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber><OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County>Okres Nitra</OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County><OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode></OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode><OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber></OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber></sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress></sekciaOsobyUzivajuceZoznam></sekciaOsobyUzivajuce><SekciaOchranaOsobnychUdajov><OchranaOsobnychUdajovSuhlas>0</OchranaOsobnychUdajovSuhlas></SekciaOchranaOsobnychUdajov><sekciaNotifikacie><NotifikacieZasielanie>1</NotifikacieZasielanie><NotifikacieKontakt></NotifikacieKontakt></sekciaNotifikacie><sekciaSposobDoruceniaVystupu><SposobDoruceniaVystupuTyp>eDesk</SposobDoruceniaVystupuTyp><SposobDoruceniaVystupuKontakt></SposobDoruceniaVystupuKontakt></sekciaSposobDoruceniaVystupu><sekciaFooter></sekciaFooter></eForm_eGov_001>
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
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html xmlns:mso="urn:schemas-microsoft-com:office:office" xmlns:msdt="uuid:C2F41010-65B3-11d1-A29F-00AA00C14882">
	<head>
	<meta http-equiv="X-UA-Compatible" content="IE=edge" />
	<title>001.Ohlásenie k miestnemu poplatku za komunálne odpady a drobné stavebné odpady</title>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
	<meta name="language" content="sk-SK" />
		<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/jquery-ui.css" rel="stylesheet" type="text/css"/>
	<style type="text/css">
/* <![CDATA[ */
.ui-multiselect { padding:2px 0 2px 4px; text-align:left }
.ui-multiselect span.ui-icon { float:right }
.ui-multiselect-single .ui-multiselect-checkboxes input { position:absolute !important; top: auto !important; left:-9999px; }
.ui-multiselect-single .ui-multiselect-checkboxes label { padding:5px !important }

.ui-multiselect-header { margin-bottom:3px; padding:3px 0 3px 4px }
.ui-multiselect-header ul { font-size:0.9em }
.ui-multiselect-header ul li { float:left; padding:0 10px 0 0 }
.ui-multiselect-header a { text-decoration:none }
.ui-multiselect-header a:hover { text-decoration:underline }
.ui-multiselect-header span.ui-icon { float:left }
.ui-multiselect-header li.ui-multiselect-close { float:right; text-align:right; padding-right:0 }

.ui-multiselect-menu { display:none; padding:3px; position:absolute; z-index:10000; text-align: left }
.ui-multiselect-checkboxes { position:relative /* fixes bug in IE6/7 */; overflow-y:auto }
.ui-multiselect-checkboxes label { cursor:default; display:block; border:1px solid transparent; padding:3px 1px }
.ui-multiselect-checkboxes label input { position:relative; top:1px }
.ui-multiselect-checkboxes li { clear:both; font-size:0.9em; padding-right:3px }
.ui-multiselect-checkboxes li.ui-multiselect-optgroup-label { text-align:center; font-weight:bold; border-bottom:1px solid }
.ui-multiselect-checkboxes li.ui-multiselect-optgroup-label a { display:block; padding:3px; margin:1px 0; text-decoration:none }

/* remove label borders in IE6 because IE6 does not support transparency */
* html .ui-multiselect-checkboxes label { border:none }

/* ]]> */
</style>

	<style type="text/css">
/* <![CDATA[ */
.ui-multiselect-hasfilter ul { position:relative; top:2px }
.ui-multiselect-filter { float:left; margin-right:10px; font-size:11px }
.ui-multiselect-filter input { width:100px; font-size:10px; margin-left:5px; height:15px; padding:2px; border:1px solid #292929; -webkit-appearance:textfield; -webkit-box-sizing:content-box; }

/* ]]> */
</style>

	<style type="text/css">
/* <![CDATA[ */
img {
	border: 0;
}
p {
	line-height: 1.3em;
	margin: 1.3em 0;
	padding: 0;
	text-align: justify;
}
.block {
	display: block;
}
a {
	color: #fff;
	text-decoration: none;
}
a:hover {
	color: #000;
	text-decoration: underline;
}
.menu {
	margin: 10px 0px 0px 180px
}
.horizontal_menu {
	padding: 0px 10px 0px 0px;
}
.horizontal_menu ul {
	border: 0;
	float: left;
	list-style: none;
	margin: 0;
	padding: 0;
	text-align: left;
}
.horizontal_menu ul li {
	border: 0;
	float: left;
	margin: 0;
	padding: 0px 13px 10px 0px;
}
.horizontal_menu ul li a {
	float: left;
	font: bold 14px arial;
	margin: 0;
	padding: 10px 0;
	text-decoration: none;
}
.horizontal_menu ul li a:link {
	color: #828284;
}
.horizontal_menu ul li a:visited {
	color: #828284;
}
.horizontal_menu ul li a:hover {
	color: #6bb110;
}
.horizontal_menu ul li a.selected {
	color: #004478;
}
.vertical_menu {
	float: left;
	height: auto;
	margin: 0px 0px 0px 10px;
	width: 250px;
}
.vertical_menu ul {
	border: 0;
	list-style: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAMAAAC67D+PAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAwBQTFRF7fb77PX7x97s8vn97/f8yuDtm8LaosbdncTbmsHaoMXcz+Pv7/b8zeLuy+DuocXdyd/t7fX7pMje8Pj88f") Inside;
	margin: 0;
	padding: 0;
	text-align: left;
}
.vertical_menu ul li {
	border: 0;
	margin: 0;
	padding: 5px 0px 0px 0px;
}
.vertical_menu ul li a {
	font: normal 13px arial;
	margin: 0;
	padding: 0px 0;
	text-decoration: none;
}
.vertical_menu ul li a:link {
	color: #87afcb;
}
.vertical_menu ul li a:visited {
	color: #87afcb;
}
.vertical_menu ul li.Selected a {
	color: #004478;
	font-weight: bold;
}
.vertical_menu ul li a:hover {
	color: #6bb110;
	font-weight: bold;
}
.HelpIco {
	padding-right: 5px;
	position: relative;
	top: 4px;
}
input[readonly], textarea[readonly], select[readonly]
{
    color: #000000 !important;
    background-color: #f0f0f0 !important;
}
.info {
	background: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABMAAAASCAIAAAA2bnI+AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAolJREFUOE+dk81r1EAYxvckiJfePHkS6UUsXryIF/8BpeBB0YMXPahgr2I9eBJPghZERB") no-repeat 0 0;
	width: 19px;
	height: 18px;
	display: inline-block;
	position: relative;
	top: 4px;
}
.dialog-modal {
	display: none;
}
table.display td {
    cursor: pointer;
}
/* ]]> */
</style>

	<style type="text/css">
/* <![CDATA[ */
body {
    background: url("data:image/jpg;base64,/9j/4AAQSkZJRgABAgAAZABkAAD/7AARRHVja3kAAQAEAAAAUAAA/+4ADkFkb2JlAGTAAAAAAf/bAIQAAgICAgICAgICAgMCAgIDBAMCAgMEBQQEBAQEBQYFBQUFBQUGBgcHCAcHBgkJCgoJCQwMDAwMDAwMDAwMDAwMDAEDAwMFBAUJBgYJDQsJCw0PDg4ODg8PDAwMDAwPDwwMDAwMDA8MDAwMDAwMDAwMDAwMDA") top repeat-x;
    background-color: #9bc2da;
    color: #646464;
    font-family: tahoma, helvetica, arial, sans-serif;
}

.clear { clear: both; }

.hidden, .hiddenSection {
    display: none;
    visibility: hidden;
}

.layoutMain {
    margin: 0px auto;
    padding: 5px 5px 5px 5px;
    width: 900px;
}

.layoutRow { margin-bottom: 5px; }

.caption { /*width: 100%; border-bottom: solid 1px black;*/ }

.nocaption > .caption { border: 0px !important; }

.nocaption > .caption span {
    background: none !important;
    display: none;
}

.caption .title { padding-left: 5px; }

.columns {
    border: none;
    margin: 0px;
    padding: 0px;
    width: 100%;
}

.column {
    border: none;
    float: left;
    margin: 0px;
    padding: 0px;
    width: 100%;
}

.cell { margin: 5px 0 5px 5px; }

.textBox { width: 160px; }

.datepicker, .datepickerISO { width: 160px; }

.time { width: 160px; }

.datetime { width: 160px; }

.daterangepicker { width: 160px; }

.checkBoxList span { display: block; }

.radioButtonList span { display: block; }

.radioButtonList input { width: 10px; }

.comboBox { width: 166px; }

.remoteComboBox { width: 166px; }

.multiCombobox { width: 166px; }

.listBox { width: 166px; }

.button { font-size: 0.55em !important; }

.radioButtonLabel, .checkBoxLabel, .optionLabel {
    font-size: 0.75em;
    padding-left: 12px;
}

.fieldLabel {
    float: left;
    font-family: arial;
    font-size: 0.75em;
    line-height: 25px;
    margin: 0px 18px 0px 0px;
    padding: 0;
    width: 190px;
}

.textArea { font-family: arial;  overflow:auto; }
/* výnimka pre Firefox */

@-moz-document url-prefix() { .textArea { font-size: 112%; } }

.label {
    float: left;
    font-family: arial;
    font-size: 0.75em;
    margin: 0;
    padding: 0;
}

.fieldContent {
    float: left;
    font-family: arial;
    font-size: 0.75em;
    margin: 0px;
    padding: 0px;
    vertical-align: top;
}

.fieldInfo {
    left: 0px;
    position: relative;
    top: 0px;
}

#repetitionCommands {
    margin: 5px;
    padding: 0px;
}

.addRemoveSection {
    cursor: pointer;
    font-family: arial;
    font-size: 0.75em;
}

.removeSection { display: none; }

fieldset {
    border: 0;
    margin-top: 5px;
    padding: 0;
}

select.text {
    margin-bottom: 12px;
    padding: .4em;
    width: 95%;
}

.errorsContainer {
    border: 2px solid red !important;
    display: none;
    font-size: 0.75em;
    margin: 0px auto;
    padding: 5px;
    width: 900px !important;
}

.errorsContainer li {
    color: red;
    list-style-type: none;
    padding: 0px;
}

.errorsContainer li label { cursor: pointer; }

input.error[type=text],
textarea.error {
    border: 1px solid red;
    border-bottom: 6px solid red;
}

select.error { border: 1px solid red; }

input.error[type=radio],
input.error[type=checkbox] {
    border: 1px solid red;
    outline: 1px solid red;
}

em {
    color: red;
    font-size: 0.85em;
    font-style: normal;
    line-height: 16px;
}

.arrow {
    cursor: pointer;
    position: absolute;
    right: 2px;
    top: 2px;
}

.infoIcon { float: left; }

.tableFilter { padding-bottom: 4px; }

.tableFilterText {
    margin-right: 4px;
    width: 160px;
}

table.display {
    clear: both;
    margin: 0 auto;
    width: 100%;
}

table.display tr.even.row_selected td { background-color: #B0BED9; }

table.display tr.odd.row_selected td { background-color: #9FAFD1; }

table.display thead th span { float: right; }

.dataTables_filter { padding: 10px 0 0 8px; }

.dataTables_info {
    float: left;
    width: 60%;
}

.dataTables_paginate {
    float: right;
    text-align: right;
    width: 44px;
    width: 50px;
}
/* Main css end */
/* jquery custom styles start */

div.ui-datepicker { font-size: 0.83em; }

.ui-dialog {
    font-size: 0.7em;
    padding: .3em;
}
/* jquery custom styles end */

table.forms { margin: 0px 0px 5px 0px; }

table.forms th { text-align: left; }

.textleft { text-align: left; }

.textcenter { text-align: center; }

.textAreaOneRow {
    height: 19px;
    width: 806px;
}

.statusDialog img {
    display: block;
    margin: 15px auto;
}

.statusDialog .statusMessage { font-weight: bold; }

.noscript {
    color: Red;
    font-weight: bold;
    text-align: center;
}

.headercorrection {
    font-size: 0.75em;
    margin: 0px;
}

.fieldVisualization {    
    font-family: arial;
    font-size: 0.75em;
    margin: 0px;
    padding: 0px; 
}

.wordwrap { 
   white-space: pre-wrap;      /* CSS3 */   
   white-space: -moz-pre-wrap; /* Firefox */    
   white-space: -pre-wrap;     /* Opera <7 */   
   white-space: -o-pre-wrap;   /* Opera 7 */    
   word-wrap: break-word;      /* IE */
}

.date-range-selected > .ui-state-active,
.date-range-selected > .ui-state-default {
   background: none;
   background-color: lightsteelblue;
}

.ui-widget-overlay {
       position: fixed !important;
}
/* ]]> */
</style>

	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/treeselect.css" rel="stylesheet" type="text/css"/>
	<link href="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Styles/chosentree.css" rel="stylesheet" type="text/css"/>
	<style type="text/css">
/* <![CDATA[ */
body {
    font-family : 'Open Sans' !important ;
    background : transparent !important ;
}

input[readonly="readonly"] {
    background : #f1f1f1;
}

[disabled="disabled"] {
    color : lightgrey !important ;
}

.textBox {
    font-family : 'Open Sans';
    width : 160px;
    height : 25px;
    border-radius : 3px;
    background : #ffffff;
    border : #d3d0ce solid 1px;
    color : #222222;
    padding-left : 7px;
}

.comboBox {
    width : 166px;
    height : 29px;
    border-radius : 3px;
    background : #ffffff;
    border : #d3d0ce solid 1px;
    color : #222222;
    padding-left : 4px;
}

.textArea {
    font-family : 'Open Sans';
    overflow : auto;
    border-radius : 3px;
    background : #ffffff;
    border : #d3d0ce solid 1px;
    color : #222222;
    padding-left : 7px;
}

.datepicker, .datepickerISO, .datetime, .time {
    height : 25px;
    font-family : 'Open Sans';
    width : 160px;
    border-radius : 3px;
    background : #ffffff;
    border : #d3d0ce solid 1px;
    color : #222222;
    padding-left : 7px;
}

.fieldLabel, .label {
    font-family : 'Open Sans', arial, sans-serif;
    line-height: 34px;  
}

div.ui-datepicker {
    font-size : 0.83em;
}

.ui-widget-content {
    background : 50% 50% repeat-x #ffffff;
    border : #d4d4d4 solid 2px;
    color : #4f4e4e;
    border-radius : 3px;
}

.ui-widget-content a, .ui-widget-header a {
    color : #222222;
}

.ui-widget-header {
    cursor : pointer;
    font-size : 0.80em;
    color : #494949;
    border : #eae9e8 solid 1px;
    background-color : #eae9e8;
    border-radius : 3px;
}

.headercorrection {
    font-size : 1em;
    padding : 6px 2px 6px 5px;
}

.ui-state-default, .ui-widget-content .ui-state-default, .ui-widget-header .ui-state-default {
    background : 50% 50% repeat-x #bd0a26;
    border : #bd0a26 solid 1px;
    color : #ffffff;
    font-weight : bold;
    text-transform : uppercase;
    padding : 4px 8px 4px 8px;
}

.ui-state-hover, .ui-widget-content .ui-state-hover, .ui-widget-header .ui-state-hover, .ui-state-focus, .ui-widget-content .ui-state-focus, .ui-widget-header .ui-state-focus {
    border : #e52241 solid 1px;
    color : #ffffff;
    font-weight : bold;
}

.ui-state-hover a, .ui-state-hover a:hover {
    color : #212121;
    text-decoration : none;
}

.radioButtonLabel {
    font-size : 0.75em;
    top : -2px;
    position : relative;
    padding-left : 12px;
}

.fieldContent input {
    border-radius : 3px;
}

.info {
    background : url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABMAAAASCAYAAAC5DOVpAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAEnQAABJ0Ad5mH3gAAALbSURBVDhPdZRdSBRRFMf/M7M72+xH6urmiqUmoqQFFqUP2qdID1JhLwr1ZD0KZQ+9BNJL9JT00kMFEUgfEARm0IcEGVJUGJIhiqL2pbZo7q7uzO7OV/deZ9") 0 0 no-repeat;
    width : 19px;
    height : 19px;
    display : inline-block;
    position : relative;
    top : 4px;
    margin-left : 5px;
}

.dialog-modal {
    display : none;
}

table.display td {
    cursor : pointer;
}

.button:hover, .lookupbutton:hover, .ui-slider-handle ui-state-default ui-corner-all ui-state-hover {
    background-color : #e52241 !important ;
}

.addRemoveSection span {
    font-size : 1.1em !important ;
    font-family : 'Open Sans', Verdana, Arial, sans-serif;
}

.ui-widget-header button {
    background-color : white !important ;
}

.ui-priority-secondary, .ui-widget-content .ui-priority-secondary, .ui-widget-header .ui-priority-secondary {
    opacity : 1;
}

.checkBoxList label {
    font-size : 1em;
    font-family : 'Open Sans';
    padding-left : 10px;
}

.button {
    line-height : 1.4;
}

#showXml, #saveForm, #loadForm, #clearForm, #validateForm, #validateFormWithXsd, #validateFormWithServer, #printForm, #closeForm, #cancelForm {
    font-size: 0.55em !important;
}

.optionLabel, .checkBoxLabel {
    top : -2px;
    position : relative;
}

.fieldContent {
    margin-top : 2px;
    margin-bottom : 2px;
    min-height: 30px;
}

.hyperLink, .crossLink {
    color : #bd0a26 !important ;
    font-family : 'Open Sans';
}

input[type="file"] {
    padding : 3px 0 0 3px;
}

input[type="button"], input[type="submit"], .lookupbutton {
    padding : 8px 12px 8px 12px !important ;
    font-size : 0.75em !important ;
}

.lookupbutton {
    margin-top: -4px;
}

.infoIcon {
    background-image : url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAADwCAMAAADYSUr5AAAA7VBMVEXMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCg") !important ;
}

#ui-datepicker-div {
    min-width : 20em;
    background : #f9f9f9;
}

.ui-timepicker-div .ui-widget-header, .ui-datepicker-header {
    background : #ffffff !important ;
    margin : 2px 2px 2px 2px;
}

.ui-datepicker-header .ui-icon {
    background-image : url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAADwCAMAAADYSUr5AAAA7VBMVEXMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCg") !important ;
}

dl dt {
    float : left;
    margin : 10px 120px 10px 0;
}

dl dd {
    width : 14em !important ;
    margin : 25px 0 10px 70px;
}

.ui_tpicker_time_label {
    width : 2em !important ;
    margin-right : 0;
}

.ui_tpicker_time {
    border : #eae9e8 solid 1px;
    background : #ffffff;
    width : 4em !important ;
    height : 1.5em;
    padding : 5px 0 5px 10px;
}

.ui_tpicker_time_label, .ui_tpicker_time, .ui_tpicker_hour_label, .ui_tpicker_minute_label {
    font-size : 0.85em;
    margin-bottom : 7px;
}

a.ui-slider-handle {
    padding : 2px 0 3px 0 !important ;
    margin-top : -4px;
}

.ui_tpicker_hour_slider, .ui_tpicker_minute_slider {
    height : 4px;
    background : #c5c5c5;
    border : 0;
}

.ui-priority-primary {
    background : #bd0a26 !important ;
}

.ui-priority-secondary {
    background : #494949 !important ;
}

.ui-priority-secondary, .ui-priority-primary {
    border : 0 !important ;
    padding : 8px 12px 8px 12px !important ;
    font-size : 0.70em !important ;
}

table.ui-datepicker-calendar td a {
    background : #ffffff !important ;
    color : #bd0a26 !important ;
    border : #eae9e8 solid 1px !important ;
}

table.ui-datepicker-calendar td a.ui-state-highlight {
    color : #494949 !important ;
}

table.ui-datepicker-calendar td a:hover, table.ui-datepicker-calendar td a.ui-state-active {
    background : #e15c71 !important ;
    color : #ffffff !important ;
    border : #bd0a26 solid 1px !important ;
}

.ui-datepicker-next-hover, .ui-datepicker-prev-hover {
    background : #ffffff !important ;
    border : #ffffff solid 1px !important ;
    color : #ffffff !important ;
}

.ui-datepicker-buttonpane {
    border : 0;
}

.ui-dialog .ui-dialog-titlebar {
    border : 0;
    background : #bd0a26;
    color : #bd0a26;
    padding : 4px 8px 4px 8px;
    width : 20px;
    float : right;
}

.lookup-dialog .ui-dialog-titlebar {
    margin-top : -6px;
}

.ui-dialog-titlebar-close.ui-state-hover {
    background : #e9ced2 !important ;
}

.ui-dialog {
    border : 0;
    background : #bd0a26 !important ;
    opacity : 0.9;
}

.ui-dialog .dialog-modal {
    margin : 5px;
    margin-top : 10px;
    padding-left : 7px;
    padding-top : 0;
}

.dialog-modal p span {
    color : #f9f9f9;
    font-size : 1em !important ;
}

div[lookupdetail].ui-dialog-content {
    color: #f9f9f9 !important;
}

.ui-widget-overlay {
    background : #ffffff;
}

.ui-dialog .ui-widget-content {
    background : none;
    border : 0;
}

.lookup-dialog {
    color : #494949 !important ;
    border : #d4d4d4 solid 2px;
    background : #f9f9f9 !important ;
    padding : 5px 0 5px 10px;
    opacity : 1;
}

.lookup-dialog .ui-helper-clearfix {
    background : #f9f9f9 !important ;
}

.lookup-dialog .fg-buttonset {
    width : 100px;
}

.lookup-dialog .ui-dialog-title {
    color : #f9f9f9;
}

.fg-button {
    margin-left : 3px !important ;
}

.lookup-dialog .ui-icon-closethick {
    margin-right : 5px;
}

.lookup-dialog .fg-toolbar {
    border : #d4d4d4 solid 1px;
    background : #eae9e8 !important ;
    color : #bd0a26;
}

.lookup-dialog table th {
    border-color : #d4d4d4 !important ;
    background : #ffffff !important ;
    color : #494949 !important ;
}

.fg-toolbar {
    background : #ffffff;
    padding : 0;
}

.lookup-dialog .fg-button {
    background : none;
    border : 0;
}

.lookup-dialog #FilterButton, .lookup-dialog .ui-button-text {
    font-size : 0.8em !important ;
}

.lookup-dialog .dataTables_processing {
    color : #4f4e4e;
}

.lookup-dialog .ui-icon, .ui-icon-closethick {
    background-image : url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAADwCAMAAADYSUr5AAAA7VBMVEXMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCgzMCg") !important ;
}

.lookup-dialog thead th, .lookup-dialog tbody tr {
    color : #bd0a26 !important ;
}
/* ]]> */
</style>

	<style type="text/css">
/* <![CDATA[ */
@font-face {
  font-family: 'Open Sans';
  font-style: normal;
  font-weight: 300;
  src: local('Open Sans Light'), local('OpenSans-Light'), url(https://fonts.gstatic.com/s/opensans/v13/DXI1ORHCpsQm3Vp6mXoaTYnF5uFdDttMLvmWuJdhhgs.ttf) format('truetype');
}
@font-face {
  font-family: 'Open Sans';
  font-style: normal;
  font-weight: 400;
  src: local('Open Sans'), local('OpenSans'), url(https://fonts.gstatic.com/s/opensans/v13/cJZKeOuBrn4kERxqtaUH3aCWcynf_cDxXwCLxiixG1c.ttf) format('truetype');
}
@font-face {
  font-family: 'Open Sans';
  font-style: normal;
  font-weight: 600;
  src: local('Open Sans Semibold'), local('OpenSans-Semibold'), url(https://fonts.gstatic.com/s/opensans/v13/MTP_ySUJH_bn48VBG8sNSonF5uFdDttMLvmWuJdhhgs.ttf) format('truetype');
}
@font-face {
  font-family: 'Open Sans';
  font-style: normal;
  font-weight: 700;
  src: local('Open Sans Bold'), local('OpenSans-Bold'), url(https://fonts.gstatic.com/s/opensans/v13/k3k702ZOKiLJc3WVjuplzInF5uFdDttMLvmWuJdhhgs.ttf) format('truetype');
}
@font-face {
  font-family: 'Open Sans';
  font-style: italic;
  font-weight: 400;
  src: local('Open Sans Italic'), local('OpenSans-Italic'), url(https://fonts.gstatic.com/s/opensans/v13/xjAJXh38I15wypJXxuGMBp0EAVxt0G0biEntp43Qt6E.ttf) format('truetype');
}

/* ]]> */
</style>

	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.min.js" type="text/javascript"></script>
	<script type="text/javascript">
/* <![CDATA[ */
/*! jQuery Migrate v1.2.1 | (c) 2005, 2013 jQuery Foundation, Inc. and other contributors | jquery.org/license */
jQuery.migrateMute===void 0&&(jQuery.migrateMute=!0),function(e,t,n){function r(n){var r=t.console;i[n]||(i[n]=!0,e.migrateWarnings.push(n),r&&r.warn&&!e.migrateMute&&(r.warn("JQMIGRATE: "+n),e.migrateTrace&&r.trace&&r.trace()))}function a(t,a,i,o){if(Object.defineProperty)try{return Object.defineProperty(t,a,{configurable:!0,enumerable:!0,get:function(){return r(o),i},set:function(e){r(o),i=e}}),n}catch(s){}e._definePropertyBroken=!0,t[a]=i}var i={};e.migrateWarnings=[],!e.migrateMute&&t.console&&t.console.log&&t.console.log("JQMIGRATE: Logging is active"),e.migrateTrace===n&&(e.migrateTrace=!0),e.migrateReset=function(){i={},e.migrateWarnings.length=0},"BackCompat"===document.compatMode&&r("jQuery is not compatible with Quirks Mode");var o=e("<input/>",{size:1}).attr("size")&&e.attrFn,s=e.attr,u=e.attrHooks.value&&e.attrHooks.value.get||function(){return null},c=e.attrHooks.value&&e.attrHooks.value.set||function(){return n},l=/^(?:input|button)$/i,d=/^[238]$/,p=/^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,f=/^(?:checked|selected)$/i;a(e,"attrFn",o||{},"jQuery.attrFn is deprecated"),e.attr=function(t,a,i,u){var c=a.toLowerCase(),g=t&&t.nodeType;return u&&(4>s.length&&r("jQuery.fn.attr( props, pass ) is deprecated"),t&&!d.test(g)&&(o?a in o:e.isFunction(e.fn[a])))?e(t)[a](i):("type"===a&&i!==n&&l.test(t.nodeName)&&t.parentNode&&r("Can't change the 'type' of an input or button in IE 6/7/8"),!e.attrHooks[c]&&p.test(c)&&(e.attrHooks[c]={get:function(t,r){var a,i=e.prop(t,r);return i===!0||"boolean"!=typeof i&&(a=t.getAttributeNode(r))&&a.nodeValue!==!1?r.toLowerCase():n},set:function(t,n,r){var a;return n===!1?e.removeAttr(t,r):(a=e.propFix[r]||r,a in t&&(t[a]=!0),t.setAttribute(r,r.toLowerCase())),r}},f.test(c)&&r("jQuery.fn.attr('"+c+"') may use property instead of attribute")),s.call(e,t,a,i))},e.attrHooks.value={get:function(e,t){var n=(e.nodeName||"").toLowerCase();return"button"===n?u.apply(this,arguments):("input"!==n&&"option"!==n&&r("jQuery.fn.attr('value') no longer gets properties"),t in e?e.value:null)},set:function(e,t){var a=(e.nodeName||"").toLowerCase();return"button"===a?c.apply(this,arguments):("input"!==a&&"option"!==a&&r("jQuery.fn.attr('value', val) no longer sets properties"),e.value=t,n)}};var g,h,v=e.fn.init,m=e.parseJSON,y=/^([^<]*)(<[\w\W]+>)([^>]*)$/;e.fn.init=function(t,n,a){var i;return t&&"string"==typeof t&&!e.isPlainObject(n)&&(i=y.exec(e.trim(t)))&&i[0]&&("<"!==t.charAt(0)&&r("$(html) HTML strings must start with '<' character"),i[3]&&r("$(html) HTML text after last tag is ignored"),"#"===i[0].charAt(0)&&(r("HTML string cannot start with a '#' character"),e.error("JQMIGRATE: Invalid selector string (XSS)")),n&&n.context&&(n=n.context),e.parseHTML)?v.call(this,e.parseHTML(i[2],n,!0),n,a):v.apply(this,arguments)},e.fn.init.prototype=e.fn,e.parseJSON=function(e){return e||null===e?m.apply(this,arguments):(r("jQuery.parseJSON requires a valid JSON string"),null)},e.uaMatch=function(e){e=e.toLowerCase();var t=/(chrome)[ \/]([\w.]+)/.exec(e)||/(webkit)[ \/]([\w.]+)/.exec(e)||/(opera)(?:.*version|)[ \/]([\w.]+)/.exec(e)||/(msie) ([\w.]+)/.exec(e)||0>e.indexOf("compatible")&&/(mozilla)(?:.*? rv:([\w.]+)|)/.exec(e)||[];return{browser:t[1]||"",version:t[2]||"0"}},e.browser||(g=e.uaMatch(navigator.userAgent),h={},g.browser&&(h[g.browser]=!0,h.version=g.version),h.chrome?h.webkit=!0:h.webkit&&(h.safari=!0),e.browser=h),a(e,"browser",e.browser,"jQuery.browser is deprecated"),e.sub=function(){function t(e,n){return new t.fn.init(e,n)}e.extend(!0,t,this),t.superclass=this,t.fn=t.prototype=this(),t.fn.constructor=t,t.sub=this.sub,t.fn.init=function(r,a){return a&&a instanceof e&&!(a instanceof t)&&(a=t(a)),e.fn.init.call(this,r,a,n)},t.fn.init.prototype=t.fn;var n=t(document);return r("jQuery.sub() is deprecated"),t},e.ajaxSetup({converters:{"text json":e.parseJSON}});var b=e.fn.data;e.fn.data=function(t){var a,i,o=this[0];return!o||"events"!==t||1!==arguments.length||(a=e.data(o,t),i=e._data(o,t),a!==n&&a!==i||i===n)?b.apply(this,arguments):(r("Use of jQuery.fn.data('events') is deprecated"),i)};var j=/\/(java|ecma)script/i,w=e.fn.andSelf||e.fn.addBack;e.fn.andSelf=function(){return r("jQuery.fn.andSelf() replaced by jQuery.fn.addBack()"),w.apply(this,arguments)},e.clean||(e.clean=function(t,a,i,o){a=a||document,a=!a.nodeType&&a[0]||a,a=a.ownerDocument||a,r("jQuery.clean() is deprecated");var s,u,c,l,d=[];if(e.merge(d,e.buildFragment(t,a).childNodes),i)for(c=function(e){return!e.type||j.test(e.type)?o?o.push(e.parentNode?e.parentNode.removeChild(e):e):i.appendChild(e):n},s=0;null!=(u=d[s]);s++)e.nodeName(u,"script")&&c(u)||(i.appendChild(u),u.getElementsByTagName!==n&&(l=e.grep(e.merge([],u.getElementsByTagName("script")),c),d.splice.apply(d,[s+1,0].concat(l)),s+=l.length));return d});var Q=e.event.add,x=e.event.remove,k=e.event.trigger,N=e.fn.toggle,T=e.fn.live,M=e.fn.die,S="ajaxStart|ajaxStop|ajaxSend|ajaxComplete|ajaxError|ajaxSuccess",C=RegExp("\\b(?:"+S+")\\b"),H=/(?:^|\s)hover(\.\S+|)\b/,A=function(t){return"string"!=typeof t||e.event.special.hover?t:(H.test(t)&&r("'hover' pseudo-event is deprecated, use 'mouseenter mouseleave'"),t&&t.replace(H,"mouseenter$1 mouseleave$1"))};e.event.props&&"attrChange"!==e.event.props[0]&&e.event.props.unshift("attrChange","attrName","relatedNode","srcElement"),e.event.dispatch&&a(e.event,"handle",e.event.dispatch,"jQuery.event.handle is undocumented and deprecated"),e.event.add=function(e,t,n,a,i){e!==document&&C.test(t)&&r("AJAX events should be attached to document: "+t),Q.call(this,e,A(t||""),n,a,i)},e.event.remove=function(e,t,n,r,a){x.call(this,e,A(t)||"",n,r,a)},e.fn.error=function(){var e=Array.prototype.slice.call(arguments,0);return r("jQuery.fn.error() is deprecated"),e.splice(0,0,"error"),arguments.length?this.bind.apply(this,e):(this.triggerHandler.apply(this,e),this)},e.fn.toggle=function(t,n){if(!e.isFunction(t)||!e.isFunction(n))return N.apply(this,arguments);r("jQuery.fn.toggle(handler, handler...) is deprecated");var a=arguments,i=t.guid||e.guid++,o=0,s=function(n){var r=(e._data(this,"lastToggle"+t.guid)||0)%o;return e._data(this,"lastToggle"+t.guid,r+1),n.preventDefault(),a[r].apply(this,arguments)||!1};for(s.guid=i;a.length>o;)a[o++].guid=i;return this.click(s)},e.fn.live=function(t,n,a){return r("jQuery.fn.live() is deprecated"),T?T.apply(this,arguments):(e(this.context).on(t,this.selector,n,a),this)},e.fn.die=function(t,n){return r("jQuery.fn.die() is deprecated"),M?M.apply(this,arguments):(e(this.context).off(t,this.selector||"**",n),this)},e.event.trigger=function(e,t,n,a){return n||C.test(e)||r("Global events are undocumented and deprecated"),k.call(this,e,t,n||document,a)},e.each(S.split("|"),function(t,n){e.event.special[n]={setup:function(){var t=this;return t!==document&&(e.event.add(document,n+"."+e.guid,function(){e.event.trigger(n,null,t,!0)}),e._data(this,n,e.guid++)),!1},teardown:function(){return this!==document&&e.event.remove(document,n+"."+e._data(this,n)),!1}}})}(jQuery,window);
/* ]]> */
</script>

	<script type="text/javascript">
/* <![CDATA[ */
// jQuery Mask Plugin v1.3.2
// github.com/igorescobar/jQuery-Mask-Plugin
(function(c){var w=function(a,d,e){var f=this;a=c(a);var l;d="function"==typeof d?d(a.val(),void 0,a,e):d;f.init=function(){e=e||{};f.byPassKeys=[8,9,16,36,37,38,39,40,46,91];f.translation={0:{pattern:/\d/},9:{pattern:/\d/,optional:!0},"#":{pattern:/\d/,recursive:!0},A:{pattern:/[a-zA-Z0-9]/},S:{pattern:/[a-zA-Z]/}};f.translation=c.extend({},f.translation,e.translation);f=c.extend(!0,{},f,e);a.each(function(){!1!==e.maxlength&&a.attr("maxlength",d.length);a.attr("autocomplete","off");g.destroyEvents();
g.events();g.val(g.getMasked())})};var g={events:function(){a.on("keydown.mask",function(){l=g.val()});a.on("keyup.mask",g.behaviour);a.on("paste.mask",function(){setTimeout(function(){a.keydown().keyup()},100)})},destroyEvents:function(){a.off("keydown.mask").off("keyup.mask").off("paste.mask")},val:function(v){var d="input"===a.get(0).tagName.toLowerCase();return 0<arguments.length?d?a.val(v):a.text(v):d?a.val():a.text()},behaviour:function(a){a=a||window.event;if(-1===c.inArray(a.keyCode||a.which,
f.byPassKeys))return g.val(g.getMasked()),g.callbacks(a)},getMasked:function(){var a=[],c=g.val(),b=0,q=d.length,h=0,l=c.length,k=1,r="push",m=-1,n,s;e.reverse?(r="unshift",k=-1,n=0,b=q-1,h=l-1,s=function(){return-1<b&&-1<h}):(n=q-1,s=function(){return b<q&&h<l});for(;s();){var t=d.charAt(b),u=c.charAt(h),p=f.translation[t];p?(u.match(p.pattern)?(a[r](u),p.recursive&&(-1==m?m=b:b==n&&(b=m-k),n==m&&(b-=k)),b+=k):p.optional&&(b+=k,h-=k),h+=k):(a[r](t),u==t&&(h+=k),b+=k)}return a.join("")},callbacks:function(f){var c=
g.val(),b=g.val()!==l;if(!0===b&&"function"==typeof e.onChange)e.onChange(c,f,a,e);if(!0===b&&"function"==typeof e.onKeyPress)e.onKeyPress(c,f,a,e);if("function"===typeof e.onComplete&&c.length===d.length)e.onComplete(c,f,a,e)}};f.remove=function(){g.destroyEvents();g.val(f.getCleanVal()).removeAttr("maxlength")};f.getCleanVal=function(){for(var a=[],c=g.val(),b=0,e=d.length;b<e;b++)f.translation[d.charAt(b)]&&a.push(c.charAt(b));return a.join("")};f.init()};c.fn.mask=function(a,d){return this.each(function(){c(this).data("mask",
new w(this,a,d))})};c.fn.unmask=function(){return this.each(function(){try{c(this).data("mask").remove()}catch(a){}})};c("input[data-mask]").each(function(){var a=c(this),d={};"true"===a.attr("data-mask-reverse")&&(d.reverse=!0);"false"===a.attr("data-mask-maxlength")&&(d.maxlength=!1);a.mask(a.attr("data-mask"),d)})})(window.jQuery||window.Zepto);

/* ]]> */
</script>
	
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery-ui.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.dataTables.min.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery-ui-timepicker-addon.js" type="text/javascript"></script>
	<script type="text/javascript">
/* <![CDATA[ */
/*
 * jQuery MultiSelect UI Widget Filtering Plugin 1.4
 * Copyright (c) 2011 Eric Hynds
 *
 * http://www.erichynds.com/jquery/jquery-ui-multiselect-widget/
 *
 * Depends:
 *   - jQuery UI MultiSelect widget
 *
 * Dual licensed under the MIT and GPL licenses:
 *   http://www.opensource.org/licenses/mit-license.php
 *   http://www.gnu.org/licenses/gpl.html
 *
*/
(function(a){var f=/[\-\[\]{}()*+?.,\\\^$|#\s]/g;a.widget("ech.multiselectfilter",{options:{label:"Filter:",width:null,placeholder:"Enter keywords",autoReset:!1},_create:function(){var e;var b=this,c=this.options,d=this.instance=a(this.element).data("multiselect");this.header=d.menu.find(".ui-multiselect-header").addClass("ui-multiselect-hasfilter");e=this.wrapper=a('<div class="ui-multiselect-filter">'+(c.label.length?c.label:"")+'<input placeholder="'+c.placeholder+'" type="search"'+(/\d/.test(c.width)?  'style="width:'+c.width+'px"':"")+" /></div>").prependTo(this.header),c=e;this.inputs=d.menu.find('input[type="checkbox"], input[type="radio"]');this.input=c.find("input").bind({keydown:function(a){13===a.which&&a.preventDefault()},keyup:a.proxy(b._handler,b),click:a.proxy(b._handler,b)});this.updateCache();d._toggleChecked=function(c,d){var e=d&&d.length?d:this.labels.find("input"),i=this,e=e.not(b.instance._isOpen?":disabled, :hidden":":disabled").each(this._toggleState("checked",c));this.update(); var j=e.map(function(){return this.value}).get();this.element.find("option").filter(function(){!this.disabled&&-1<a.inArray(this.value,j)&&i._toggleState("selected",c).call(this)})};d=a(document).bind("multiselectrefresh",function(){b.updateCache();b._handler()});this.options.autoReset&&d.bind("multiselectclose",a.proxy(this._reset,this))},_handler:function(b){var c=a.trim(this.input[0].value.toLowerCase()),d=this.rows,g=this.inputs,h=this.cache;if(c){d.hide();var e=RegExp(c.replace(f,"\\$&"),"gi"); this._trigger("filter",b,a.map(h,function(a,b){return-1!==a.search(e)?(d.eq(b).show(),g.get(b)):null}))}else d.show();this.instance.menu.find(".ui-multiselect-optgroup-label").each(function(){var b=a(this),c=b.nextUntil(".ui-multiselect-optgroup-label").filter(function(){return"none"!==a.css(this,"display")}).length;b[c?"show":"hide"]()})},_reset:function(){this.input.val("").trigger("keyup")},updateCache:function(){this.rows=this.instance.menu.find(".ui-multiselect-checkboxes li:not(.ui-multiselect-optgroup-label)");this.cache=this.element.children().map(function(){var b=a(this);"optgroup"===this.tagName.toLowerCase()&&(b=b.children());return b.map(function(){return this.innerHTML.toLowerCase()}).get()}).get()},widget:function(){return this.wrapper},destroy:function(){a.Widget.prototype.destroy.call(this);this.input.val("").trigger("keyup");this.wrapper.remove()}})})(jQuery);

/* ]]> */
</script>

	<script type="text/javascript">
/* <![CDATA[ */
/*
 * jQuery MultiSelect UI Widget 1.13
 * Copyright (c) 2012 Eric Hynds
 *
 * http://www.erichynds.com/jquery/jquery-ui-multiselect-widget/
 *
 * Depends:
 *   - jQuery 1.4.2+
 *   - jQuery UI 1.8 widget factory
 *
 * Optional:
 *   - jQuery UI effects
 *   - jQuery UI position utility
 *
 * Dual licensed under the MIT and GPL licenses:
 *   http://www.opensource.org/licenses/mit-license.php
 *   http://www.gnu.org/licenses/gpl.html
 *
 */
(function(d){var k=0;d.widget("ech.multiselect",{options:{header:!0,height:175,minWidth:225,classes:"",checkAllText:"Check all",uncheckAllText:"Uncheck all",noneSelectedText:"Select options",selectedText:"# selected",selectedList:0,show:null,hide:null,autoOpen:!1,multiple:!0,position:{}},_create:function(){var a=this.element.hide(),b=this.options;this.speed=d.fx.speeds._default;this._isOpen=!1;a=(this.button=d('<button type="button"><span class="ui-icon ui-icon-triangle-2-n-s"></span></button>')).addClass("ui-multiselect ui-widget ui-state-default ui-corner-all").addClass(b.classes).attr({title:a.attr("title"),"aria-haspopup":!0,tabIndex:a.attr("tabIndex")}).insertAfter(a);(this.buttonlabel=d("<span />")).html(b.noneSelectedText).appendTo(a);var a=(this.menu=d("<div />")).addClass("ui-multiselect-menu ui-widget ui-widget-content ui-corner-all").addClass(b.classes).appendTo(document.body),c=(this.header=d("<div />")).addClass("ui-widget-header ui-corner-all ui-multiselect-header ui-helper-clearfix").appendTo(a);(this.headerLinkContainer=d("<ul />")).addClass("ui-helper-reset").html(function(){return!0===b.header?'<li><a class="ui-multiselect-all" href="#"><span class="ui-icon ui-icon-check"></span><span>'+b.checkAllText+'</span></a></li><li><a class="ui-multiselect-none" href="#"><span class="ui-icon ui-icon-closethick"></span><span>'+b.uncheckAllText+"</span></a></li>":"string"===typeof b.header?"<li>"+b.header+"</li>":""}).append('<li class="ui-multiselect-close"><a href="#" class="ui-multiselect-close"><span class="ui-icon ui-icon-circle-close"></span></a></li>').appendTo(c);(this.checkboxContainer=d("<ul />")).addClass("ui-multiselect-checkboxes ui-helper-reset").appendTo(a);this._bindEvents();this.refresh(!0);b.multiple||a.addClass("ui-multiselect-single")},_init:function(){!1===this.options.header&&this.header.hide();this.options.multiple||this.headerLinkContainer.find(".ui-multiselect-all, .ui-multiselect-none").hide();this.options.autoOpen&&this.open();this.element.is(":disabled")&&this.disable()},refresh:function(a){var b=this.element,c=this.options,f=this.menu,h=this.checkboxContainer,g=[],e="",i=b.attr("id")||k++;b.find("option").each(function(b){d(this);var a=this.parentNode,f=this.innerHTML,h=this.title,k=this.value,b="ui-multiselect-"+(this.id||i+"-option-"+b),l=this.disabled,n=this.selected,m=["ui-corner-all"],o=(l?"ui-multiselect-disabled ":" ")+this.className,j;"OPTGROUP"===a.tagName&&(j=a.getAttribute("label"),-1===d.inArray(j,g)&&(e+='<li class="ui-multiselect-optgroup-label '+a.className+'"><a href="#">'+j+"</a></li>",g.push(j)));l&&m.push("ui-state-disabled");n&&!c.multiple&&m.push("ui-state-active");e+='<li class="'+o+'">';e+='<label for="'+b+'" title="'+h+'" class="'+m.join(" ")+'">';e+='<input id="'+b+'" name="multiselect_'+i+'" type="'+(c.multiple?"checkbox":"radio")+'" value="'+k+'" title="'+f+'"';n&&(e+=' checked="checked"',e+=' aria-selected="true"');l&&(e+=' disabled="disabled"',e+=' aria-disabled="true"');e+=" /><span>"+f+"</span></label></li>"});h.html(e);this.labels=f.find("label");this.inputs=this.labels.children("input");this._setButtonWidth();this._setMenuWidth();this.button[0].defaultValue=this.update();a||this._trigger("refresh")},update:function(){var a=this.options,b=this.inputs,c=b.filter(":checked"),f=c.length,a=0===f?a.noneSelectedText:d.isFunction(a.selectedText)?a.selectedText.call(this,f,b.length,c.get()):/\d/.test(a.selectedList)&&0<a.selectedList&&f<=a.selectedList?c.map(function(){return d(this).next().html()}).get().join(", "):a.selectedText.replace("#",f).replace("#",b.length);this.buttonlabel.html(a);return a},_bindEvents:function(){function a(){b[b._isOpen? "close":"open"]();return!1}var b=this,c=this.button;c.find("span").bind("click.multiselect",a);c.bind({click:a,keypress:function(a){switch(a.which){case 27:case 38:case 37:b.close();break;case 39:case 40:b.open()}},mouseenter:function(){c.hasClass("ui-state-disabled")||d(this).addClass("ui-state-hover")},mouseleave:function(){d(this).removeClass("ui-state-hover")},focus:function(){c.hasClass("ui-state-disabled")||d(this).addClass("ui-state-focus")},blur:function(){d(this).removeClass("ui-state-focus")}});this.header.delegate("a","click.multiselect",function(a){if(d(this).hasClass("ui-multiselect-close"))b.close();else b[d(this).hasClass("ui-multiselect-all")?"checkAll":"uncheckAll"]();a.preventDefault()});this.menu.delegate("li.ui-multiselect-optgroup-label a","click.multiselect",function(a){a.preventDefault();var c=d(this),g=c.parent().nextUntil("li.ui-multiselect-optgroup-label").find("input:visible:not(:disabled)"),e=g.get(),c=c.parent().text();!1!==b._trigger("beforeoptgrouptoggle",a,{inputs:e,label:c})&&(b._toggleChecked(g.filter(":checked").length!==g.length,g),b._trigger("optgrouptoggle",a,{inputs:e,label:c,checked:e[0].checked}))}).delegate("label","mouseenter.multiselect",function(){d(this).hasClass("ui-state-disabled")||(b.labels.removeClass("ui-state-hover"),d(this).addClass("ui-state-hover").find("input").focus())}).delegate("label","keydown.multiselect",function(a){a.preventDefault();switch(a.which){case 9:case 27:b.close();break;case 38:case 40:case 37:case 39:b._traverse(a.which,this);break;case 13:d(this).find("input")[0].click()}}).delegate('input[type="checkbox"], input[type="radio"]',"click.multiselect",function(a){var c=d(this),g=this.value,e=this.checked,i=b.element.find("option");this.disabled||!1===b._trigger("click",a,{value:g,text:this.title,checked:e})?a.preventDefault():(c.focus(),c.attr("aria-selected",e),i.each(function(){this.value===g?this.selected=e:b.options.multiple||(this.selected=!1)}),b.options.multiple||(b.labels.removeClass("ui-state-active"),c.closest("label").toggleClass("ui-state-active",e),b.close()),b.element.trigger("change"),setTimeout(d.proxy(b.update,b),10))});d(document).bind("mousedown.multiselect",function(a){b._isOpen&&(!d.contains(b.menu[0],a.target)&&!d.contains(b.button[0],a.target)&&a.target!==b.button[0])&&b.close()});d(this.element[0].form).bind("reset.multiselect",function(){setTimeout(d.proxy(b.refresh,b),10)})},_setButtonWidth:function(){var a=this.element.outerWidth(),b=this.options;/\d/.test(b.minWidth)&&a<b.minWidth&&(a=b.minWidth);this.button.width(a)},_setMenuWidth:function(){var a=this.menu,b=this.button.outerWidth()-parseInt(a.css("padding-left"),10)-parseInt(a.css("padding-right"),10)-parseInt(a.css("border-right-width"),10)-parseInt(a.css("border-left-width"),10);a.width(b||this.button.outerWidth())},_traverse:function(a,b){var c=d(b),f=38===a||37===a,c=c.parent()[f?"prevAll":"nextAll"]("li:not(.ui-multiselect-disabled, .ui-multiselect-optgroup-label)")[f?"last":"first"]();c.length?c.find("label").trigger("mouseover"):(c=this.menu.find("ul").last(),this.menu.find("label")[f? "last":"first"]().trigger("mouseover"),c.scrollTop(f?c.height():0))},_toggleState:function(a,b){return function(){this.disabled||(this[a]=b);b?this.setAttribute("aria-selected",!0):this.removeAttribute("aria-selected")}},_toggleChecked:function(a,b){var c=b&&b.length?b:this.inputs,f=this;c.each(this._toggleState("checked",a));c.eq(0).focus();this.update();var h=c.map(function(){return this.value}).get();this.element.find("option").each(function(){!this.disabled&&-1<d.inArray(this.value,h)&&f._toggleState("selected",a).call(this)});c.length&&this.element.trigger("change")},_toggleDisabled:function(a){this.button.attr({disabled:a,"aria-disabled":a})[a?"addClass":"removeClass"]("ui-state-disabled");var b=this.menu.find("input"),b=a?b.filter(":enabled").data("ech-multiselect-disabled",!0):b.filter(function(){return!0===d.data(this,"ech-multiselect-disabled")}).removeData("ech-multiselect-disabled");b.attr({disabled:a,"arial-disabled":a}).parent()[a?"addClass":"removeClass"]("ui-state-disabled");this.element.attr({disabled:a,"aria-disabled":a})},open:function(){var a=this.button,b=this.menu,c=this.speed,f=this.options,h=[];if(!(!1===this._trigger("beforeopen")||a.hasClass("ui-state-disabled")||this._isOpen)){var g=b.find("ul").last(),e=f.show,i=a.offset();d.isArray(f.show)&&(e=f.show[0],c=f.show[1]||this.speed);e&&(h=[e,c]);g.scrollTop(0).height(f.height);d.ui.position&&!d.isEmptyObject(f.position)?(f.position.of=f.position.of||a,b.show().position(f.position).hide()):b.css({top:i.top+a.outerHeight(),left:i.left});d.fn.show.apply(b,h);this.labels.eq(0).trigger("mouseover").trigger("mouseenter").find("input").trigger("focus");a.addClass("ui-state-active");this._isOpen=!0;this._trigger("open")}},close:function(){if(!1!==this._trigger("beforeclose")){var a=this.options,b=a.hide,c=this.speed,f=[];d.isArray(a.hide)&&(b=a.hide[0],c=a.hide[1]||this.speed);b&&(f=[b,c]);d.fn.hide.apply(this.menu,f);this.button.removeClass("ui-state-active").trigger("blur").trigger("mouseleave");this._isOpen=!1;this._trigger("close")}},enable:function(){this._toggleDisabled(!1)},disable:function(){this._toggleDisabled(!0)},checkAll:function(){this._toggleChecked(!0);this._trigger("checkAll")},uncheckAll:function(){this._toggleChecked(!1);this._trigger("uncheckAll")},getChecked:function(){return this.menu.find("input").filter(":checked")},destroy:function(){d.Widget.prototype.destroy.call(this);this.button.remove();this.menu.remove();this.element.show();return this},isOpen:function(){return this._isOpen},widget:function(){return this.menu},getButton:function(){return this.button},_setOption:function(a,b){var c=this.menu;switch(a){case "header":c.find("div.ui-multiselect-header")[b?"show":"hide"]();break;case "checkAllText":c.find("a.ui-multiselect-all span").eq(-1).text(b);break;case "uncheckAllText":c.find("a.ui-multiselect-none span").eq(-1).text(b);break;case "height":c.find("ul").last().height(parseInt(b,10));break;case "minWidth":this.options[a]=parseInt(b,10);this._setButtonWidth();this._setMenuWidth();break;case "selectedText":case "selectedList":case "noneSelectedText":this.options[a]=b;this.update();break;case "classes":c.add(this.button).removeClass(this.options.classes).addClass(b);break;case "multiple":c.toggleClass("ui-multiselect-single",!b),this.options.multiple=b,this.element[0].multiple=b,this.refresh()}d.Widget.prototype._setOption.apply(this,arguments)}})})(jQuery);

/* ]]> */
</script>

	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.validate.min.js" type="text/javascript"></script>
	<script type="text/javascript">
/* <![CDATA[ */
(function ($) {
    if (!$.validator) {
        throw '$.validator is missing.';
    }

    var custom = function (value, element, methodName) {
        if (!methodName) {
            throw 'Invalid method.';
        }

        var method = window[methodName];
        if (!method) {
            throw 'Invalid method ' + methodName + '.';
        }

        return method.apply(this, [element, '-1', 1]);
    };
    $.validator.addMethod('customE', function (value, element, methodName) {
        return custom(value, element, methodName);
    });

    $.validator.addMethod('customW', function (value, element, methodName) {
        return custom(value, element, methodName);
    });

    $.validator.addMethod("date", function (value, element) {
        var check = false;
        if (!$("#" + element.id).hasClass("datetimepicker")) {
            var re = /^\d{1,2}\.\d{1,2}\.\d{4}$/;
            if (re.test(value)) {
                var adata = value.split('.');
                var day = parseInt(adata[0], 10);
                var month = parseInt(adata[1], 10);
                var year = parseInt(adata[2], 10);
                check = isValidDate(day, month, year);
            }
        }
        else {
            var re2 = /^\d{1,2}\.\d{1,2}\.\d{4}\s\d{1,2}:\d{1,2}$/;
            if (re2.test(value)) {
                var adata = value.split('.');
                var day = parseInt(adata[0], 10);
                var month = parseInt(adata[1], 10);
                var year = parseInt(adata[2], 10);
                var hours = parseInt(adata[3], 10);
                var minutes = parseInt(adata[4], 10);
                check = isValidDateTime(day, month, year, hours, minutes);
            }
        }

        return this.optional(element) || check;
    }, "Please enter a correct date");


    $.validator.addMethod("maxValue", function (value, element, arg) {
        var check = true;
        var max = parseFloat(arg);
        if (value > max)
            check = false;

        return this.optional(element) || check;
    }, "Bad value");

    $.validator.addMethod("minValue", function (value, element, arg) {
        var check = true;
        var min = parseFloat(arg);
        if (value < min)
            check = false;

        return this.optional(element) || check;
    }, "Bad value");

}(jQuery));

function isValidDate(day, month, year) {
    if (month < 1 || month > 12) {
        return false;
    }
    if (day < 1 || day > 31) {
        return false;
    }
    if ((month == 4 || month == 6 || month == 9 || month == 11) && day == 31) {
        return false;
    }
    if (month == 2) { // check for february 29th
        var isleap = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
        if (day > 29 || (day == 29 && !isleap)) {
            return false;
        }
    }
    return true;  // date is valid
}

function isValidDateTime(day, month, year, hours, minutes) {
    if (!isValidDate(day, month, year)) {
        return false;
    }

    if (hours < 0 || hours > 23) {
        return false;
    }
    if (minutes < 0 || minutes > 59) {
        return false;
    }

    return true;  // time is valid
}
/* ]]> */
</script>

	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/ego.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.form.plugins.js" type="text/javascript"></script>			
	<script type="text/javascript">
/* <![CDATA[ */
/// <reference path="jquery-1.4.1-vsdoc.js" />
$(document).ready(function () {
    InitStatusDialog();
});

function InitStatusDialog() {
    statusDialog.initDialog();
}

var statusDialog = {

    getDialog: function () {
        return $("#statusDialog");
    },

    initDialog: function () {
        var dlg = statusDialog.getDialog();

        dlg.dialog({ 
            'autoOpen': false,
            'modal': true,
            'title': 'Dialog',
            'resizable': 'disable',
            'width': '350px',
            'height': 'auto'
        });
    },

    showDialog: function () {
        statusDialog.getDialog().dialog('open');
    },

    hideDialog: function () {
        statusDialog.getDialog().dialog('close');
    },

    showProgress: function () {
        statusDialog.getDialog().find("#statusLoader").show();
    },

    hideProgress: function () {
        statusDialog.getDialog().find("#statusLoader").hide();
    },

    setTitle: function (title) {
        statusDialog.getDialog().dialog("option", "title", title);
    },

    setMessage: function (message) {
        statusDialog.getDialog().find("#statusMessage").text(message);
    },

    setOptions: function (options) {
        statusDialog.getDialog().dialog("option", options);
    }

}


/* ]]> */
</script>

	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.chosentree.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/jquery.treeselect.js" type="text/javascript"></script>
	<script src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Scripts/fillerSaver.js" type="text/javascript"></script>
	<script type="text/javascript">
/* <![CDATA[ */
var useAttachs = false;
var attachmentsDataArray = new Object();
var fillerUri = "http://localhost/eGO.Filler.WS/FillerService.svc/rest/";

$(document).ready(function () {
    $("#showXml").click(function () {
        ShowData();
    });

    $("#showXmlWithAttachments").click(function () {
        ShowDataWithAttachments();
    });

    $("#saveForm").click(function () {
        SaveXml();
    });

    $("#loadForm").click(function () {
        LoadXml(this.form);
    });

    $("#closeForm").click(function () {
        CloseForm();
    });

    $("#printForm").click(function () {
        PrintForm();
    });

    $("#validateForm").click(function () {
        ValidateForm();
    });

    $("#validateFormWithXsd").click(function () {
        ValidateFormWithXsd();
    });

    $("#validateFormWithServer").click(function () {
        ValidateFormWithServer();
    });

    $("#clearForm").click(function () {
        ClearForm(this.form);
    });

    $("#cancelForm").click(function () {
        CancelForm();
    });

    $("#saveAndCloseForm").click(function () {
        SaveAndCloseForm();
    });

    if (useAttachs) {
        ShowSavedForms();
        InitializeAttachmentFields();
    }
});

function InitializeAttachmentFields() {
    $('input:file').each(function () {
        document.getElementById($(this).attr('id')).addEventListener('change', HandleFileSelect, false);
    });
}

function GetData() {
    var xml = "<xml>";
    var hasMetadata = $("#mtd_formMetaData").length > 0;
    function processHtml() {
        var element = $(this);
        var isempty = 'isempty';
        if (element.attr(isempty) !== undefined && element.attr(isempty) == "true")
            return;
        var name = 'name';
        var layoutRow = 'layoutRow';
        var firstInput;
        if (element.hasClass(layoutRow)) {
            firstInput = element.children("input:first");
            if (firstInput.attr(name) != 'Attachments') {
                if (element.hasClass('hiddenSection')) {
                    xml += '<' + disableValidatorPrefix + firstInput.attr(name) + '>';
                } else {
                    xml += '<' + firstInput.attr(name) + '>';
                }
            }
        }

        if (element.is(':input')) {
            if (element.is(':file') || element.is(':button') || element.attr('LookupDetailInfo') == "true")
                return;

            if (element.parent().hasClass(layoutRow))
                return;

            var attr = element.attr(name);
            if (attr !== undefined) {
                var index = attr.indexOf(sign);
                if (index > -1) {
                    attr = attr.substr(0, index);
                }
                var checked = ':checked';
                var val;
                if (element.is(':radio')) {
                    if (element.is(checked)) {
                        var cleanName = GetValueWithoutIncremental(attr);

                        xml += '<' + cleanName + '>' + element.val() + '</' + cleanName + '>';
                    }
                }
                else if (element.is(':checkbox')) {                   
                     if (element.is(checked)) {
                        if (!hasMetadata) {
                            xml += '<' + attr + '>' + ((element.hasClass("checkBox")) ? 1 : element.val()) + '</' + attr + '>';
                        }
                        else {
                            xml += '<' + attr + '>' + ((element.hasClass("checkBox") && element.hasClass("xsd_boolean")) ? 1 : element.val()) + '</' + attr + '>';
                        }
                    }
                    else {
                        if (element.hasClass("checkBox")) {
                            if (!hasMetadata) {
                                xml += '<' + attr + '>' + 0 + '</' + attr + '>';
                            }
                            else {
                                if (element.hasClass("xsd_boolean")) {
                                    xml += '<' + attr + '>' + 0 + '</' + attr + '>';
                                }
                            }
                        }
                    }
                }
                else if (element.attr("multiple")) {
                    val = element.val() === null ? "" : element.val();
                    for (var i = 0, j = val.length; i < j; i++) {
                        xml += '<' + attr + '>' + HtmlEncode(val[i]) + '</' + attr + '>';
                    }
                }

                else {
                    val = element.val() === null ? "" : element.val();
                    xml += '<' + attr + '>' + HtmlEncode(val) + '</' + attr + '>';
                }
            }
        }

        if (element.attr(isempty) === undefined || element.attr(isempty) == "false")
            element.children().each(processHtml);

        if (element.hasClass(layoutRow)) {
            firstInput = element.children("input:first");
            if (firstInput.attr(name) != 'Attachments') {
                if (element.hasClass('hiddenSection')) {
                    xml += '</' + disableValidatorPrefix + firstInput.attr(name) + '>';
                } else {
                    xml += '</' + firstInput.attr(name) + '>';
                }
            }
        }
    }

    $('#main').children('div').each(processHtml);

    xml += "</xml>";

    var formId = GetFormId();
    var xmlns = GetMetadataNamespace();
    xml = xml.replace('<xml>', '<' + formId + xmlns + '>').replace('</xml>', '</' + formId + '>');

    return xml;
}

function GetMetadataNamespace() {
    var xmlns = '';
    var mtdNamespace = $('form').find("#mtd_namespace")[0];
    if (mtdNamespace != undefined) {
        mtdNamespace = mtdNamespace.innerHTML;
        if (mtdNamespace != undefined && mtdNamespace != xmlns) {
            xmlns = " xmlns='" + mtdNamespace + "'";
        }
    }
    return xmlns;
}

function GetValueWithoutIncremental(value) {
    var regEx = new RegExp(repeatingPostfix + "\\d+$");
    return value.replace(regEx, '');
}

function ShowData() {
    var xml = GetData();
    alert(decodeURIComponent(xml));
}

function ShowDataWithAttachments() {
    var xml = GetData();
    var formId = GetFormId();
    var xmlWithAttachments = xml.replace('</' + formId + '>', '');

    var attachmentsData = '';
    for (var key in attachmentsDataArray) {
        attachmentsData = attachmentsData + attachmentsDataArray[key];
    }

    xmlWithAttachments += '<Attachments>' + attachmentsData + '</Attachments>';
    xmlWithAttachments += '</' + formId + '>';

    var parentWindow = window.opener;
    parentWindow.setFinalXml(xmlWithAttachments);
}

function SaveXml() {
    localStorage.setItem(GetFormStorageKey(), GetData());

    var message = "Formular " + "'" + GetFormStorageKey().replace('ego_', '') + "'" + " bol uspesne ulozeny do lokalneho uloziska";
    alert(message);

    ShowSavedForms();
}

function LoadXml(form) {
    $(form).find(':input').each(function () {
        switch (this.type) {
            case 'password':
            case 'select-multiple':
            case 'select-one':
            case 'text':
            case 'textarea':
                {
                    $(this).val(FindValueInXml($(this).attr('id')));
                    break;
                }
            case 'checkbox':
            case 'radio':
                this.checked = false;
        }
    });
}

function FindValueInXml(elementName) {
    var xmlData = localStorage.getItem(GetFormStorageKey());
    var xmlDoc = $.parseXML(xmlData);
    var $xml = $(xmlDoc);

    var $xmlValue = $xml.find(elementName);

    return $xmlValue.text();
}

function ShowSavedForms() {
    var savedForms = "<span class='fieldContent'>";
    var savedFormsCount = 0;

    for (var i = 0; i < localStorage.length; i++) {
        if (localStorage.key(i) == GetFormStorageKey()) {
            savedForms += "<span>" + localStorage.key(i).substr(4) + "</span><br/>";
            savedFormsCount++;
        }
    }
    savedForms += "</span>";

    $('#lcellSavedForms').html(savedForms);
    var element = $("#savedFormsContainer");
    if (savedFormsCount > 0) {
        element.show();
    }
    else {
        element.hide();
    }
}

function PrintForm() {
    window.print();
}

function GetFormId() {
    return $('form').attr('ID');
}

function ValidateForm() {
    return $('#' + GetFormId()).valid();
}

function CloseForm() {
    var xml = GetData();
    var parentWindow = window.opener;

    try {
        var formId = parentWindow.getFormId();
        var eDoc = TranslateNativeToEDoc(xml, fillerUri + "TranslateNativeToEDoc", formId);

        parentWindow.setXmlData(eDoc);

        window.close();
    } catch (err) {
        alert('workdesk bol uzavretý');
    }
}

function CancelForm() {
    window.close();
}

function SaveAndCloseForm() {
    var form = $('#' + GetFormId());
    var $validator = form.validate();
    ValidateForm(form);

    if ($validator.numberOfInvalids() > 0) {
        if (confirm("Formulár obsahuje chyby. Naozaj ho chcete uložiť?")) {
            CloseForm();
        } else {
        }
    }
}

function GetAttachments() {
    var files = $('input[type="file"]')[0].files;
    var attachements = "";
    for (var i = 0; i < files.length; i++) {
        attachements += files[i].name + "<br/>";
    }

    return attachements;
}

function ClearForm(element) {
    $(element).find(':input').each(function () {
        switch (this.type) {
            case 'password':
            case 'select-multiple':
            case 'select-one':
            case 'text':
            case 'textarea':
                $(this).val('');
                break;
            case 'checkbox':
            case 'radio':
                this.checked = false;
        }
    });
}

function GetFormStorageKey() {
    var formId = GetFormId();
    return 'ego_' + formId;
}

function HandleFileSelect(evt) {
    var files = evt.target.files;

    for (var i = 0, f; f = files[i]; i++) {
        var reader = new FileReader();

        reader.onload = (function (theFile) {
            return function (e) {
                attachmentsDataArray[evt.target.id] = '<Attachment><Name>' + theFile.name + '</Name><Type>' + theFile.type
                    + '</Type><Size>' + theFile.size + '</Size>' + '<Content>' + e.target.result + '</Content></Attachment>';
            };
        })(files[0]);

        reader.readAsDataURL(files[0]);
    }
}

function WrapXmlData(xml) {
    return "<FormDataXml><XmlData>" + xml + "</XmlData></FormDataXml>";
}

function TranslateNativeToEDoc(xml, url, formId) {
    var formDataXml = WrapXmlData(xml);
    var formData = '{"FormId": "' + formId + '", "FormDataXml": "' + formDataXml + '"}';

    var contentType = "application/json";

    var eDoc = "";
    $.ajax({
        type: 'POST',
        url: url,
        data: formData,
        contentType: contentType,
        success: function (result) {
            eDoc = result;
        },
        error: function (result) {
            alert(result);
        },
        async: false
    });

    return eDoc.Content;
}

function ValidateFormWithXsd() {
    var xml = GetData();
    var parentWindow = window.opener;

    try {
        var formId = parentWindow.getFormId();
        var valRes = CallValidateFormWithXsd(xml, fillerUri + "ValidateFormWithXsd", formId);

        ShowValidationResult(valRes, "xsdValidation");

    } catch (err) {
        alert(err);
    }
}

function ValidateFormWithServer() {
    var xml = GetData();
    var parentWindow = window.opener;

    try {
        var formId = parentWindow.getFormId();
        var valRes = CallValidateFormWithServer(xml, fillerUri + "ValidateForm", formId);

        ShowValidationResult(valRes, "serverValidation");

    } catch (err) {
        alert(err);
    }
}

function ShowValidationResult(result, validationType) {
    var valid = true;
    resultXML = $.parseXML(result),
    resultXMLTraversable = $(resultXML);
    responseCode = resultXMLTraversable.find("response > code").text();
    responseErrors = resultXMLTraversable.find("response > errors > error");
    responseXsltErrors = resultXMLTraversable.find("response > errors > xsltError");
    var ok = "ok";
    validatorObject.resetForm();

    if (responseCode == ok && responseErrors.length == 0 && responseXsltErrors.length == 0) {
        validatorObject.resetForm();
        statusDialog.hideProgress();
        statusDialog.setMessage(validationType === "xsdValidation" ? "Formulár je validný voči XSD schéme." : "Formulár je validný.");
        statusDialog.setOptions({ "buttons": { "Ok": function () { statusDialog.hideDialog(); } } });
        statusDialog.showDialog();
    }

    var valMsg = new Object;
    responseErrors.each(function (index, item) {
        AddValidationMessage(index, item, valMsg);
    });

    if (responseCode != ok || responseErrors.length != 0) {
        valid = false;
        validatorObject.settings.onfocusout = false;
        validatorObject.showErrors(valMsg);
        validatorObject.focusInvalid();
    }

    if (responseCode != ok || responseXsltErrors.length != 0) {
        valid = false;
        var xsltErrorDiv = $("#xsltErrorContainer");

        if (!xsltErrorDiv.length) {
            $('#errorsContainerDiv').after('<div id="xsltErrorContainer"></div>');
            xsltErrorDiv = $("#xsltErrorContainer");
        }
        else {
            xsltErrorDiv.empty();
        }

        responseXsltErrors.each(function (index, item) {
            var input = $(item);
            xsltErrorDiv.append('<li>' + input.text() + '</li>');
        });
    }
    else {
        var xsltErrorDiv = $('#xsltErrorContainer');
        if (xsltErrorDiv.length) {
            xsltErrorDiv.remove();
        }
    }
    return valid;
}

function CallValidateFormWithXsd(xml, url, formId) {
    var formDataXml = WrapXmlData(xml);
    var formData = '{"FormId": "' + formId + '", "FormDataXml": "' + formDataXml + '"}';

    var contentType = "application/json";

    var response = "";
    $.ajax({
        type: 'POST',
        url: url,
        data: formData,
        contentType: contentType,
        success: function (result) {
            response = result;
        },
        error: function (result) {
            alert(result);
        },
        async: false
    });

    return response.Details;
}

function CallValidateFormWithServer(xml, url, formId) {
    var formDataXml = WrapXmlData(xml);
    var formData = '{"FormId": "' + formId + '", "FormDataXml": "' + formDataXml + '"}';

    var contentType = "application/json";

    var response = "";
    $.ajax({
        type: 'POST',
        url: url,
        data: formData,
        contentType: contentType,
        success: function (result) {
            response = result;
        },
        error: function (result) {
            alert(result);
        },
        async: false
    });

    return response.Content;
}

function GetConfigurationValue(key, url, callbackName) {
    var values = "ConfigurationKey=" + key;
    var contentType = "application/json";

    $.ajax({
        url: url,
        dataType: "jsonp",
        contentType: contentType,
        data: values,
        jsonpCallback: callbackName,
        jsonp: 'callback'
    });
}

function HtmlEncode(value) {
    if (value != null) {
        value = value.replace(/\n/gi, "%0A");
        value = value.replace(/\\/gi, "%0B");
        value = value.replace(/"/gi, "%0X");
        return $('<div/>').text(value).html();
    }
    return value;
}

function DisableForm() { $('form :input').attr('disabled', true); }

function EnableForm() { $('form :input').removeAttr('disabled'); }
/* ]]> */
</script>

	<script type="text/javascript">
/* <![CDATA[ */
$(document).ready(InitMultipleLineLabelStyle);

function InitMultipleLineLabelStyle() {
    $(document).find("label.fieldLabel,span.fieldLabel").each(function () {
        var element = $(this);
        var lines = (element.height() / 34);
        if (lines > 1) {
            var marginBottom = 5 * (lines - 1);
            var newStyle = element.attr("style") + "; margin-bottom: " + marginBottom.toString() + "px;";
            element.attr("style", newStyle);
        }
    });
}
/* ]]> */
</script>

		<script type="text/javascript">
		var projectType = 'UPVS';
				$(document).ready(function () {
			$("#cancelForm").click(function () {
				CancelForm();
			});

			$("#validateForm").click(function () {
				ValidateForm();
			});

			$("#clearForm").click(function () {
				ClearForm(this.form);
			});

			$("#loadFormXml").click(function () {
				LoadFromFile();
			});

			$("#saveToXml").click(function () {
				SaveXmlAs();
			});
		});
		
		
					/* <![CDATA[ */
		
		
		
		
		function GetExternalResourceIndex(resourcetype) {
  switch (resourcetype) {
    default:
      return null;
  }
  return null;
}
function GetExternalResource(resourcetype, index) {
  switch (resourcetype) {
    default:
      return null;
  }
  return null;
}

		function SetDefaultValue(key, value) {
  if (value == '' || key == '') {
    return;
	}
}
function GetDefaultValue() {
  var retString = '';
  return retString;
}

				function InitConditionalRules(context, sid) {
			if (sid == null) {

			$(document).ready(function () {
$("[id|='OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode']").mask("Y999 99", {'translation': { Y: {pattern: /[+,-]/, optional: true} }});
$("[id|='NehnutelnostAdresaNehnutelnostiPSC_PostalCode']").mask("Y999 99", {'translation': { Y: {pattern: /[+,-]/, optional: true} }});
$("[id|='ZiadatelFOTrvalyPobytAdresaPSC_PostalCode']").mask("Y999 99", {'translation': { Y: {pattern: /[+,-]/, optional: true} }});
});

			
			
			
			
			}
		}
						

		var validatorObject = null;
		
		function InitValidation() {
			validatorObject = $("#eForm_eGov_001").validate({
							errorLabelContainer: $("#errorsContainer"),
				wrapper: "li",
				onkeyup: false,
				onclick: false,
		        ignore: ".disableValidators",
								rules: {
			  		OsobyUzivajucePocet :
{
required: true
},

OsobyUzivajuceZoznamMeno_GivenName :
{
required: true
},

OsobyUzivajuceZoznamPriezvisko_FamilyName :
{
required: true
},


OsobyUzivajuceZoznamTypPobytu :
{
required: true
},


OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality :
{
required: true
},

OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName :
{
required: true
},

OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber :
{
required: true
},





OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode :
{
maxlength: 6
},


NehnutelnostAdresaNehnutelnostiObec_Municipality :
{
required: true
},

NehnutelnostAdresaNehnutelnostiUlica_StreetName :
{
required: true
},

NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber :
{
required: true
},





NehnutelnostAdresaNehnutelnostiPSC_PostalCode :
{
maxlength: 6
},









OchranaOsobnychUdajovSuhlas :
{
required: true
},













ZiadatelFODorucenieAdresaPSC_PostalCode :
{
maxlength: 5
},


ZiadatelFODetailMeno_GivenName :
{
required: true
},

ZiadatelFODetailRC :
{
required: true
},

ZiadatelFODetailPriezvisko_FamilyName :
{
required: true
},




ZiadatelFOTrvalyPobytAdresaObec_Municipality :
{
required: true
},

ZiadatelFOTrvalyPobytAdresaUlica_StreetName :
{
required: true
},

ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber :
{
required: true
},





ZiadatelFOTrvalyPobytAdresaPSC_PostalCode :
{
maxlength: 6
},









ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode :
{
maxlength: 5
}
			  	},
				messages: {			
			   		OsobyUzivajucePocet :
{
required: "Položka 'Počet osôb, ktoré využívajú nehnuteľnosť, resp. majú prihlásený trvalý alebo prechodný pobyt, majú právo užívať nehnuteľnosť na uvedenej adrese' musí byť vyplnená"
},

OsobyUzivajuceZoznamMeno_GivenName :
{
required: "Položka 'Meno' musí byť vyplnená"
},

OsobyUzivajuceZoznamPriezvisko_FamilyName :
{
required: "Položka 'Priezvisko' musí byť vyplnená"
},

OsobyUzivajuceZoznamMeno_DateOfBirth :
{
date: "Položka 'Dátum narodenia' má neplatný formát"
},

OsobyUzivajuceZoznamTypPobytu :
{
required: "Položka 'Označenie pobytu' musí byť vyplnená"
},


OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality :
{
required: "Položka 'Obec' musí byť vyplnená"
},

OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName :
{
required: "Položka 'Ulica' musí byť vyplnená"
},

OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber :
{
required: "Položka 'Súp.č.' musí byť vyplnená"
},





OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 6 znakov"
},


NehnutelnostAdresaNehnutelnostiObec_Municipality :
{
required: "Položka 'Obec' musí byť vyplnená"
},

NehnutelnostAdresaNehnutelnostiUlica_StreetName :
{
required: "Položka 'Ulica' musí byť vyplnená"
},

NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber :
{
required: "Položka 'Súp.č.' musí byť vyplnená"
},





NehnutelnostAdresaNehnutelnostiPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 6 znakov"
},









OchranaOsobnychUdajovSuhlas :
{
required: "Položka 'Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona.' musí byť vyplnená"
},













ZiadatelFODorucenieAdresaPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 5 znakov"
},


ZiadatelFODetailMeno_GivenName :
{
required: "Položka 'Meno' musí byť vyplnená"
},

ZiadatelFODetailRC :
{
required: "Položka 'Rodné číslo' musí byť vyplnená"
},

ZiadatelFODetailPriezvisko_FamilyName :
{
required: "Položka 'Priezvisko' musí byť vyplnená"
},


ZiadatelFODetailDatumNarodenia_DateOfBirth :
{
date: "Položka 'Dátum narodenia' má neplatný formát"
},


ZiadatelFOTrvalyPobytAdresaObec_Municipality :
{
required: "Položka 'Obec' musí byť vyplnená"
},

ZiadatelFOTrvalyPobytAdresaUlica_StreetName :
{
required: "Položka 'Ulica' musí byť vyplnená"
},

ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber :
{
required: "Položka 'Súp.č.' musí byť vyplnená"
},





ZiadatelFOTrvalyPobytAdresaPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 6 znakov"
},









ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode :
{
maxlength: "Maximálna dĺžka položky 'PSČ' musí byť: 5 znakov"
}	  	
			  	}
			});
	  	}
	/* ]]> */
			</script>
	<style type="text/css">
		.infoIcon {display:none;}
.logo img {width:100px; height:120px;}
.LabelBold{font-weight: bold;}
.VecNazovFrm {font-size:26px;font-weight:bold;text-align: center;text-transform: uppercase;}
.OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country_internal{width:110px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality_internal{width:110px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber_internal{width:50px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region_internal{width:110px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber_internal{width:50px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County_internal{width:110px;}.OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode_internal{width:50px;}.NehnutelnostAdresaNehnutelnostiStat_Country_internal{width:110px;}.NehnutelnostAdresaNehnutelnostiObec_Municipality_internal{width:110px;}.NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber_internal{width:50px;}.NehnutelnostAdresaNehnutelnostiKraj_Region_internal{width:110px;}.NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber_internal{width:50px;}.NehnutelnostAdresaNehnutelnostiOkres_County_internal{width:110px;}.NehnutelnostAdresaNehnutelnostiPSC_PostalCode_internal{width:50px;}.HeaderNazov_internal{width:500px;}.ZiadatelFODorucenieAdresaStat_Country_internal{width:110px;}.ZiadatelFODorucenieAdresaObec_Municipality_internal{width:110px;}.ZiadatelFODorucenieAdresaKraj_Region_internal{width:110px;}.ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber_internal{width:50px;}.ZiadatelFODorucenieAdresaOrC_BuildingNumber_internal{width:50px;}.ZiadatelFODorucenieAdresaOkres_County_internal{width:110px;}.ZiadatelFODorucenieAdresaPSC_PostalCode_internal{width:50px;}.ZiadatelFODetailTitulPred_PrefixQualificationAffix_internal{width:60px;}.ZiadatelFODetailTitulZa_PostfixQualificationAffix_internal{width:60px;}.ZiadatelFOTrvalyPobytAdresaStat_Country_internal{width:110px;}.ZiadatelFOTrvalyPobytAdresaObec_Municipality_internal{width:110px;}.ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber_internal{width:50px;}.ZiadatelFOTrvalyPobytAdresaKraj_Region_internal{width:110px;}.ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber_internal{width:50px;}.ZiadatelFOTrvalyPobytAdresaOkres_County_internal{width:110px;}.ZiadatelFOTrvalyPobytAdresaPSC_PostalCode_internal{width:50px;}.ZiadatelFOPrechodnyPobytAdresaStat_Country_internal{width:110px;}.ZiadatelFOPrechodnyPobytAdresaObec_Municipality_internal{width:110px;}.ZiadatelFOPrechodnyPobytAdresaKraj_Region_internal{width:110px;}.ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber_internal{width:50px;}.ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber_internal{width:50px;}.ZiadatelFOPrechodnyPobytAdresaOkres_County_internal{width:110px;}.ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode_internal{width:50px;}.ZiadatelFOKontaktEmailAdresa_internal{width:220px;}.SposobDoruceniaVystupuKontakt_internal{width:210px;}
	</style>

<!--[if gte mso 9]><xml>
<mso:CustomDocumentProperties>
<mso:eFormDocDescription msdt:dt="string">Prázdny html formulár</mso:eFormDocDescription>
<mso:eFormDocIdentifier msdt:dt="string">form.156.html</mso:eFormDocIdentifier>
<mso:eFormDocLanguage msdt:dt="string">sk</mso:eFormDocLanguage>
<mso:eFormDocType msdt:dt="string">CLS_F_HTML_FORM</mso:eFormDocType>
</mso:CustomDocumentProperties>
</xml><![endif]-->
</head>
<body>
	<noscript><p class="noscript">Pre kompletnú funkčnosť aplikácie je potrebné povoliť JavaScript</p></noscript>
	<div id="errorsContainerDiv" class="errorsContainerDiv"> <ul id="errorsContainer" class="errorsContainer"><li/></ul> </div>
	<form id="eForm_eGov_001" action="">
		<div id="main" class="layoutMain ui-widget-content">	
						 
		<div id="layoutRow9892" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="SekciaObec" />
				<div id="layoutRowContentlayoutRow9892" class="columns">
				
				<div id="layoutColumn18618" class="column first"  style="width:150px;">
											
<div id="layoutCell48466" class="cell  logo" >		
			
		<span class="fieldContent" style="display: none"><img src="https://www.slovensko.sk/static/eForm/Designer/2.0.1.13/Images/Logo" alt="" title=""/></span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18619" class="column "  style="width:500px;">
											
<div id="layoutCell48467" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_MsU"  style="width:450px;">Mesto Nitra: Mestský úrad Nitra, Štefánikova trieda 60, 950 06 Nitra </label><span class="fieldContent" style="display: none"><input id="Obec_MsU" name="Obec_MsU" title="" type="text" class="xsd_string textBox "  maxlength="400" size="340"  alt="" value="Mestský úrad Nitra, Štefánikova trieda 60, 950 06 Nitra" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Mesto Nitra: Mestský úrad Nitr" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48468" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_Telefon"  style="width:250px;">Telefón: 037/65 02 111 </label><span class="fieldContent" style="display: none"><input id="Obec_Telefon" name="Obec_Telefon" title="" type="text" class="xsd_string textBox "  maxlength="400" size="150"  alt="" value="037/65 02 111" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Telefón: 037/65 02 111" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48469" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_BankoveSpojenie"  style="width:290px;">IBAN: SK0409000000005028001139 </label><span class="fieldContent" style="display: none"><input id="Obec_BankoveSpojenie" name="Obec_BankoveSpojenie" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="SK0409000000005028001139" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "IBAN: SK0409000000005028001139" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18620" class="column "  style="width:150px;">
											
<div id="layoutCell48471" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_ICO"  style="width:150px;">IČO: 00308307 </label><span class="fieldContent" style="display: none"><input id="Obec_ICO" name="Obec_ICO" title="" type="text" class="xsd_string textBox "  maxlength="400" size="100"  alt="" value="00308307" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "IČO: 00308307" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48472" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_DIC"  style="width:150px;">DIČ: 2021102853 </label><span class="fieldContent" style="display: none"><input id="Obec_DIC" name="Obec_DIC" title="" type="text" class="xsd_string textBox "  maxlength="400" size="100"  alt="" value="2021102853" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "DIČ: 2021102853" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48470" class="cell  LabelBold" >		
			
		<label class="fieldLabel" title="" for="Obec_Email"  style="width:150px;">E-mail: info@nitra.sk </label><span class="fieldContent" style="display: none"><input id="Obec_Email" name="Obec_Email" title="" type="text" class="xsd_string textBox "  maxlength="400" size="100"  alt="" value="info@nitra.sk" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "E-mail: info@nitra.sk" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
						<div id="layoutRow9893" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="sekciaHeader" />
				<div id="layoutRowContentlayoutRow9893" class="columns">
				
				<div id="layoutColumn18621" class="column first" >
											
<div id="layoutCell48474" class="cell  VecNazovFrm" >		
			
		<span class="fieldLabel" title=""   style="width:850px;">Ohlásenie k miestnemu poplatku za komunálne odpady a drobné stavebné odpady pre vlastníka resp. užívateľa nehnuteľnosti určenej na bývanie  </span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
						<div id="layoutRow9897" class="layoutRow ui-tabs ui-widget-content   NezobrazovatInfoIkonuRemoteLookup "   title="" >
						<input type="hidden" name="sekciaZiadatelFO_PhysicalPerson" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Meno a priezvisko užívateľa resp. vlastníka nehnuteľnosti určenej na bývanie - (FO):">Meno a priezvisko užívateľa resp. vlastníka nehnuteľnosti určenej na bývanie - (FO):			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9897" class="columns">
				
				<div id="layoutColumn18626" class="column first" >
											
<div id="layoutCell48494" class="cell " >		
			 
		<div id="layoutRow9899" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="sekciaZiadatelFODetail" />
				<div id="layoutRowContentlayoutRow9899" class="columns">
				
				<div id="layoutColumn18630" class="column first"  style="width:400px;">
											
<div id="layoutCell48496" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailTitulPred_PrefixQualificationAffix"  style="width:125px;">Titul pred menom </label><div class="fieldContent">
<input id="ZiadatelFODetailTitulPred_PrefixQualificationAffix" type="text"  value="" alt="" name="ZiadatelFODetailTitulPred_PrefixQualificationAffix" class="xsd_string remoteLookup ZiadatelFODetailTitulPred_PrefixQualificationAffix_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulPred_PrefixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0062</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Titul pred menom" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulPred_PrefixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0062</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulPred_PrefixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0062</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48497" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailMeno_GivenName"  style="width:125px;">Meno <em>*</em></label><span class="fieldContent"><input id="ZiadatelFODetailMeno_GivenName" name="ZiadatelFODetailMeno_GivenName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Meno" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48498" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailRC"  style="width:125px;">Rodné číslo <em>*</em></label><span class="fieldContent"><input id="ZiadatelFODetailRC" name="ZiadatelFODetailRC" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Rodné číslo" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18631" class="column "  style="width:400px;">
											
<div id="layoutCell48500" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailTitulZa_PostfixQualificationAffix"  style="width:125px;">Titul za menom </label><div class="fieldContent">
<input id="ZiadatelFODetailTitulZa_PostfixQualificationAffix" type="text"  value="" alt="" name="ZiadatelFODetailTitulZa_PostfixQualificationAffix" class="xsd_string remoteLookup ZiadatelFODetailTitulZa_PostfixQualificationAffix_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulZa_PostfixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0063</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Titul za menom" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulZa_PostfixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0063</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODetailTitulZa_PostfixQualificationAffix</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0063</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48499" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailPriezvisko_FamilyName"  style="width:125px;">Priezvisko <em>*</em></label><span class="fieldContent"><input id="ZiadatelFODetailPriezvisko_FamilyName" name="ZiadatelFODetailPriezvisko_FamilyName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Priezvisko" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48501" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODetailDatumNarodenia_DateOfBirth"  style="width:125px;">Dátum narodenia </label><span class="fieldContent"><input alt="" id="ZiadatelFODetailDatumNarodenia_DateOfBirth" name="ZiadatelFODetailDatumNarodenia_DateOfBirth" title="" type="text" class="xsd_string date datepicker " value="" maxlength="14" size="160"  ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Dátum narodenia" hodnotu v tvare "deň.mesiac.rok" ("DD.MM.RRRR") alebo vyberte z ponuky.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
					
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48502" class="cell " >		
			 
		<div id="layoutRow9900" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa trvalého pobytu">Adresa trvalého pobytu			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9900" class="columns">
				
				<div id="layoutColumn18632" class="column first"  style="width:290px;">
											
<div id="layoutCell48503" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaStat_Country"  style="width:45px;">Štát </label><div class="fieldContent">
<input id="ZiadatelFOTrvalyPobytAdresaStat_Country" type="text"  value="" alt="" name="ZiadatelFOTrvalyPobytAdresaStat_Country" class="xsd_string remoteLookup ZiadatelFOTrvalyPobytAdresaStat_Country_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48504" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaObec_Municipality"  style="width:45px;">Obec <em>*</em></label><div class="fieldContent">
<input id="ZiadatelFOTrvalyPobytAdresaObec_Municipality" type="text"  value="" alt="" name="ZiadatelFOTrvalyPobytAdresaObec_Municipality" class="xsd_string remoteLookup ZiadatelFOTrvalyPobytAdresaObec_Municipality_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48505" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaUlica_StreetName"  style="width:45px;">Ulica <em>*</em></label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaUlica_StreetName" name="ZiadatelFOTrvalyPobytAdresaUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18633" class="column "  style="width:280px;">
											
<div id="layoutCell48507" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaKraj_Region"  style="width:20px;">Kraj </label><div class="fieldContent">
<input id="ZiadatelFOTrvalyPobytAdresaKraj_Region" type="text"  value="" alt="" name="ZiadatelFOTrvalyPobytAdresaKraj_Region" class="xsd_string remoteLookup ZiadatelFOTrvalyPobytAdresaKraj_Region_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48508" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaCastObce_District"  style="width:60px;">Časť obce </label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaCastObce_District" name="ZiadatelFOTrvalyPobytAdresaCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="150"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48506" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber"  style="width:60px;">Súp.č. <em>*</em></label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber" name="ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18634" class="column "  style="width:280px;">
											
<div id="layoutCell48510" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaOkres_County"  style="width:20px;">Okres </label><div class="fieldContent">
<input id="ZiadatelFOTrvalyPobytAdresaOkres_County" type="text"  value="" alt="" name="ZiadatelFOTrvalyPobytAdresaOkres_County" class="xsd_string remoteLookup ZiadatelFOTrvalyPobytAdresaOkres_County_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48511" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaPSC_PostalCode"  style="width:20px;">PSČ </label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaPSC_PostalCode" name="ZiadatelFOTrvalyPobytAdresaPSC_PostalCode" title="" type="text" class="xsd_string textBox ZiadatelFOTrvalyPobytAdresaPSC_PostalCode_internal"  maxlength="6" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48509" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber"  style="width:20px;">Or.č. </label><span class="fieldContent"><input id="ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber" name="ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber" title="" type="text" class="xsd_string textBox ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber_internal"  maxlength="400" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
					
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48515" class="cell " >		
			 
		<div id="layoutRow9902" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaZiadatelFOPrechodnyPobytAdresa" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9902" class="columns">
				
				<div id="layoutColumn18637" class="column first"  style="width:290px;">
											
<div id="layoutCell48516" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaStat_Country"  style="width:45px;">Štát </label><div class="fieldContent">
<input id="ZiadatelFOPrechodnyPobytAdresaStat_Country" type="text"  value="" alt="" name="ZiadatelFOPrechodnyPobytAdresaStat_Country" class="xsd_string remoteLookup ZiadatelFOPrechodnyPobytAdresaStat_Country_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48517" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaObec_Municipality"  style="width:45px;">Obec </label><div class="fieldContent">
<input id="ZiadatelFOPrechodnyPobytAdresaObec_Municipality" type="text"  value="" alt="" name="ZiadatelFOPrechodnyPobytAdresaObec_Municipality" class="xsd_string remoteLookup ZiadatelFOPrechodnyPobytAdresaObec_Municipality_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48518" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaUlica_StreetName"  style="width:45px;">Ulica </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaUlica_StreetName" name="ZiadatelFOPrechodnyPobytAdresaUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18638" class="column "  style="width:280px;">
											
<div id="layoutCell48519" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaKraj_Region"  style="width:20px;">Kraj </label><div class="fieldContent">
<input id="ZiadatelFOPrechodnyPobytAdresaKraj_Region" type="text"  value="" alt="" name="ZiadatelFOPrechodnyPobytAdresaKraj_Region" class="xsd_string remoteLookup ZiadatelFOPrechodnyPobytAdresaKraj_Region_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48520" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaCastObce_District"  style="width:60px;">Časť obce </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaCastObce_District" name="ZiadatelFOPrechodnyPobytAdresaCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48521" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber"  style="width:60px;">Súp.č. </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber" name="ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18639" class="column "  style="width:280px;">
											
<div id="layoutCell48523" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaOkres_County"  style="width:20px;">Okres </label><div class="fieldContent">
<input id="ZiadatelFOPrechodnyPobytAdresaOkres_County" type="text"  value="" alt="" name="ZiadatelFOPrechodnyPobytAdresaOkres_County" class="xsd_string remoteLookup ZiadatelFOPrechodnyPobytAdresaOkres_County_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFOPrechodnyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48524" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode"  style="width:20px;">PSČ </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode" name="ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode" title="" type="text" class="xsd_string textBox ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode_internal"  maxlength="5" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48522" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber"  style="width:20px;">Or.č. </label><span class="fieldContent"><input id="ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber" name="ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber" title="" type="text" class="xsd_string textBox ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber_internal"  maxlength="400" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
					<div id="repetitionCommandslayoutRow9902" class="sectionPager">
								<span id="addSectionlayoutRow9902" class="button addRemoveSection" onclick="addSection(0, 1, this)" title="Pridať sekciu Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Pridať</span>
				<span id="removeSectionlayoutRow9902" class="button addRemoveSection" onclick="removeSection(0, this)" title="Odobrať sekciu Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Odobrať</span>	
			</div>
			</div>	
						<script type="text/javascript">$(document).ready(function () { initRepetitionSection(0, 1, 'layoutRow9902') })</script>
					
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48484" class="cell " >		
			 
		<div id="layoutRow9898" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaZiadatelFODorucenieAdresa_DeliveryAddress" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9898" class="columns">
				
				<div id="layoutColumn18627" class="column first"  style="width:290px;">
											
<div id="layoutCell48485" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaStat_Country"  style="width:45px;">Štát </label><div class="fieldContent">
<input id="ZiadatelFODorucenieAdresaStat_Country" type="text"  value="" alt="" name="ZiadatelFODorucenieAdresaStat_Country" class="xsd_string remoteLookup ZiadatelFODorucenieAdresaStat_Country_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48486" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaObec_Municipality"  style="width:45px;">Obec </label><div class="fieldContent">
<input id="ZiadatelFODorucenieAdresaObec_Municipality" type="text"  value="" alt="" name="ZiadatelFODorucenieAdresaObec_Municipality" class="xsd_string remoteLookup ZiadatelFODorucenieAdresaObec_Municipality_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48487" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaUlica_StreetName"  style="width:45px;">Ulica </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaUlica_StreetName" name="ZiadatelFODorucenieAdresaUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18628" class="column "  style="width:280px;">
											
<div id="layoutCell48488" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaKraj_Region"  style="width:20px;">Kraj </label><div class="fieldContent">
<input id="ZiadatelFODorucenieAdresaKraj_Region" type="text"  value="" alt="" name="ZiadatelFODorucenieAdresaKraj_Region" class="xsd_string remoteLookup ZiadatelFODorucenieAdresaKraj_Region_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48489" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaCastObce_District"  style="width:60px;">Časť obce </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaCastObce_District" name="ZiadatelFODorucenieAdresaCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48490" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber"  style="width:60px;">Súp.č. </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber" name="ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18629" class="column "  style="width:280px;">
											
<div id="layoutCell48492" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaOkres_County"  style="width:20px;">Okres </label><div class="fieldContent">
<input id="ZiadatelFODorucenieAdresaOkres_County" type="text"  value="" alt="" name="ZiadatelFODorucenieAdresaOkres_County" class="xsd_string remoteLookup ZiadatelFODorucenieAdresaOkres_County_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">ZiadatelFODorucenieAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48493" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaPSC_PostalCode"  style="width:20px;">PSČ </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaPSC_PostalCode" name="ZiadatelFODorucenieAdresaPSC_PostalCode" title="" type="text" class="xsd_string textBox ZiadatelFODorucenieAdresaPSC_PostalCode_internal"  maxlength="5" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48491" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFODorucenieAdresaOrC_BuildingNumber"  style="width:20px;">Or.č. </label><span class="fieldContent"><input id="ZiadatelFODorucenieAdresaOrC_BuildingNumber" name="ZiadatelFODorucenieAdresaOrC_BuildingNumber" title="" type="text" class="xsd_string textBox ZiadatelFODorucenieAdresaOrC_BuildingNumber_internal"  maxlength="400" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
					<div id="repetitionCommandslayoutRow9898" class="sectionPager">
								<span id="addSectionlayoutRow9898" class="button addRemoveSection" onclick="addSection(0, 1, this)" title="Pridať sekciu Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Pridať</span>
				<span id="removeSectionlayoutRow9898" class="button addRemoveSection" onclick="removeSection(0, this)" title="Odobrať sekciu Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)">Odobrať</span>	
			</div>
			</div>	
						<script type="text/javascript">$(document).ready(function () { initRepetitionSection(0, 1, 'layoutRow9898') })</script>
					
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell67219" class="cell " >		
			 
		<div id="layoutRow13986" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaZiadatelFOKontakt" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Kontakt">Kontakt			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow13986" class="columns">
				
				<div id="layoutColumn26417" class="column first"  style="width:400px;">
											
<div id="layoutCell67220" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOKontaktTelCislo_TelephoneAddress"  style="width:125px;">Telefónne číslo </label><span class="fieldContent"><input id="ZiadatelFOKontaktTelCislo_TelephoneAddress" name="ZiadatelFOKontaktTelCislo_TelephoneAddress" title="" type="text" class="xsd_string textBox "  maxlength="400" size="100"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Telefónne číslo" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn26418" class="column "  style="width:400px;">
											
<div id="layoutCell67221" class="cell " >		
			
		<label class="fieldLabel" title="" for="ZiadatelFOKontaktEmailAdresa"  style="width:120px;">E-mailová adresa </label><span class="fieldContent"><input id="ZiadatelFOKontaktEmailAdresa" name="ZiadatelFOKontaktEmailAdresa" title="" type="text" class="xsd_string textBox ZiadatelFOKontaktEmailAdresa_internal"  maxlength="400" size="220"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "E-mailová adresa" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
					
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
						<div id="layoutRow5343" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaNehnutelnost" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Nehnuteľnosť">Nehnuteľnosť			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow5343" class="columns">
				
				<div id="layoutColumn9892" class="column first" >
											
<div id="layoutCell48536" class="cell " >		
			 
		<div id="layoutRow9905" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa nehnuteľnosti">Adresa nehnuteľnosti			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9905" class="columns">
				
				<div id="layoutColumn18644" class="column first"  style="width:290px;">
											
<div id="layoutCell48537" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiStat_Country"  style="width:45px;">Štát </label><div class="fieldContent">
<input id="NehnutelnostAdresaNehnutelnostiStat_Country" type="text"  value="" alt="" name="NehnutelnostAdresaNehnutelnostiStat_Country" class="xsd_string remoteLookup NehnutelnostAdresaNehnutelnostiStat_Country_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48538" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiObec_Municipality"  style="width:45px;">Obec <em>*</em></label><div class="fieldContent">
<input id="NehnutelnostAdresaNehnutelnostiObec_Municipality" type="text"  value="" alt="" name="NehnutelnostAdresaNehnutelnostiObec_Municipality" class="xsd_string remoteLookup NehnutelnostAdresaNehnutelnostiObec_Municipality_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48539" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiUlica_StreetName"  style="width:45px;">Ulica <em>*</em></label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiUlica_StreetName" name="NehnutelnostAdresaNehnutelnostiUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18645" class="column "  style="width:280px;">
											
<div id="layoutCell48541" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiKraj_Region"  style="width:20px;">Kraj </label><div class="fieldContent">
<input id="NehnutelnostAdresaNehnutelnostiKraj_Region" type="text"  value="" alt="" name="NehnutelnostAdresaNehnutelnostiKraj_Region" class="xsd_string remoteLookup NehnutelnostAdresaNehnutelnostiKraj_Region_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48542" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiCastObce_District"  style="width:60px;">Časť obce </label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiCastObce_District" name="NehnutelnostAdresaNehnutelnostiCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="150"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48540" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber"  style="width:60px;">Súp.č. <em>*</em></label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber" name="NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18646" class="column "  style="width:280px;">
											
<div id="layoutCell48544" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiOkres_County"  style="width:20px;">Okres </label><div class="fieldContent">
<input id="NehnutelnostAdresaNehnutelnostiOkres_County" type="text"  value="" alt="" name="NehnutelnostAdresaNehnutelnostiOkres_County" class="xsd_string remoteLookup NehnutelnostAdresaNehnutelnostiOkres_County_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">NehnutelnostAdresaNehnutelnostiOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48545" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiPSC_PostalCode"  style="width:20px;">PSČ </label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiPSC_PostalCode" name="NehnutelnostAdresaNehnutelnostiPSC_PostalCode" title="" type="text" class="xsd_string textBox NehnutelnostAdresaNehnutelnostiPSC_PostalCode_internal"  maxlength="6" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48543" class="cell " >		
			
		<label class="fieldLabel" title="" for="NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber"  style="width:20px;">Or.č. </label><span class="fieldContent"><input id="NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber" name="NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber" title="" type="text" class="xsd_string textBox NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber_internal"  maxlength="400" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
					
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
						<div id="layoutRow3122" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="sekciaOsobyUzivajuce" />
				<div id="layoutRowContentlayoutRow3122" class="columns">
				
				<div id="layoutColumn5795" class="column first" >
											
<div id="layoutCell14386" class="cell " >		
			 
		<div id="layoutRow3121" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaOsobyUzivajucePocet" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Počet osôb užívajúcich nehnuteľnosť">Počet osôb užívajúcich nehnuteľnosť			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow3121" class="columns">
				
				<div id="layoutColumn5794" class="column first" >
											
<div id="layoutCell14384" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajucePocet"  style="width:900px;">Počet osôb, ktoré využívajú nehnuteľnosť, resp. majú prihlásený trvalý alebo prechodný pobyt, majú právo užívať nehnuteľnosť na uvedenej adrese <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajucePocet" name="OsobyUzivajucePocet" title="" type="text" class="xsd_integer textBox " maxlength="400" size="190"  alt="" value="0" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Počet osôb, ktoré využívajú ne" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
					
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell14387" class="cell " >		
			 
		<div id="layoutRow3123" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaOsobyUzivajuceZoznam" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Prihlásená osoba">Prihlásená osoba			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow3123" class="columns">
				
				<div id="layoutColumn5796" class="column first"  style="width:220px;">
											
<div id="layoutCell22555" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamMeno_GivenName" >Meno <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajuceZoznamMeno_GivenName" name="OsobyUzivajuceZoznamMeno_GivenName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Meno" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn5797" class="column "  style="width:220px;">
											
<div id="layoutCell22558" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamPriezvisko_FamilyName" >Priezvisko <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajuceZoznamPriezvisko_FamilyName" name="OsobyUzivajuceZoznamPriezvisko_FamilyName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Priezvisko" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn5798" class="column "  style="width:220px;">
											
<div id="layoutCell22559" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamMeno_DateOfBirth" >Dátum narodenia </label><span class="fieldContent"><input alt="" id="OsobyUzivajuceZoznamMeno_DateOfBirth" name="OsobyUzivajuceZoznamMeno_DateOfBirth" title="" type="text" class="xsd_string date datepicker " value="" maxlength="14" size="160"  ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Dátum narodenia" hodnotu v tvare "deň.mesiac.rok" ("DD.MM.RRRR") alebo vyberte z ponuky.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn5799" class="column "  style="width:150px;">
											
<div id="layoutCell22560" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTypPobytu" >Označenie pobytu <em>*</em></label><span class="fieldContent"><select id="OsobyUzivajuceZoznamTypPobytu" name="OsobyUzivajuceZoznamTypPobytu" class="xsd_string comboBox " title=""  ><option value=""></option><option value="TP" >Trval&#253;</option><option value="PP" >Prechodn&#253;</option><option value="U" >Už&#237;vateľ</option><option value="PU" >Pr&#225;vo už&#237;vať</option></select><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Označenie pobytu" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18640" class="column " >
											
<div id="layoutCell48526" class="cell " >		
			 
		<div id="layoutRow9904" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Adresa trvalého pobytu">Adresa trvalého pobytu			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9904" class="columns">
				
				<div id="layoutColumn18641" class="column first"  style="width:290px;">
											
<div id="layoutCell48527" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country"  style="width:45px;">Štát </label><div class="fieldContent">
<input id="OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country" type="text"  value="" alt="" name="OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country" class="xsd_string remoteLookup OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Štát" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country</span><span class ="remoteSourceIdentifier"></span><span class ="remoteLookupCode">SUSR_0859</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48528" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality"  style="width:45px;">Obec <em>*</em></label><div class="fieldContent">
<input id="OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality" type="text"  value="" alt="" name="OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality" class="xsd_string remoteLookup OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Obec" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0025</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48529" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName"  style="width:45px;">Ulica <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName" name="OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName" title="" type="text" class="xsd_string textBox "  maxlength="400" size="0"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Ulica" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18642" class="column "  style="width:280px;">
											
<div id="layoutCell48531" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region"  style="width:20px;">Kraj </label><div class="fieldContent">
<input id="OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region" type="text"  value="" alt="" name="OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region" class="xsd_string remoteLookup OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kraj" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0023</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48532" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District"  style="width:60px;">Časť obce </label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District" name="OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District" title="" type="text" class="xsd_string textBox "  maxlength="400" size="150"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Časť obce" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48530" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber"  style="width:60px;">Súp.č. <em>*</em></label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber" name="OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber" title="" type="text" class="xsd_string textBox OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber_internal"  maxlength="400" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Súp.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18643" class="column "  style="width:280px;">
											
<div id="layoutCell48534" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County"  style="width:20px;">Okres </label><div class="fieldContent">
<input id="OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County" type="text"  value="" alt="" name="OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County" class="xsd_string remoteLookup OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County_internal textBox turned" title=""  ></input><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Okres" hodnotu  alebo vyberte z ponuky.</span></p></p></div></div>
<input class="LookupDetailInfo" type="hidden" />
<span class="lookupbutton ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only">Vybrať</span>
<div title="Info" class="LookupDetail"><div class="LookupDetailInfoText"></div><span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span></div>
<div title="Vyberte hodnotu" class="LookupForm" style="display: none;">
<span class="lookupConfiguration" style="display: none;"><span class ="lookupComponentId">OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County</span><span class ="remoteSourceIdentifier">REPMON</span><span class ="remoteLookupCode">SUSR_0024</span></span>
<div class="tableFilter">
Zadajte text:
<input class="tableFilterText ui-corner-all" type="text" />
<input class="FilterButton ui-button ui-widget ui-state-default ui-corner-all" type="button" value="Hľadať" alt="Hľadať" />
</div>
<table cellpadding="0" cellspacing="0" border="0" class="display LookupTable">
<thead>
<tr>
<th>Kód</th>
<th>Hodnota</th>
</tr>
</thead>
<tbody>
<tr>
<th></th>
<th></th>
</tr>
</tbody>
</table>
</div>
</div>
<span class="fieldInfo">
<span class="infoIcon ui-icon ui-icon-info"></span>
</span>
	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48535" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode"  style="width:20px;">PSČ </label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode" name="OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode" title="" type="text" class="xsd_string textBox OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode_internal"  maxlength="6" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "PSČ" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48533" class="cell " >		
			
		<label class="fieldLabel" title="" for="OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber"  style="width:20px;">Or.č. </label><span class="fieldContent"><input id="OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber" name="OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber" title="" type="text" class="xsd_string textBox OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber_internal"  maxlength="400" size="50"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Or.č." hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
					
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
					<div id="repetitionCommandslayoutRow3123" class="sectionPager">
								<span id="addSectionlayoutRow3123" class="button addRemoveSection" onclick="addSection(1, 10, this)" title="Pridať sekciu Prihlásená osoba">Pridať</span>
				<span id="removeSectionlayoutRow3123" class="button addRemoveSection" onclick="removeSection(1, this)" title="Odobrať sekciu Prihlásená osoba">Odobrať</span>	
			</div>
			</div>	
						<script type="text/javascript">$(document).ready(function () { initRepetitionSection(1, 10, 'layoutRow3123') })</script>
					
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
						<div id="layoutRow9894" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="SekciaOchranaOsobnychUdajov" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Ochrana osobných údajov">Ochrana osobných údajov			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9894" class="columns">
				
				<div id="layoutColumn18622" class="column first" >
											
<div id="layoutCell48476" class="cell " >		
			
		<input id="OchranaOsobnychUdajovSuhlas" name="OchranaOsobnychUdajovSuhlas" title="" type="checkbox" class="xsd_boolean checkBox " value="Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona." alt=""   ></input><label for="OchranaOsobnychUdajovSuhlas" class="checkBoxLabel">Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona.</label><br />
	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
						<div id="layoutRow9895" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaNotifikacie" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Notifikácie">Notifikácie			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow9895" class="columns">
				
				<div id="layoutColumn18623" class="column first"  style="width:550px;">
											
<div id="layoutCell48478" class="cell " >		
			
		<span class="fieldLabel" title=""  >Zasielanie upozornení  <div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Vyberte jednu z možností.</span></p></p></div></div></span><fieldset><legend></legend><div class="xsd_string radioButtonList "><span><input id="NotifikacieZasielanie" name="NotifikacieZasielanie" class="xsd_string radioButtonList " title="" type="radio" alt="1" value="1" checked="checked"  ></input><label for="NotifikacieZasielanie" class="optionLabel">Žiadne</label></span><span><input id="NotifikacieZasielaniePostfixList1" name="NotifikacieZasielanie" class="xsd_string radioButtonList " title="" type="radio" alt="2" value="2"   ></input><label for="NotifikacieZasielaniePostfixList1" class="optionLabel">eDesk</label></span><span><input id="NotifikacieZasielaniePostfixList2" name="NotifikacieZasielanie" class="xsd_string radioButtonList " title="" type="radio" alt="3" value="3"   ></input><label for="NotifikacieZasielaniePostfixList2" class="optionLabel">SMS</label></span><span><input id="NotifikacieZasielaniePostfixList3" name="NotifikacieZasielanie" class="xsd_string radioButtonList " title="" type="radio" alt="4" value="4"   ></input><label for="NotifikacieZasielaniePostfixList3" class="optionLabel">E-mail</label></span></div></fieldset>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn18624" class="column "  style="width:300px;">
											
<div id="layoutCell48479" class="cell " >		
			
		<label class="fieldLabel" title="" for="NotifikacieKontakt"  style="width:70px;">Kontakt </label><span class="fieldContent"><input id="NotifikacieKontakt" name="NotifikacieKontakt" title="" type="text" class="xsd_string textBox "  maxlength="400" size="190"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kontakt" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
						<div id="layoutRow14230" class="layoutRow ui-tabs ui-widget-content   "   title="" >
						<input type="hidden" name="sekciaSposobDoruceniaVystupu" />
							<div class="caption ui-widget-header">		
				<div class="headercorrection" title="Spôsob doručenia výstupu">Spôsob doručenia výstupu			</div>
			<span class="arrow ui-icon ui-icon-carat-1-n"></span></div>
				<div id="layoutRowContentlayoutRow14230" class="columns">
				
				<div id="layoutColumn26874" class="column first"  style="width:300px;">
											
<div id="layoutCell67920" class="cell " >		
			
		<span class="fieldLabel" title=""  >Spôsob doručenia výstupu  <div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Vyberte jednu z možností.</span></p></p></div></div></span><fieldset><legend></legend><div class="xsd_string radioButtonList "><span><input id="SposobDoruceniaVystupuTyp" name="SposobDoruceniaVystupuTyp" class="xsd_string radioButtonList " title="" type="radio" alt="eDesk" value="eDesk" checked="checked"  ></input><label for="SposobDoruceniaVystupuTyp" class="optionLabel">eDesk</label></span><span><input id="SposobDoruceniaVystupuTypPostfixList1" name="SposobDoruceniaVystupuTyp" class="xsd_string radioButtonList " title="" type="radio" alt="osobne" value="osobne"   ></input><label for="SposobDoruceniaVystupuTypPostfixList1" class="optionLabel">osobne</label></span><span><input id="SposobDoruceniaVystupuTypPostfixList2" name="SposobDoruceniaVystupuTyp" class="xsd_string radioButtonList " title="" type="radio" alt="poštou" value="poštou"   ></input><label for="SposobDoruceniaVystupuTypPostfixList2" class="optionLabel">poštou</label></span></div></fieldset>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
				<div id="layoutColumn26875" class="column "  style="width:550px;">
											
<div id="layoutCell67921" class="cell " >		
			
		<label class="fieldLabel" title="" for="SposobDoruceniaVystupuKontakt"  style="width:270px;">Kontakt v prípade doručenia osobne / poštou </label><span class="fieldContent"><input id="SposobDoruceniaVystupuKontakt" name="SposobDoruceniaVystupuKontakt" title="" type="text" class="xsd_string textBox SposobDoruceniaVystupuKontakt_internal"  maxlength="400" size="210"  alt="" value="" ></input><div class="info"><div class="dialog-modal" title="Nápoveda"><p><style type="text/css">
p { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
body { font-family: 'Verdana';font-size: 16px; } 
.p_6AAD5060 { margin-top: 0px;margin-bottom: 12px;line-height: 1.15; } 
.s_D3FCB7B8 { font-family: 'Verdana';font-size: 16px; } </style><p class="p_6AAD5060"><span class="s_D3FCB7B8">Zadajte do poľa "Kontakt v prípade doručenia os" hodnotu.</span></p></p></div></div>
</span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
						<div id="layoutRow9896" class="layoutRow ui-tabs ui-widget-content   nocaption "   title="" >
						<input type="hidden" name="sekciaFooter" />
				<div id="layoutRowContentlayoutRow9896" class="columns">
				
				<div id="layoutColumn18625" class="column first" >
											
<div id="layoutCell48481" class="cell " >		
			
		<span class="fieldContent"><a href="http://www.nitra.sk" class="xsd_string hyperLink " target="_blank" >Copyright © 2015, Mesto Nitra - Všetky práva vyhradené</a>
</span>	
		<div class="clear"> </div>
</div>							
											
<div id="layoutCell48482" class="cell " >		
			
		<span class="fieldLabel" title=""   style="width:400px;">NITRA je moderné a otvorené mesto pre všetkých  </span>	
		<div class="clear"> </div>
</div>							
						
				</div>	
				
			<div class="clear"> </div>
		</div>
			</div>	
					
			<div id="buttonsPlaceholder">
									<input id="validateForm" type="button" class="button ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only" value="Skontrolovať" alt="Skontrolovať" accesskey="S" />
										<input id="clearForm" type="button" class="button ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only" value="Vyčisti"  alt="Vyčisti" accesskey="V" />
					<input id="loadFormXml" type="button" class="button ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only" value="Načítať"  alt="Načítať" accesskey="N" />
					<input id="saveToXml" type="button" class="button ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only" value="Uložiť"  alt="Uložiť" accesskey="U" />
									<input id="cancelForm" type="button" class="button ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only" value="Zrušiť"  alt="Zrušiť" accesskey="Z" />			
			</div>		
		</div>
		<div id="statusDialog" title="Status">
			<img id="statusLoader" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAMAAABg3Am1AAAACGFjVEwAAAAJAAAAAIRdomEAAADbUExURQAAAP///7PCrq6+qLvIthNBAdXd0uTp4s/YzMLOvsjSxPHz8Nzj2vr7+u3w7Ke4oPb49qGzmunt6BNBAZKnijBYIF5+UjlgKiFMEEFmMvT29MzVyEptPL/LusTPwJaqjuXq5J2wlmuIYKq7pIOberfFsk" alt="Čakajte prosím" />
			<p id="statusMessage" class="statusMessage"></p>
		</div>
		<div id="savedFormsContainer" class="layoutMain ui-widget-content" style="display:none">
		  <div id="savedFormsContainerRow" class="layoutRow ui-tabs ui-widget-content"  title="" >
			<input type="hidden" name="Basic" />
			<div class="caption ui-widget-header">
			  <div class="headercorrection" title="Uložené formuláre">Uložené formuláre</div>
			  <span class="arrow ui-icon ui-icon-carat-1-n"></span>
			</div>
			<div id="layoutRowSavedForms" class="columns">
			  <div id="lcolumnSavedForms" class="column first" >
				<div id="lcellSavedForms" class="cell">          				  
				</div>				
			  </div>
			  <div class="clear"> </div>
			</div>
		  </div>
		</div>
		<div id="mtd_formMetaData" style="display:none"><span id="mtd_version">1.1</span><span id="mtd_idp">2149</span><span id="mtd_namespace">http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1</span></div>
	</form>
</body>
</html>

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"  xmlns:egonp="http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1">
<xsl:output method="text" indent="yes" omit-xml-declaration="yes"/>
<xsl:strip-space elements="*" />
<xsl:template match="egonp:eForm_eGov_001">
<xsl:text>eForm_eGov_001</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>Obec</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec/egonp:Obec_MsU">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Mesto Nitra: Mestský úrad Nitra, Štefánikova trieda 60, 950 06 Nitra: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec/egonp:Obec_Telefon">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Telefón: 037/65 02 111: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec/egonp:Obec_BankoveSpojenie">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>IBAN: SK0409000000005028001139: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec/egonp:Obec_ICO">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>IČO: 00308307: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec/egonp:Obec_DIC">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>DIČ: 2021102853: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec/egonp:Obec_Email">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>E-mail: info@nitra.sk: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaHeader">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>sekciaHeader: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>Meno a priezvisko užívateľa resp. vlastníka nehnuteľnosti určenej na bývanie - (FO):</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Žiadateľ  - fyzická osoba</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail/egonp:ZiadatelFODetailTitulPred_PrefixQualificationAffix">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Titul pred menom: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail/egonp:ZiadatelFODetailMeno_GivenName">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Meno: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail/egonp:ZiadatelFODetailRC">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Rodné číslo: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail/egonp:ZiadatelFODetailTitulZa_PostfixQualificationAffix">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Titul za menom: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail/egonp:ZiadatelFODetailPriezvisko_FamilyName">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Priezvisko: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail/egonp:ZiadatelFODetailDatumNarodenia_DateOfBirth">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Dátum narodenia: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Adresa trvalého pobytu</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaStat_Country">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Štát: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaObec_Municipality">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Obec: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaUlica_StreetName">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Ulica: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaKraj_Region">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Kraj: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaCastObce_District">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Časť obce: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Súp.č.: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaOkres_County">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Okres: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaPSC_PostalCode">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>PSČ: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Or.č.: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaStat_Country">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Štát: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaObec_Municipality">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Obec: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaUlica_StreetName">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Ulica: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaKraj_Region">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Kraj: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaCastObce_District">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Časť obce: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Súp.č.: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaOkres_County">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Okres: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>PSČ: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Or.č.: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaStat_Country">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Štát: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaObec_Municipality">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Obec: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaUlica_StreetName">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Ulica: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaKraj_Region">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Kraj: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaCastObce_District">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Časť obce: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Súp.č.: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaOkres_County">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Okres: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaPSC_PostalCode">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>PSČ: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaOrC_BuildingNumber">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Or.č.: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOKontakt">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Kontakt</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOKontakt/egonp:ZiadatelFOKontaktTelCislo_TelephoneAddress">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Telefónne číslo: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOKontakt/egonp:ZiadatelFOKontaktEmailAdresa">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>E-mailová adresa: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>Nehnuteľnosť</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Adresa nehnuteľnosti</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiStat_Country">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Štát: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiObec_Municipality">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Obec: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiUlica_StreetName">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Ulica: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiKraj_Region">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Kraj: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiCastObce_District">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Časť obce: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Súp.č.: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiOkres_County">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Okres: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiPSC_PostalCode">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>PSČ: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Or.č.: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>Osoby užívajúce nehnuteľnosť</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajucePocet">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Počet osôb užívajúcich nehnuteľnosť</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajucePocet/egonp:OsobyUzivajucePocet">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Počet osôb, ktoré využívajú nehnuteľnosť, resp. majú prihlásený trvalý alebo prechodný pobyt, majú právo užívať nehnuteľnosť na uvedenej adrese: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Prihlásená osoba</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:OsobyUzivajuceZoznamMeno_GivenName">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Meno: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:OsobyUzivajuceZoznamPriezvisko_FamilyName">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Priezvisko: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:OsobyUzivajuceZoznamMeno_DateOfBirth">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Dátum narodenia: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:OsobyUzivajuceZoznamTypPobytu">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Označenie pobytu: </xsl:text><xsl:choose><xsl:when test=".='TP'"><xsl:text>Trval&#253;</xsl:text></xsl:when><xsl:when test=".='PP'"><xsl:text>Prechodn&#253;</xsl:text></xsl:when><xsl:when test=".='U'"><xsl:text>Už&#237;vateľ</xsl:text></xsl:when><xsl:when test=".='PU'"><xsl:text>Pr&#225;vo už&#237;vať</xsl:text></xsl:when><xsl:otherwise><xsl:value-of select="."/></xsl:otherwise></xsl:choose>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Adresa trvalého pobytu</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Štát: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Obec: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Ulica: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Kraj: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Časť obce: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Súp.č.: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Okres: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>PSČ: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Or.č.: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaOchranaOsobnychUdajov">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>Ochrana osobných údajov</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaOchranaOsobnychUdajov/egonp:OchranaOsobnychUdajovSuhlas">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona.: </xsl:text><xsl:call-template name="booleanCheckboxToString"><xsl:with-param name="boolValue" select="." /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNotifikacie">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>Notifikácie</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNotifikacie/egonp:NotifikacieZasielanie">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Zasielanie upozornení: </xsl:text><xsl:choose><xsl:when test=".='1'"><xsl:text>Žiadne</xsl:text></xsl:when><xsl:when test=".='2'"><xsl:text>eDesk</xsl:text></xsl:when><xsl:when test=".='3'"><xsl:text>SMS</xsl:text></xsl:when><xsl:when test=".='4'"><xsl:text>E-mail</xsl:text></xsl:when><xsl:otherwise><xsl:value-of select="."/></xsl:otherwise></xsl:choose>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNotifikacie/egonp:NotifikacieKontakt">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Kontakt: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaSposobDoruceniaVystupu">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>Spôsob doručenia výstupu</xsl:text>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaSposobDoruceniaVystupu/egonp:SposobDoruceniaVystupuTyp">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Spôsob doručenia výstupu: </xsl:text><xsl:choose><xsl:when test=".='eDesk'"><xsl:text>eDesk</xsl:text></xsl:when><xsl:when test=".='osobne'"><xsl:text>osobne</xsl:text></xsl:when><xsl:when test=".='poštou'"><xsl:text>poštou</xsl:text></xsl:when><xsl:otherwise><xsl:value-of select="."/></xsl:otherwise></xsl:choose>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaSposobDoruceniaVystupu/egonp:SposobDoruceniaVystupuKontakt">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>&#09;</xsl:text><xsl:text>Kontakt v prípade doručenia osobne / poštou: </xsl:text><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'&#10;'" /><xsl:with-param name="by" select="'&#13;&#10;&#09;&#09;'" /></xsl:call-template>
</xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaFooter">
<xsl:if test="./text()">
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#09;</xsl:text><xsl:text>sekciaFooter: </xsl:text><xsl:value-of select="."/>
</xsl:if>
</xsl:template>
<xsl:template name="formatToSkDate">
<xsl:param name="date" />
<xsl:variable name="dateString" select="string($date)" />
<xsl:choose>
<xsl:when test="$dateString != '' and string-length($dateString)=10 and string(number(substring($dateString, 1, 4))) != 'NaN' ">
<xsl:value-of select="concat(substring($dateString, 9, 2), '.', substring($dateString, 6, 2), '.', substring($dateString, 1, 4))" />
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$dateString"></xsl:value-of>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="booleanCheckboxToString">
<xsl:param name="boolValue" />
<xsl:variable name="boolValueString" select="string($boolValue)" />
<xsl:choose>
<xsl:when test="$boolValueString = 'true' ">
<xsl:text>Áno</xsl:text>
</xsl:when>
<xsl:when test="$boolValueString = 'false' ">
<xsl:text>Nie</xsl:text>
</xsl:when>
<xsl:when test="$boolValueString = '1' ">
<xsl:text>Áno</xsl:text>
</xsl:when>
<xsl:when test="$boolValueString = '0' ">
<xsl:text>Nie</xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$boolValueString"></xsl:value-of>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="formatTimeTrimSeconds">
<xsl:param name="time" />
<xsl:variable name="timeString" select="string($time)" />
<xsl:if test="$timeString != ''">
<xsl:value-of select="substring($timeString, 1, 5)" />
</xsl:if>
</xsl:template>
<xsl:template name="formatTime">
<xsl:param name="time" />
<xsl:variable name="timeString" select="string($time)" />
<xsl:if test="$timeString != ''">
<xsl:value-of select="substring($timeString, 1, 8)" />
</xsl:if>
</xsl:template>
<xsl:template name="string-replace-all">
<xsl:param name="text"/>
<xsl:param name="replace"/>
<xsl:param name="by"/>
<xsl:choose>
<xsl:when test="contains($text, $replace)">
<xsl:value-of select="substring-before($text,$replace)"/>
<xsl:value-of select="$by"/>
<xsl:call-template name="string-replace-all">
<xsl:with-param name="text" select="substring-after($text,$replace)"/>
<xsl:with-param name="replace" select="$replace"/>
<xsl:with-param name="by" select="$by" />
</xsl:call-template>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$text"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="formatToSkDateTime">
<xsl:param name="dateTime" />
<xsl:variable name="dateTimeString" select="string($dateTime)" />
<xsl:choose>
<xsl:when test="$dateTimeString!= '' and string-length($dateTimeString)>18 and string(number(substring($dateTimeString, 1, 4))) != 'NaN' ">
<xsl:value-of select="concat(substring($dateTimeString, 9, 2), '.', substring($dateTimeString, 6, 2), '.', substring($dateTimeString, 1, 4),' ', substring($dateTimeString, 12, 2),':', substring($dateTimeString, 15, 2))" />
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$dateTimeString"></xsl:value-of>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="formatToSkDateTimeSecond">
<xsl:param name="dateTime" />
<xsl:variable name="dateTimeString" select="string($dateTime)" />
<xsl:choose>
<xsl:when test="$dateTimeString!= '' and string-length($dateTimeString)>18 and string(number(substring($dateTimeString, 1, 4))) != 'NaN' ">
<xsl:value-of select="concat(substring($dateTimeString, 9, 2), '.', substring($dateTimeString, 6, 2), '.', substring($dateTimeString, 1, 4),' ', substring($dateTimeString, 12, 2),':', substring($dateTimeString, 15, 2),':', substring($dateTimeString, 18, 2))" />
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$dateTimeString"></xsl:value-of>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>


<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"  xmlns:egonp="http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1" exclude-result-prefixes="egonp">
<xsl:output method="html" doctype-system="http://www.w3.org/TR/html4/loose.dtd" doctype-public="-//W3C//DTD HTML 4.01 Transitional//EN" indent="no" omit-xml-declaration="yes"/>
<xsl:template match="/">
<html>
<head>
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<title>001.Ohlásenie k miestnemu poplatku za komunálne odpady a drobné stavebné odpady</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<meta name="language" content="sk-SK"/>
<style type="text/css">
body { 
	font-family: 'Open Sans', 'Segoe UI', 'Trebuchet MS', 'Geneva CE', lucida, sans-serif;
	background : #ffffff !important ;
}
.ui-tabs {
	padding: .2em;
	position: relative;
	zoom: 1;
}								
.clear { clear: both; height: 0;}
.layoutMain {
	margin: 0px auto;
	padding: 5px 5px 5px 5px;	
}				
.layoutRow { margin-bottom: 5px; }				
.caption { /*width: 100%; border-bottom: solid 1px black;*/ }
.nocaption &gt; .caption { border: 0px !important; }
.nocaption &gt; .caption span {
	background: none !important;
	display: none;
} 
.caption .title { padding-left: 5px; }
.headercorrection {	
	margin: 0px;
    font-size : 1em;
    font-weight: bold;
}				
.labelVis {
	float: left;
	font-weight: bold;
	font-family: 'Open Sans', 'Segoe UI', 'Trebuchet MS', 'Geneva CE', lucida, sans-serif;
	line-height: 25px;
	margin: 0px 18px 0px 0px;
	padding-left: 3px;
	width: 190px;
	word-wrap: break-word;
    font-size: 0.8em;
}
.contentVis {    	     
	float: left;	
	line-height: 25px;
	margin: 0px;
	padding: 0px;
	vertical-align: top;
    font-size: 0.75em;			
}
.wordwrap { 
    white-space: pre-wrap;      
    white-space: -moz-pre-wrap; 
    white-space: -pre-wrap;     
    white-space: -o-pre-wrap;   
    word-wrap: break-word;      
}	
.ui-widget-content {
	background : 50% 50% repeat-x #ffffff;
	border : #d4d4d4 solid 2px;
	color : #4f4e4e;
	border-radius : 3px;
}
.ui-widget-header {
	cursor : pointer;
	font-size : 0.8em;
	color : #494949;
	padding-left : 2px;
	border : #eae9e8 solid 1px;
	background-color : #eae9e8;
	margin-bottom: 3px;
	border-radius : 3px;
}			
</style>
</head>
<body>
<div id="main" class="layoutMain">
<xsl:apply-templates/>
</div>
</body>
</html>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">eForm_eGov_001</div>
</div>
<xsl:apply-templates select="./egonp:sekciaHeader"/>
<xsl:apply-templates select="./egonp:sekciaFooter"/>
<xsl:apply-templates select="./egonp:SekciaObec"/>
<xsl:apply-templates select="./egonp:sekciaZiadatelFO_PhysicalPerson"/>
<xsl:apply-templates select="./egonp:sekciaNehnutelnost"/>
<xsl:apply-templates select="./egonp:sekciaOsobyUzivajuce"/>
<xsl:apply-templates select="./egonp:SekciaOchranaOsobnychUdajov"/>
<xsl:apply-templates select="./egonp:sekciaNotifikacie"/>
<xsl:apply-templates select="./egonp:sekciaSposobDoruceniaVystupu"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaNehnutelnost">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Nehnuteľnosť</div>
</div>
<xsl:apply-templates select="./egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Adresa nehnuteľnosti</div>
</div>
<xsl:apply-templates select="./egonp:NehnutelnostAdresaNehnutelnostiStat_Country"/>
<xsl:apply-templates select="./egonp:NehnutelnostAdresaNehnutelnostiObec_Municipality"/>
<xsl:apply-templates select="./egonp:NehnutelnostAdresaNehnutelnostiUlica_StreetName"/>
<xsl:apply-templates select="./egonp:NehnutelnostAdresaNehnutelnostiKraj_Region"/>
<xsl:apply-templates select="./egonp:NehnutelnostAdresaNehnutelnostiCastObce_District"/>
<xsl:apply-templates select="./egonp:NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber"/>
<xsl:apply-templates select="./egonp:NehnutelnostAdresaNehnutelnostiOkres_County"/>
<xsl:apply-templates select="./egonp:NehnutelnostAdresaNehnutelnostiPSC_PostalCode"/>
<xsl:apply-templates select="./egonp:NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:SekciaOchranaOsobnychUdajov">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Ochrana osobných údajov</div>
</div>
<xsl:apply-templates select="./egonp:OchranaOsobnychUdajovSuhlas"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Osoby užívajúce nehnuteľnosť</div>
</div>
<xsl:apply-templates select="./egonp:sekciaOsobyUzivajucePocet"/>
<xsl:apply-templates select="./egonp:sekciaOsobyUzivajuceZoznam"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajucePocet">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Počet osôb užívajúcich nehnuteľnosť</div>
</div>
<xsl:apply-templates select="./egonp:OsobyUzivajucePocet"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Prihlásená osoba</div>
</div>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamMeno_GivenName"/>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamPriezvisko_FamilyName"/>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamMeno_DateOfBirth"/>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamTypPobytu"/>
<xsl:apply-templates select="./egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Adresa trvalého pobytu</div>
</div>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country"/>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality"/>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName"/>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region"/>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District"/>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber"/>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County"/>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode"/>
<xsl:apply-templates select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaNotifikacie">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Notifikácie</div>
</div>
<xsl:apply-templates select="./egonp:NotifikacieZasielanie"/>
<xsl:apply-templates select="./egonp:NotifikacieKontakt"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaSposobDoruceniaVystupu">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Spôsob doručenia výstupu</div>
</div>
<xsl:apply-templates select="./egonp:SposobDoruceniaVystupuTyp"/>
<xsl:apply-templates select="./egonp:SposobDoruceniaVystupuKontakt"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Meno a priezvisko užívateľa resp. vlastníka nehnuteľnosti určenej na bývanie - (FO):</div>
</div>
<xsl:apply-templates select="./egonp:sekciaZiadatelFODetail"/>
<xsl:apply-templates select="./egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress"/>
<xsl:apply-templates select="./egonp:sekciaZiadatelFOPrechodnyPobytAdresa"/>
<xsl:apply-templates select="./egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress"/>
<xsl:apply-templates select="./egonp:sekciaZiadatelFOKontakt"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOKontakt">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Kontakt</div>
</div>
<xsl:apply-templates select="./egonp:ZiadatelFOKontaktTelCislo_TelephoneAddress"/>
<xsl:apply-templates select="./egonp:ZiadatelFOKontaktEmailAdresa"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Žiadateľ  - fyzická osoba</div>
</div>
<xsl:apply-templates select="./egonp:ZiadatelFODetailTitulPred_PrefixQualificationAffix"/>
<xsl:apply-templates select="./egonp:ZiadatelFODetailMeno_GivenName"/>
<xsl:apply-templates select="./egonp:ZiadatelFODetailRC"/>
<xsl:apply-templates select="./egonp:ZiadatelFODetailTitulZa_PostfixQualificationAffix"/>
<xsl:apply-templates select="./egonp:ZiadatelFODetailPriezvisko_FamilyName"/>
<xsl:apply-templates select="./egonp:ZiadatelFODetailDatumNarodenia_DateOfBirth"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Adresa trvalého pobytu</div>
</div>
<xsl:apply-templates select="./egonp:ZiadatelFOTrvalyPobytAdresaStat_Country"/>
<xsl:apply-templates select="./egonp:ZiadatelFOTrvalyPobytAdresaObec_Municipality"/>
<xsl:apply-templates select="./egonp:ZiadatelFOTrvalyPobytAdresaUlica_StreetName"/>
<xsl:apply-templates select="./egonp:ZiadatelFOTrvalyPobytAdresaKraj_Region"/>
<xsl:apply-templates select="./egonp:ZiadatelFOTrvalyPobytAdresaCastObce_District"/>
<xsl:apply-templates select="./egonp:ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber"/>
<xsl:apply-templates select="./egonp:ZiadatelFOTrvalyPobytAdresaOkres_County"/>
<xsl:apply-templates select="./egonp:ZiadatelFOTrvalyPobytAdresaPSC_PostalCode"/>
<xsl:apply-templates select="./egonp:ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)</div>
</div>
<xsl:apply-templates select="./egonp:ZiadatelFOPrechodnyPobytAdresaStat_Country"/>
<xsl:apply-templates select="./egonp:ZiadatelFOPrechodnyPobytAdresaObec_Municipality"/>
<xsl:apply-templates select="./egonp:ZiadatelFOPrechodnyPobytAdresaUlica_StreetName"/>
<xsl:apply-templates select="./egonp:ZiadatelFOPrechodnyPobytAdresaKraj_Region"/>
<xsl:apply-templates select="./egonp:ZiadatelFOPrechodnyPobytAdresaCastObce_District"/>
<xsl:apply-templates select="./egonp:ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber"/>
<xsl:apply-templates select="./egonp:ZiadatelFOPrechodnyPobytAdresaOkres_County"/>
<xsl:apply-templates select="./egonp:ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode"/>
<xsl:apply-templates select="./egonp:ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)</div>
</div>
<xsl:apply-templates select="./egonp:ZiadatelFODorucenieAdresaStat_Country"/>
<xsl:apply-templates select="./egonp:ZiadatelFODorucenieAdresaObec_Municipality"/>
<xsl:apply-templates select="./egonp:ZiadatelFODorucenieAdresaUlica_StreetName"/>
<xsl:apply-templates select="./egonp:ZiadatelFODorucenieAdresaKraj_Region"/>
<xsl:apply-templates select="./egonp:ZiadatelFODorucenieAdresaCastObce_District"/>
<xsl:apply-templates select="./egonp:ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber"/>
<xsl:apply-templates select="./egonp:ZiadatelFODorucenieAdresaOkres_County"/>
<xsl:apply-templates select="./egonp:ZiadatelFODorucenieAdresaPSC_PostalCode"/>
<xsl:apply-templates select="./egonp:ZiadatelFODorucenieAdresaOrC_BuildingNumber"/>
</div>
</xsl:template>
<xsl:template match="/egonp:eForm_eGov_001/egonp:SekciaObec">
<div class="layoutRow ui-tabs ui-widget-content" >
<div class="caption ui-widget-header">
<div class="headercorrection">Obec</div>
</div>
<xsl:apply-templates select="./egonp:Obec_MsU"/>
<xsl:apply-templates select="./egonp:Obec_Telefon"/>
<xsl:apply-templates select="./egonp:Obec_BankoveSpojenie"/>
<xsl:apply-templates select="./egonp:Obec_ICO"/>
<xsl:apply-templates select="./egonp:Obec_DIC"/>
<xsl:apply-templates select="./egonp:Obec_Email"/>
</div>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaHeader">
<xsl:if test="./text()">
<div><label class="labelVis">sekciaHeader: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaFooter">
<xsl:if test="./text()">
<div><label class="labelVis">sekciaFooter: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiStat_Country">
<xsl:if test="./text()">
<div><label class="labelVis">Štát: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiObec_Municipality">
<xsl:if test="./text()">
<div><label class="labelVis">Obec: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiUlica_StreetName">
<xsl:if test="./text()">
<div><label class="labelVis">Ulica: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiKraj_Region">
<xsl:if test="./text()">
<div><label class="labelVis">Kraj: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiCastObce_District">
<xsl:if test="./text()">
<div><label class="labelVis">Časť obce: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber">
<xsl:if test="./text()">
<div><label class="labelVis">Súp.č.: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiOkres_County">
<xsl:if test="./text()">
<div><label class="labelVis">Okres: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiPSC_PostalCode">
<xsl:if test="./text()">
<div><label class="labelVis">PSČ: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress/egonp:NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber">
<xsl:if test="./text()">
<div><label class="labelVis">Or.č.: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaOchranaOsobnychUdajov/egonp:OchranaOsobnychUdajovSuhlas">
<xsl:if test="./text()">
<div><label class="labelVis">Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona.: </label><span class="contentVis wordwrap"><xsl:call-template name="booleanCheckboxToString"><xsl:with-param name="boolValue" select="." /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajucePocet/egonp:OsobyUzivajucePocet">
<xsl:if test="./text()">
<div><label class="labelVis">Počet osôb, ktoré využívajú nehnuteľnosť, resp. majú prihlásený trvalý alebo prechodný pobyt, majú právo užívať nehnuteľnosť na uvedenej adrese: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:OsobyUzivajuceZoznamMeno_GivenName">
<xsl:if test="./text()">
<div><label class="labelVis">Meno: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:OsobyUzivajuceZoznamPriezvisko_FamilyName">
<xsl:if test="./text()">
<div><label class="labelVis">Priezvisko: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:OsobyUzivajuceZoznamMeno_DateOfBirth">
<xsl:if test="./text()">
<div><label class="labelVis">Dátum narodenia: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:OsobyUzivajuceZoznamTypPobytu">
<xsl:if test="./text()">
<div><label class="labelVis">Označenie pobytu: </label><span class="contentVis wordwrap"><xsl:choose><xsl:when test=".='TP'"><xsl:text>Trval&#253;</xsl:text></xsl:when><xsl:when test=".='PP'"><xsl:text>Prechodn&#253;</xsl:text></xsl:when><xsl:when test=".='U'"><xsl:text>Už&#237;vateľ</xsl:text></xsl:when><xsl:when test=".='PU'"><xsl:text>Pr&#225;vo už&#237;vať</xsl:text></xsl:when><xsl:otherwise><xsl:value-of select="."/></xsl:otherwise></xsl:choose></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country">
<xsl:if test="./text()">
<div><label class="labelVis">Štát: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality">
<xsl:if test="./text()">
<div><label class="labelVis">Obec: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName">
<xsl:if test="./text()">
<div><label class="labelVis">Ulica: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region">
<xsl:if test="./text()">
<div><label class="labelVis">Kraj: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District">
<xsl:if test="./text()">
<div><label class="labelVis">Časť obce: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber">
<xsl:if test="./text()">
<div><label class="labelVis">Súp.č.: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County">
<xsl:if test="./text()">
<div><label class="labelVis">Okres: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode">
<xsl:if test="./text()">
<div><label class="labelVis">PSČ: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress/egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber">
<xsl:if test="./text()">
<div><label class="labelVis">Or.č.: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNotifikacie/egonp:NotifikacieZasielanie">
<xsl:if test="./text()">
<div><label class="labelVis">Zasielanie upozornení: </label><span class="contentVis wordwrap"><xsl:choose><xsl:when test=".='1'"><xsl:text>Žiadne</xsl:text></xsl:when><xsl:when test=".='2'"><xsl:text>eDesk</xsl:text></xsl:when><xsl:when test=".='3'"><xsl:text>SMS</xsl:text></xsl:when><xsl:when test=".='4'"><xsl:text>E-mail</xsl:text></xsl:when><xsl:otherwise><xsl:value-of select="."/></xsl:otherwise></xsl:choose></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNotifikacie/egonp:NotifikacieKontakt">
<xsl:if test="./text()">
<div><label class="labelVis">Kontakt: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaSposobDoruceniaVystupu/egonp:SposobDoruceniaVystupuTyp">
<xsl:if test="./text()">
<div><label class="labelVis">Spôsob doručenia výstupu: </label><span class="contentVis wordwrap"><xsl:choose><xsl:when test=".='eDesk'"><xsl:text>eDesk</xsl:text></xsl:when><xsl:when test=".='osobne'"><xsl:text>osobne</xsl:text></xsl:when><xsl:when test=".='poštou'"><xsl:text>poštou</xsl:text></xsl:when><xsl:otherwise><xsl:value-of select="."/></xsl:otherwise></xsl:choose></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaSposobDoruceniaVystupu/egonp:SposobDoruceniaVystupuKontakt">
<xsl:if test="./text()">
<div><label class="labelVis">Kontakt v prípade doručenia osobne / poštou: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOKontakt/egonp:ZiadatelFOKontaktTelCislo_TelephoneAddress">
<xsl:if test="./text()">
<div><label class="labelVis">Telefónne číslo: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOKontakt/egonp:ZiadatelFOKontaktEmailAdresa">
<xsl:if test="./text()">
<div><label class="labelVis">E-mailová adresa: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail/egonp:ZiadatelFODetailTitulPred_PrefixQualificationAffix">
<xsl:if test="./text()">
<div><label class="labelVis">Titul pred menom: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail/egonp:ZiadatelFODetailMeno_GivenName">
<xsl:if test="./text()">
<div><label class="labelVis">Meno: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail/egonp:ZiadatelFODetailRC">
<xsl:if test="./text()">
<div><label class="labelVis">Rodné číslo: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail/egonp:ZiadatelFODetailTitulZa_PostfixQualificationAffix">
<xsl:if test="./text()">
<div><label class="labelVis">Titul za menom: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail/egonp:ZiadatelFODetailPriezvisko_FamilyName">
<xsl:if test="./text()">
<div><label class="labelVis">Priezvisko: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail/egonp:ZiadatelFODetailDatumNarodenia_DateOfBirth">
<xsl:if test="./text()">
<div><label class="labelVis">Dátum narodenia: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaStat_Country">
<xsl:if test="./text()">
<div><label class="labelVis">Štát: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaObec_Municipality">
<xsl:if test="./text()">
<div><label class="labelVis">Obec: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaUlica_StreetName">
<xsl:if test="./text()">
<div><label class="labelVis">Ulica: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaKraj_Region">
<xsl:if test="./text()">
<div><label class="labelVis">Kraj: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaCastObce_District">
<xsl:if test="./text()">
<div><label class="labelVis">Časť obce: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber">
<xsl:if test="./text()">
<div><label class="labelVis">Súp.č.: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaOkres_County">
<xsl:if test="./text()">
<div><label class="labelVis">Okres: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaPSC_PostalCode">
<xsl:if test="./text()">
<div><label class="labelVis">PSČ: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress/egonp:ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber">
<xsl:if test="./text()">
<div><label class="labelVis">Or.č.: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaStat_Country">
<xsl:if test="./text()">
<div><label class="labelVis">Štát: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaObec_Municipality">
<xsl:if test="./text()">
<div><label class="labelVis">Obec: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaUlica_StreetName">
<xsl:if test="./text()">
<div><label class="labelVis">Ulica: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaKraj_Region">
<xsl:if test="./text()">
<div><label class="labelVis">Kraj: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaCastObce_District">
<xsl:if test="./text()">
<div><label class="labelVis">Časť obce: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber">
<xsl:if test="./text()">
<div><label class="labelVis">Súp.č.: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaOkres_County">
<xsl:if test="./text()">
<div><label class="labelVis">Okres: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode">
<xsl:if test="./text()">
<div><label class="labelVis">PSČ: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa/egonp:ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber">
<xsl:if test="./text()">
<div><label class="labelVis">Or.č.: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaStat_Country">
<xsl:if test="./text()">
<div><label class="labelVis">Štát: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaObec_Municipality">
<xsl:if test="./text()">
<div><label class="labelVis">Obec: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaUlica_StreetName">
<xsl:if test="./text()">
<div><label class="labelVis">Ulica: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaKraj_Region">
<xsl:if test="./text()">
<div><label class="labelVis">Kraj: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaCastObce_District">
<xsl:if test="./text()">
<div><label class="labelVis">Časť obce: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber">
<xsl:if test="./text()">
<div><label class="labelVis">Súp.č.: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaOkres_County">
<xsl:if test="./text()">
<div><label class="labelVis">Okres: </label><span class="contentVis wordwrap"><xsl:value-of select="."/></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaPSC_PostalCode">
<xsl:if test="./text()">
<div><label class="labelVis">PSČ: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress/egonp:ZiadatelFODorucenieAdresaOrC_BuildingNumber">
<xsl:if test="./text()">
<div><label class="labelVis">Or.č.: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec/egonp:Obec_MsU">
<xsl:if test="./text()">
<div><label class="labelVis">Mesto Nitra: Mestský úrad Nitra, Štefánikova trieda 60, 950 06 Nitra: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec/egonp:Obec_Telefon">
<xsl:if test="./text()">
<div><label class="labelVis">Telefón: 037/65 02 111: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec/egonp:Obec_BankoveSpojenie">
<xsl:if test="./text()">
<div><label class="labelVis">IBAN: SK0409000000005028001139: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec/egonp:Obec_ICO">
<xsl:if test="./text()">
<div><label class="labelVis">IČO: 00308307: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec/egonp:Obec_DIC">
<xsl:if test="./text()">
<div><label class="labelVis">DIČ: 2021102853: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec/egonp:Obec_Email">
<xsl:if test="./text()">
<div><label class="labelVis">E-mail: info@nitra.sk: </label><span class="contentVis wordwrap"><xsl:call-template name="string-replace-all"><xsl:with-param name="text" select="." /><xsl:with-param name="replace" select="'%0A'" /><xsl:with-param name="by" select="'&#13;&#10;'" /></xsl:call-template></span></div><div class="clear">&#xa0;</div></xsl:if>
</xsl:template>
<xsl:template name="formatToSkDate">
<xsl:param name="date" />
<xsl:variable name="dateString" select="string($date)" />
<xsl:choose>
<xsl:when test="$dateString != '' and string-length($dateString)=10 and string(number(substring($dateString, 1, 4))) != 'NaN' ">
<xsl:value-of select="concat(substring($dateString, 9, 2), '.', substring($dateString, 6, 2), '.', substring($dateString, 1, 4))" />
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$dateString"></xsl:value-of>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="booleanCheckboxToString">
<xsl:param name="boolValue" />
<xsl:variable name="boolValueString" select="string($boolValue)" />
<xsl:choose>
<xsl:when test="$boolValueString = 'true' ">
<xsl:text>Áno</xsl:text>
</xsl:when>
<xsl:when test="$boolValueString = 'false' ">
<xsl:text>Nie</xsl:text>
</xsl:when>
<xsl:when test="$boolValueString = '1' ">
<xsl:text>Áno</xsl:text>
</xsl:when>
<xsl:when test="$boolValueString = '0' ">
<xsl:text>Nie</xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$boolValueString"></xsl:value-of>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="formatTimeTrimSeconds">
<xsl:param name="time" />
<xsl:variable name="timeString" select="string($time)" />
<xsl:if test="$timeString != ''">
<xsl:value-of select="substring($timeString, 1, 5)" />
</xsl:if>
</xsl:template>
<xsl:template name="formatTime">
<xsl:param name="time" />
<xsl:variable name="timeString" select="string($time)" />
<xsl:if test="$timeString != ''">
<xsl:value-of select="substring($timeString, 1, 8)" />
</xsl:if>
</xsl:template>
<xsl:template name="string-replace-all">
<xsl:param name="text"/>
<xsl:param name="replace"/>
<xsl:param name="by"/>
<xsl:choose>
<xsl:when test="contains($text, $replace)">
<xsl:value-of select="substring-before($text,$replace)"/>
<xsl:value-of select="$by"/>
<xsl:call-template name="string-replace-all">
<xsl:with-param name="text" select="substring-after($text,$replace)"/>
<xsl:with-param name="replace" select="$replace"/>
<xsl:with-param name="by" select="$by" />
</xsl:call-template>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$text"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="formatToSkDateTime">
<xsl:param name="dateTime" />
<xsl:variable name="dateTimeString" select="string($dateTime)" />
<xsl:choose>
<xsl:when test="$dateTimeString!= '' and string-length($dateTimeString)>18 and string(number(substring($dateTimeString, 1, 4))) != 'NaN' ">
<xsl:value-of select="concat(substring($dateTimeString, 9, 2), '.', substring($dateTimeString, 6, 2), '.', substring($dateTimeString, 1, 4),' ', substring($dateTimeString, 12, 2),':', substring($dateTimeString, 15, 2))" />
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$dateTimeString"></xsl:value-of>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="formatToSkDateTimeSecond">
<xsl:param name="dateTime" />
<xsl:variable name="dateTimeString" select="string($dateTime)" />
<xsl:choose>
<xsl:when test="$dateTimeString!= '' and string-length($dateTimeString)>18 and string(number(substring($dateTimeString, 1, 4))) != 'NaN' ">
<xsl:value-of select="concat(substring($dateTimeString, 9, 2), '.', substring($dateTimeString, 6, 2), '.', substring($dateTimeString, 1, 4),' ', substring($dateTimeString, 12, 2),':', substring($dateTimeString, 15, 2),':', substring($dateTimeString, 18, 2))" />
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$dateTimeString"></xsl:value-of>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>


<?xml version="1.0" encoding="UTF-8"?><xs:schema elementFormDefault="qualified" attributeFormDefault="unqualified" xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1" xmlns="http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1">
<xs:simpleType name="xsdTextCislo">
<xs:restriction base="xs:integer">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdTextBox">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="datum">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdComboTypPobyt">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCiselnikStaty">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCiselnikObce">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCiselnikKraje">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCiselnikOkresy">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdTextPSC">
<xs:restriction base="xs:string">
<xs:maxLength value="6" />
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCheckBox">
<xs:restriction base="xs:boolean">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdRadioTypNotifikacie">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCiselnikTitulyPred">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdCiselnikTitulyZa">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="xsdRadioSposobDoruceniaVystupu">
<xs:restriction base="xs:string">
</xs:restriction>
</xs:simpleType>


<xs:element name="eForm_eGov_001">
<xs:complexType>
<xs:sequence>
<xs:element name="SekciaObec" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="Obec_MsU" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="Obec_Telefon" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="Obec_BankoveSpojenie" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="Obec_ICO" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="Obec_DIC" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="Obec_Email" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaHeader" minOccurs="0">
<xs:complexType>
<xs:sequence>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaZiadatelFO_PhysicalPerson" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="sekciaZiadatelFODetail" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="ZiadatelFODetailTitulPred_PrefixQualificationAffix" type="xsdCiselnikTitulyPred" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODetailMeno_GivenName" type="xsdTextBox" minOccurs="1" />
<xs:element name="ZiadatelFODetailRC" type="xsdTextBox" minOccurs="1" />
<xs:element name="ZiadatelFODetailTitulZa_PostfixQualificationAffix" type="xsdCiselnikTitulyZa" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODetailPriezvisko_FamilyName" type="xsdTextBox" minOccurs="1" />
<xs:element name="ZiadatelFODetailDatumNarodenia_DateOfBirth" type="datum" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="ZiadatelFOTrvalyPobytAdresaStat_Country" type="xsdCiselnikStaty" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaObec_Municipality" type="xsdCiselnikObce" minOccurs="1" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaUlica_StreetName" type="xsdTextBox" minOccurs="1" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaKraj_Region" type="xsdCiselnikKraje" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaCastObce_District" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber" type="xsdTextBox" minOccurs="1" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaOkres_County" type="xsdCiselnikOkresy" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaPSC_PostalCode" type="xsdTextPSC" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaZiadatelFOPrechodnyPobytAdresa" minOccurs="0" maxOccurs="1">
<xs:complexType>
<xs:sequence>
<xs:element name="ZiadatelFOPrechodnyPobytAdresaStat_Country" type="xsdCiselnikStaty" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaObec_Municipality" type="xsdCiselnikObce" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaUlica_StreetName" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaKraj_Region" type="xsdCiselnikKraje" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaCastObce_District" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaOkres_County" type="xsdCiselnikOkresy" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode" type="xsdTextPSC" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaZiadatelFODorucenieAdresa_DeliveryAddress" minOccurs="0" maxOccurs="1">
<xs:complexType>
<xs:sequence>
<xs:element name="ZiadatelFODorucenieAdresaStat_Country" type="xsdCiselnikStaty" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaObec_Municipality" type="xsdCiselnikObce" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaUlica_StreetName" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaKraj_Region" type="xsdCiselnikKraje" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaCastObce_District" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaOkres_County" type="xsdCiselnikOkresy" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaPSC_PostalCode" type="xsdTextPSC" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFODorucenieAdresaOrC_BuildingNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaZiadatelFOKontakt" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="ZiadatelFOKontaktTelCislo_TelephoneAddress" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="ZiadatelFOKontaktEmailAdresa" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaNehnutelnost" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="NehnutelnostAdresaNehnutelnostiStat_Country" type="xsdCiselnikStaty" minOccurs="0" nillable="true" />
<xs:element name="NehnutelnostAdresaNehnutelnostiObec_Municipality" type="xsdCiselnikObce" minOccurs="1" />
<xs:element name="NehnutelnostAdresaNehnutelnostiUlica_StreetName" type="xsdTextBox" minOccurs="1" />
<xs:element name="NehnutelnostAdresaNehnutelnostiKraj_Region" type="xsdCiselnikKraje" minOccurs="0" nillable="true" />
<xs:element name="NehnutelnostAdresaNehnutelnostiCastObce_District" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber" type="xsdTextBox" minOccurs="1" />
<xs:element name="NehnutelnostAdresaNehnutelnostiOkres_County" type="xsdCiselnikOkresy" minOccurs="0" nillable="true" />
<xs:element name="NehnutelnostAdresaNehnutelnostiPSC_PostalCode" type="xsdTextPSC" minOccurs="0" nillable="true" />
<xs:element name="NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaOsobyUzivajuce" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="sekciaOsobyUzivajucePocet" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="OsobyUzivajucePocet" type="xsdTextCislo" minOccurs="1" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaOsobyUzivajuceZoznam" minOccurs="1" maxOccurs="10">
<xs:complexType>
<xs:sequence>
<xs:element name="OsobyUzivajuceZoznamMeno_GivenName" type="xsdTextBox" minOccurs="1" />
<xs:element name="OsobyUzivajuceZoznamPriezvisko_FamilyName" type="xsdTextBox" minOccurs="1" />
<xs:element name="OsobyUzivajuceZoznamMeno_DateOfBirth" type="datum" minOccurs="0" nillable="true" />
<xs:element name="OsobyUzivajuceZoznamTypPobytu" type="xsdComboTypPobyt" minOccurs="1" />
<xs:element name="sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country" type="xsdCiselnikStaty" minOccurs="0" nillable="true" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality" type="xsdCiselnikObce" minOccurs="1" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName" type="xsdTextBox" minOccurs="1" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region" type="xsdCiselnikKraje" minOccurs="0" nillable="true" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District" type="xsdTextBox" minOccurs="0" nillable="true" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber" type="xsdTextBox" minOccurs="1" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County" type="xsdCiselnikOkresy" minOccurs="0" nillable="true" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode" type="xsdTextPSC" minOccurs="0" nillable="true" />
<xs:element name="OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="SekciaOchranaOsobnychUdajov" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="OchranaOsobnychUdajovSuhlas" type="xsdCheckBox" minOccurs="1" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaNotifikacie" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="NotifikacieZasielanie" type="xsdRadioTypNotifikacie" minOccurs="0" nillable="true" />
<xs:element name="NotifikacieKontakt" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaSposobDoruceniaVystupu" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="SposobDoruceniaVystupuTyp" type="xsdRadioSposobDoruceniaVystupu" minOccurs="0" nillable="true" />
<xs:element name="SposobDoruceniaVystupuKontakt" type="xsdTextBox" minOccurs="0" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="sekciaFooter" minOccurs="0">
<xs:complexType>
<xs:sequence>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>


<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet xml:lang="en" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:d = "http://docbook.org/ns/docbook" xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:exsl="http://exslt.org/common"  xmlns:egonp="http://schemas.gov.sk/form/00308307.A0000224.000000026.OhlasenieMiestnyPoplatokZaKOaDSO_FO/1.1" exclude-result-prefixes="d" version="1.0">
  <xsl:template match="/">
    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">      
		<fo:layout-master-set>
    <fo:simple-page-master master-name="A4"
      page-height="842px" page-width="595px"
      margin-top="10px" margin-bottom="10px"
      margin-left="10px" margin-right="10px">
      <fo:region-body margin-bottom="20mm"/>
      <fo:region-after region-name="footer" extent="10mm"/>
    </fo:simple-page-master>
    <fo:page-sequence-master master-name="document">
      <fo:repeatable-page-master-alternatives>
        <fo:conditional-page-master-reference master-reference="A4"/>
      </fo:repeatable-page-master-alternatives>
    </fo:page-sequence-master>
  </fo:layout-master-set>
  <fo:page-sequence master-reference="document" font-family="Arial">
    <fo:static-content flow-name="footer">
      <fo:block text-align="end"><fo:page-number/></fo:block>
    </fo:static-content>
          <fo:flow flow-name="xsl-region-body">		
						<fo:block font-size='20pt' text-align='center'>001.Ohlásenie k miestnemu poplatku za komunálne odpady a drobné stavebné odpady</fo:block><fo:block color='white'>|</fo:block><fo:block/>
					     				
				<xsl:apply-templates/>
			</fo:flow>
           </fo:page-sequence>
          </fo:root>
         </xsl:template>

			<xsl:template name="string-replace-all">
            <xsl:param name="text"/>
            <xsl:param name="replace"/>
            <xsl:param name="by"/>
            <xsl:choose>
            <xsl:when test="contains($text, $replace)">
            <xsl:value-of select="substring-before($text,$replace)"/>
            <xsl:value-of select="$by"/>
            <xsl:call-template name="string-replace-all">
            <xsl:with-param name="text" select="substring-after($text,$replace)"/>
            <xsl:with-param name="replace" select="$replace"/>
            <xsl:with-param name="by" select="$by" />
            </xsl:call-template>
            </xsl:when>
            <xsl:otherwise>
            <xsl:value-of select="$text"/>
            </xsl:otherwise>
            </xsl:choose>
            </xsl:template>

			<xsl:template name="formatTimeTrimSeconds">
			<xsl:param name="time" />
			<xsl:variable name="timeString" select="string($time)" />
			<xsl:if test="$timeString != ''">
			<xsl:value-of select="substring($timeString, 1, 5)" />
			</xsl:if>
			</xsl:template>

			<xsl:template name="formatTime">
			<xsl:param name="time" />
			<xsl:variable name="timeString" select="string($time)" />
			<xsl:if test="$timeString != ''">
			<xsl:value-of select="substring($timeString, 1, 8)" />
			</xsl:if>
			</xsl:template>

			<xsl:template name="formatToSkDate">
			<xsl:param name="date" />
			<xsl:variable name="dateString" select="string($date)" />
			<xsl:choose>
			<xsl:when test="$dateString != '' and string-length($dateString)=10 and string(number(substring($dateString, 1, 4))) != 'NaN' ">
			<xsl:value-of select="concat(substring($dateString, 9, 2), '.', substring($dateString, 6, 2), '.', substring($dateString, 1, 4))" />
			</xsl:when>
			<xsl:otherwise>
			<xsl:value-of select="$dateString"></xsl:value-of>
			</xsl:otherwise>
			</xsl:choose>
			</xsl:template>

			<xsl:template name="formatToSkDateTime">
            <xsl:param name="dateTime" />
            <xsl:variable name="dateTimeString" select="string($dateTime)" />
            <xsl:choose>
            <xsl:when test="$dateTimeString!= '' and string-length($dateTimeString)>18 and string(number(substring($dateTimeString, 1, 4))) != 'NaN' ">
            <xsl:value-of select="concat(substring($dateTimeString, 9, 2), '.', substring($dateTimeString, 6, 2), '.', substring($dateTimeString, 1, 4),' ', substring($dateTimeString, 12, 2),':', substring($dateTimeString, 15, 2))" />
            </xsl:when>
            <xsl:otherwise>
            <xsl:value-of select="$dateTimeString"></xsl:value-of>
            </xsl:otherwise>
            </xsl:choose>
            </xsl:template>

			<xsl:template name="formatToSkDateTimeSecond">
            <xsl:param name="dateTime" />
            <xsl:variable name="dateTimeString" select="string($dateTime)" />
            <xsl:choose>
            <xsl:when test="$dateTimeString!= '' and string-length($dateTimeString)>18 and string(number(substring($dateTimeString, 1, 4))) != 'NaN' ">
            <xsl:value-of select="concat(substring($dateTimeString, 9, 2), '.', substring($dateTimeString, 6, 2), '.', substring($dateTimeString, 1, 4),' ', substring($dateTimeString, 12, 2),':', substring($dateTimeString, 15, 2),':', substring($dateTimeString, 18, 2))" />
            </xsl:when>
            <xsl:otherwise>
            <xsl:value-of select="$dateTimeString"></xsl:value-of>
            </xsl:otherwise>
            </xsl:choose>
            </xsl:template>
							<xsl:template match="egonp:eForm_eGov_001">
  <fo:table>
    <fo:table-column />
    <fo:table-body>
      <fo:table-row>
        <fo:table-cell>
          <xsl:apply-templates select="./egonp:SekciaObec" />
          <xsl:apply-templates select="./egonp:sekciaHeader" />
          <xsl:apply-templates select="./egonp:sekciaZiadatelFO_PhysicalPerson" />
          <xsl:apply-templates select="./egonp:sekciaNehnutelnost" />
          <xsl:apply-templates select="./egonp:sekciaOsobyUzivajuce" />
          <xsl:apply-templates select="./egonp:SekciaOchranaOsobnychUdajov" />
          <xsl:apply-templates select="./egonp:sekciaNotifikacie" />
          <xsl:apply-templates select="./egonp:sekciaSposobDoruceniaVystupu" />
          <xsl:apply-templates select="./egonp:sekciaFooter" />
        </fo:table-cell>
      </fo:table-row>
    </fo:table-body>
  </fo:table>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaObec">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:table>
        <fo:table-column />
        <fo:table-column />
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell />
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Mesto Nitra: Mestský úrad Nitra, Štefánikova trieda 60, 950 06 Nitra</fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Telefón: 037/65 02 111</fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>IBAN: SK0409000000005028001139</fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>IČO: 00308307</fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>DIČ: 2021102853</fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>E-mail: info@nitra.sk</fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaHeader">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:table>
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block margin-top="1mm">Ohlásenie k miestnemu poplatku za komunálne odpady a drobné stavebné odpady pre vlastníka resp. užívateľa nehnuteľnosti určenej na bývanie</fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Meno a priezvisko užívateľa resp. vlastníka nehnuteľnosti určenej na bývanie - (FO):</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <xsl:apply-templates select="./egonp:sekciaZiadatelFODetail" />
              <xsl:apply-templates select="./egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress" />
              <xsl:apply-templates select="./egonp:sekciaZiadatelFOPrechodnyPobytAdresa" />
              <xsl:apply-templates select="./egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress" />
              <xsl:apply-templates select="./egonp:sekciaZiadatelFOKontakt" />
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODetail">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:table>
        <fo:table-column />
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Titul pred menom</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODetailTitulPred_PrefixQualificationAffix" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Meno</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODetailMeno_GivenName" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Rodné číslo</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODetailRC" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Titul za menom</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODetailTitulZa_PostfixQualificationAffix" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Priezvisko</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODetailPriezvisko_FamilyName" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Dátum narodenia</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODetailDatumNarodenia_DateOfBirth" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOTrvalyPobytAdresa_PhysicalAddress">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Adresa trvalého pobytu</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-column />
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Štát</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOTrvalyPobytAdresaStat_Country" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Obec</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOTrvalyPobytAdresaObec_Municipality" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Ulica</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOTrvalyPobytAdresaUlica_StreetName" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Kraj</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOTrvalyPobytAdresaKraj_Region" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Časť obce</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOTrvalyPobytAdresaCastObce_District" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Súp.č.</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOTrvalyPobytAdresaSupC_PropertyRegistrationNumber" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Okres</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOTrvalyPobytAdresaOkres_County" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>PSČ</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOTrvalyPobytAdresaPSC_PostalCode" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Or.č.</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOTrvalyPobytAdresaOrC_BuildingNumber" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOPrechodnyPobytAdresa">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Adresa prechodného pobytu (vyplňte ak je adresa iná ako adresa trvalého pobytu)</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-column />
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Štát</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOPrechodnyPobytAdresaStat_Country" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Obec</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOPrechodnyPobytAdresaObec_Municipality" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Ulica</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOPrechodnyPobytAdresaUlica_StreetName" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Kraj</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOPrechodnyPobytAdresaKraj_Region" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Časť obce</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOPrechodnyPobytAdresaCastObce_District" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Súp.č.</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOPrechodnyPobytAdresaSupC_PropertyRegistrationNumber" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Okres</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOPrechodnyPobytAdresaOkres_County" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>PSČ</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOPrechodnyPobytAdresaPSC_PostalCode" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Or.č.</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOPrechodnyPobytAdresaOrC_BuildingNumber" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFODorucenieAdresa_DeliveryAddress">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Adresa pre doručenie (vyplňte ak je adresa iná ako adresa trvalého pobytu)</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-column />
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Štát</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODorucenieAdresaStat_Country" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Obec</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODorucenieAdresaObec_Municipality" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Ulica</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODorucenieAdresaUlica_StreetName" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Kraj</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODorucenieAdresaKraj_Region" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Časť obce</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODorucenieAdresaCastObce_District" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Súp.č.</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODorucenieAdresaSupC_PropertyRegistrationNumber" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Okres</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODorucenieAdresaOkres_County" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>PSČ</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODorucenieAdresaPSC_PostalCode" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Or.č.</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFODorucenieAdresaOrC_BuildingNumber" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaZiadatelFO_PhysicalPerson/egonp:sekciaZiadatelFOKontakt">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Kontakt</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Telefónne číslo</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOKontaktTelCislo_TelephoneAddress" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>E-mailová adresa</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:ZiadatelFOKontaktEmailAdresa" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Nehnuteľnosť</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <xsl:apply-templates select="./egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress" />
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNehnutelnost/egonp:sekciaNehnutelnostAdresaNehnutelnosti_PhysicalAddress">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Adresa nehnuteľnosti</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-column />
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Štát</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:NehnutelnostAdresaNehnutelnostiStat_Country" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Obec</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:NehnutelnostAdresaNehnutelnostiObec_Municipality" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Ulica</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:NehnutelnostAdresaNehnutelnostiUlica_StreetName" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Kraj</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:NehnutelnostAdresaNehnutelnostiKraj_Region" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Časť obce</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:NehnutelnostAdresaNehnutelnostiCastObce_District" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Súp.č.</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:NehnutelnostAdresaNehnutelnostiSupC_PropertyRegistrationNumber" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Okres</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:NehnutelnostAdresaNehnutelnostiOkres_County" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>PSČ</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:NehnutelnostAdresaNehnutelnostiPSC_PostalCode" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Or.č.</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:NehnutelnostAdresaNehnutelnostiOrC_BuildingNumber" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:table>
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <xsl:apply-templates select="./egonp:sekciaOsobyUzivajucePocet" />
              <xsl:apply-templates select="./egonp:sekciaOsobyUzivajuceZoznam" />
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajucePocet">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Počet osôb užívajúcich nehnuteľnosť</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Počet osôb, ktoré využívajú nehnuteľnosť, resp. majú prihlásený trvalý alebo prechodný pobyt, majú právo užívať nehnuteľnosť na uvedenej adrese</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajucePocet" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Prihlásená osoba</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-column />
        <fo:table-column />
        <fo:table-column />
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Meno</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajuceZoznamMeno_GivenName" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Priezvisko</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajuceZoznamPriezvisko_FamilyName" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Dátum narodenia</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajuceZoznamMeno_DateOfBirth" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Označenie pobytu</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:choose>
                            <xsl:when test="OsobyUzivajuceZoznamTypPobytu[text()='TP']">
                              <fo:block>Trval&#253;</fo:block>
                            </xsl:when>
                            <xsl:when test="OsobyUzivajuceZoznamTypPobytu[text()='PP']">
                              <fo:block>Prechodn&#253;</fo:block>
                            </xsl:when>
                            <xsl:when test="OsobyUzivajuceZoznamTypPobytu[text()='U']">
                              <fo:block>Už&#237;vateľ</fo:block>
                            </xsl:when>
                            <xsl:when test="OsobyUzivajuceZoznamTypPobytu[text()='PU']">
                              <fo:block>Pr&#225;vo už&#237;vať</fo:block>
                            </xsl:when>
                            <xsl:otherwise>
                              <xsl:value-of select="./egonp:OsobyUzivajuceZoznamTypPobytu" />
                            </xsl:otherwise>
                          </xsl:choose>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <xsl:apply-templates select="./egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress" />
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaOsobyUzivajuce/egonp:sekciaOsobyUzivajuceZoznam/egonp:sekciaOsobyUzivajuceZoznamTrvalyPobytAdresa_PhysicalAddress">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Adresa trvalého pobytu</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-column />
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Štát</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaStat_Country" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Obec</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaObec_Municipality" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Ulica</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaUlica_StreetName" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Kraj</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaKraj_Region" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Časť obce</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaCastObce_District" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Súp.č.</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaSupC_PropertyRegistrationNumber" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Okres</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaOkres_County" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>PSČ</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaPSC_PostalCode" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Or.č.</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:OsobyUzivajuceZoznamTrvalyPobytAdresaOrC_BuildingNumber" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:SekciaOchranaOsobnychUdajov">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Ochrana osobných údajov</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona.</fo:block>
                      </fo:table-cell>
                      <fo:table-cell>
                        <fo:block>
                          <xsl:choose>
                            <xsl:when test="egonp:OchranaOsobnychUdajovSuhlas[text()='Žiadateľ ako dotknutá osoba v súlade s ustanovením § 11 zákona č. 122/2013 Z. z. o ochrane osobných údajov a o zmene a doplnení niektorých zákonov (ďalej len „zákon), poskytuje Mestu Nitra, ako prevádzkovateľovi, súhlas so spracovaním osobných údajov uvedených v tejto žiadosti a jej požadovaných prílohách, a to za účelom bezpečnej a zámenu vylučujúcej identifikácie dotknutej osoby s tým, že je oprávnený tento súhlas písomne odvolať v prípade preukázateľného porušenia zákona zo strany prevádzkovateľa. Odvolanie musí byť urobené písomne a preukázateľne doručené Mestu Nitra.  Doba platnosti súhlasu sa viaže na dobu trvania preukázateľného účelu spracúvania osobných údajov dotknutej osoby. Prevádzkovateľ týmto prehlasuje, že osobné údaje dotknutej osoby bude spracovávať plne v súlade s ustanoveniami zákona.']">
                              <fo:inline font-family="Wingdings">&#xF078;</fo:inline>
                            </xsl:when>
                            <xsl:otherwise>
                              <fo:inline font-family="Wingdings">&#xF0A8;</fo:inline>
                            </xsl:otherwise>
                          </xsl:choose>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaNotifikacie">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Notifikácie</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Zasielanie upozornení</fo:block>
                      </fo:table-cell>
                      <fo:table-cell>
                        <fo:block>
                          <fo:table>
                            <fo:table-column />
                            <fo:table-column />
                            <fo:table-body>
                              <fo:table-row>
                                <fo:table-cell>
                                  <fo:block>Žiadne</fo:block>
                                </fo:table-cell>
                                <fo:table-cell>
                                  <fo:block>
                                    <xsl:choose>
                                      <xsl:when test="egonp:NotifikacieZasielanie[text()='1']">
                                        <fo:inline font-family="Wingdings">&#xF0A4;</fo:inline>
                                      </xsl:when>
                                      <xsl:otherwise>
                                        <fo:inline font-family="Wingdings">&#xF0A1;</fo:inline>
                                      </xsl:otherwise>
                                    </xsl:choose>
                                  </fo:block>
                                </fo:table-cell>
                              </fo:table-row>
                            </fo:table-body>
                          </fo:table>
                          <fo:table>
                            <fo:table-column />
                            <fo:table-column />
                            <fo:table-body>
                              <fo:table-row>
                                <fo:table-cell>
                                  <fo:block>eDesk</fo:block>
                                </fo:table-cell>
                                <fo:table-cell>
                                  <fo:block>
                                    <xsl:choose>
                                      <xsl:when test="egonp:NotifikacieZasielanie[text()='2']">
                                        <fo:inline font-family="Wingdings">&#xF0A4;</fo:inline>
                                      </xsl:when>
                                      <xsl:otherwise>
                                        <fo:inline font-family="Wingdings">&#xF0A1;</fo:inline>
                                      </xsl:otherwise>
                                    </xsl:choose>
                                  </fo:block>
                                </fo:table-cell>
                              </fo:table-row>
                            </fo:table-body>
                          </fo:table>
                          <fo:table>
                            <fo:table-column />
                            <fo:table-column />
                            <fo:table-body>
                              <fo:table-row>
                                <fo:table-cell>
                                  <fo:block>SMS</fo:block>
                                </fo:table-cell>
                                <fo:table-cell>
                                  <fo:block>
                                    <xsl:choose>
                                      <xsl:when test="egonp:NotifikacieZasielanie[text()='3']">
                                        <fo:inline font-family="Wingdings">&#xF0A4;</fo:inline>
                                      </xsl:when>
                                      <xsl:otherwise>
                                        <fo:inline font-family="Wingdings">&#xF0A1;</fo:inline>
                                      </xsl:otherwise>
                                    </xsl:choose>
                                  </fo:block>
                                </fo:table-cell>
                              </fo:table-row>
                            </fo:table-body>
                          </fo:table>
                          <fo:table>
                            <fo:table-column />
                            <fo:table-column />
                            <fo:table-body>
                              <fo:table-row>
                                <fo:table-cell>
                                  <fo:block>E-mail</fo:block>
                                </fo:table-cell>
                                <fo:table-cell>
                                  <fo:block>
                                    <xsl:choose>
                                      <xsl:when test="egonp:NotifikacieZasielanie[text()='4']">
                                        <fo:inline font-family="Wingdings">&#xF0A4;</fo:inline>
                                      </xsl:when>
                                      <xsl:otherwise>
                                        <fo:inline font-family="Wingdings">&#xF0A1;</fo:inline>
                                      </xsl:otherwise>
                                    </xsl:choose>
                                  </fo:block>
                                </fo:table-cell>
                              </fo:table-row>
                            </fo:table-body>
                          </fo:table>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Kontakt</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:NotifikacieKontakt" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaSposobDoruceniaVystupu">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:block background-color="black" color="white" margin-left="3pt" margin-top="3pt" margin-right="3pt" padding-left="1pt" padding-top="2pt">Spôsob doručenia výstupu</fo:block>
      <fo:block color="white">|</fo:block>
      <fo:table>
        <fo:table-column />
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Spôsob doručenia výstupu</fo:block>
                      </fo:table-cell>
                      <fo:table-cell>
                        <fo:block>
                          <fo:table>
                            <fo:table-column />
                            <fo:table-column />
                            <fo:table-body>
                              <fo:table-row>
                                <fo:table-cell>
                                  <fo:block>eDesk</fo:block>
                                </fo:table-cell>
                                <fo:table-cell>
                                  <fo:block>
                                    <xsl:choose>
                                      <xsl:when test="egonp:SposobDoruceniaVystupuTyp[text()='eDesk']">
                                        <fo:inline font-family="Wingdings">&#xF0A4;</fo:inline>
                                      </xsl:when>
                                      <xsl:otherwise>
                                        <fo:inline font-family="Wingdings">&#xF0A1;</fo:inline>
                                      </xsl:otherwise>
                                    </xsl:choose>
                                  </fo:block>
                                </fo:table-cell>
                              </fo:table-row>
                            </fo:table-body>
                          </fo:table>
                          <fo:table>
                            <fo:table-column />
                            <fo:table-column />
                            <fo:table-body>
                              <fo:table-row>
                                <fo:table-cell>
                                  <fo:block>osobne</fo:block>
                                </fo:table-cell>
                                <fo:table-cell>
                                  <fo:block>
                                    <xsl:choose>
                                      <xsl:when test="egonp:SposobDoruceniaVystupuTyp[text()='osobne']">
                                        <fo:inline font-family="Wingdings">&#xF0A4;</fo:inline>
                                      </xsl:when>
                                      <xsl:otherwise>
                                        <fo:inline font-family="Wingdings">&#xF0A1;</fo:inline>
                                      </xsl:otherwise>
                                    </xsl:choose>
                                  </fo:block>
                                </fo:table-cell>
                              </fo:table-row>
                            </fo:table-body>
                          </fo:table>
                          <fo:table>
                            <fo:table-column />
                            <fo:table-column />
                            <fo:table-body>
                              <fo:table-row>
                                <fo:table-cell>
                                  <fo:block>poštou</fo:block>
                                </fo:table-cell>
                                <fo:table-cell>
                                  <fo:block>
                                    <xsl:choose>
                                      <xsl:when test="egonp:SposobDoruceniaVystupuTyp[text()='poštou']">
                                        <fo:inline font-family="Wingdings">&#xF0A4;</fo:inline>
                                      </xsl:when>
                                      <xsl:otherwise>
                                        <fo:inline font-family="Wingdings">&#xF0A1;</fo:inline>
                                      </xsl:otherwise>
                                    </xsl:choose>
                                  </fo:block>
                                </fo:table-cell>
                              </fo:table-row>
                            </fo:table-body>
                          </fo:table>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block>Kontakt v prípade doručenia osobne / poštou</fo:block>
                      </fo:table-cell>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:SposobDoruceniaVystupuKontakt" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
<xsl:template match="egonp:eForm_eGov_001/egonp:sekciaFooter">
  <fo:block border-width="0.3pt" border-style="solid" margin-left="1pt" margin-top="6pt" margin-right="1pt">
    <fo:block margin-bottom="6pt">
      <fo:table>
        <fo:table-column />
        <fo:table-body>
          <fo:table-row>
            <fo:table-cell>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell border-width="0.6pt" border-style="solid" background-color="white" padding="1pt">
                        <fo:block>
                          <xsl:value-of select="./egonp:footerLink" />
                          <fo:inline color="white">___</fo:inline>
                        </fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
              <fo:block margin-top="3mm" margin-right="3mm">
                <fo:table>
                  <fo:table-column />
                  <fo:table-body>
                    <fo:table-row>
                      <fo:table-cell>
                        <fo:block margin-top="1mm">NITRA je moderné a otvorené mesto pre všetkých</fo:block>
                      </fo:table-cell>
                    </fo:table-row>
                  </fo:table-body>
                </fo:table>
              </fo:block>
            </fo:table-cell>
          </fo:table-row>
        </fo:table-body>
      </fo:table>
    </fo:block>
  </fo:block>
</xsl:template>
	
        </xsl:stylesheet>

77u/PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz48cG9zcD48ZmllbGRzPjxmaWVsZD48aWQ+Q2hlY2taRVA8L2lkPjx2YWx1ZT5mYWxzZTwvdmFsdWU+PC9maWVsZD48ZmllbGQ+PGlkPlBheW1lbnRPcmRlcjwvaWQ+PHZhbHVlPmZhbHNlPC92YWx1ZT48L2ZpZWxkPjxmaWVsZD48aWQ+RGVsaXZlcnk8L2lkPjx2YWx1ZT5mYWxzZTwvdmFsdWU+PC9maWVsZD48ZmllbGQ+PGlkPlNpZ248L2lkPjx2YWx1ZT5mYWxzZTwvdmFsdWU+PC9maWVsZD48L2ZpZWxkcz48b3JjaGVzdHJhdGlvbj48aWQ+MTwvaWQ+PC9vcmNoZXN0cmF0aW9uPjwvcG9zcD4=