Главное меню
ГЛАВНАЯ
Я-ХУДОЖНИК
РИСУЙ С НАМИ
КОНКУРСЫ
ЗАЯВКА
ЛИЧНЫЙ КАБИНЕТ
ЛК
ГАЛЕРЕЯ
РЕЗУЛЬТАТЫ
ВНЕУРОЧКА
ВИДЕОУРОКИ
ЖУРНАЛ
О НАС
ВХОД | РЕГИСТРАЦИЯ
ВХОД | РЕГИСТРАЦИЯ
?
ПОЛОЖЕНИЯ О КОНКУРСАХ
Волшебная ВЕСНА
О КОНКУРСЕ
ПОЛОЖЕНИЕ О КОНКУРСЕ
ЧИТАТЬ
СКАЧАТЬ
Подарок своими руками
О КОНКУРСЕ
ПОЛОЖЕНИЕ О КОНКУРСЕ
ЧИТАТЬ
СКАЧАТЬ
Космическое путешествие
О КОНКУРСЕ
ПОЛОЖЕНИЕ О КОНКУРСЕ
ЧИТАТЬ
СКАЧАТЬ
Подвиги наших СОЛДАТ
О КОНКУРСЕ
ПОЛОЖЕНИЕ О КОНКУРСЕ
ЧИТАТЬ
СКАЧАТЬ
На службе ОТЕЧЕСТВУ
О КОНКУРСЕ
ПОЛОЖЕНИЕ О КОНКУРСЕ
ЧИТАТЬ
СКАЧАТЬ
Вечная память ВЕТЕРАНАМ
О КОНКУРСЕ
ПОЛОЖЕНИЕ О КОНКУРСЕ
ЧИТАТЬ
СКАЧАТЬ
Мои любимые животные
О КОНКУРСЕ
ПОЛОЖЕНИЕ О КОНКУРСЕ
ЧИТАТЬ
СКАЧАТЬ
ПДД знай - по дороге не гуляй
О КОНКУРСЕ
ПОЛОЖЕНИЕ О КОНКУРСЕ
ЧИТАТЬ
СКАЧАТЬ
Маме с любовью
О КОНКУРСЕ
ПОЛОЖЕНИЕ О КОНКУРСЕ
ЧИТАТЬ
СКАЧАТЬ
Моя СЕМЬЯ - мое богатство
О КОНКУРСЕ
ПОЛОЖЕНИЕ О КОНКУРСЕ
ЧИТАТЬ
СКАЧАТЬ
<tr class="row-6"><td class="col-1 col-first">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/kanikuly" >Приключения на каникулах</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/kanikuly" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/universalnyy_diplom_1_stepeni.jpg?itok=FrFRv9XQ" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/universalnyy_diplom_1_stepeni.jpg?itok=bJyjb55S" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Приключения на каникулах" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/kanikuly" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/universalnyy_sertifikat.jpg?itok=En2l461M" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/universalnyy_sertifikat.jpg?itok=uFjynqNq" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Приключения на каникулах"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-884"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/kanikuly" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-kanikuly_0.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-kanikuly_0.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-kanikuly_0.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-884" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-884" class="konkursnid" type="hidden" name="konkursnid" value="884"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td><td class="col-2 col-last">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/narodnye-promysly" >НАРОДНЫЕ ПРОМЫСЛЫ</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/narodnye-promysly" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_universalnyi2.jpg?itok=-sI-RLIT" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_universalnyi2.jpg?itok=HOhxwX49" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса НАРОДНЫЕ ПРОМЫСЛЫ" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/narodnye-promysly" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_universalnyi2.jpg?itok=l5179vDl" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_universalnyi2.jpg?itok=i85xCP6L" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса НАРОДНЫЕ ПРОМЫСЛЫ"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-171898"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/narodnye-promysly" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-narodnye-promysly.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-narodnye-promysly.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-narodnye-promysly.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-171898" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-171898" class="konkursnid" type="hidden" name="konkursnid" value="171898"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td></tr><tr class="row-7"><td class="col-1 col-first">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/v-mire-cvetov" >В мире цветов</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/v-mire-cvetov" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_mir_cvetov.jpg?itok=EbItafEJ" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_mir_cvetov.jpg?itok=6mF2sSz-" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса В мире цветов" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/v-mire-cvetov" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_mir_cvetov.jpg?itok=ljlaB7EB" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_mir_cvetov.jpg?itok=40TaMlhs" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса В мире цветов"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-50377"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/v-mire-cvetov" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-v-mire-cvetov.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-v-mire-cvetov.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-v-mire-cvetov.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-50377" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-50377" class="konkursnid" type="hidden" name="konkursnid" value="50377"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td><td class="col-2 col-last">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/lyubi-svoy-kray" >Люби и знай родной свой край</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/lyubi-svoy-kray" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_lubi_i_znai_rodnoi_cvoi_krai.jpg?itok=ZGOKBAj2" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_lubi_i_znai_rodnoi_cvoi_krai.jpg?itok=mMpdsXWe" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Люби и знай родной свой край" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/lyubi-svoy-kray" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_lubi_i_znai_rodnoi_cvoi_krai.jpg?itok=w6t0MH-9" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_lubi_i_znai_rodnoi_cvoi_krai.jpg?itok=TEj2JgBD" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Люби и знай родной свой край"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-1115"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/lyubi-svoy-kray" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-lyubi-svoy-kray_0.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-lyubi-svoy-kray_0.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-lyubi-svoy-kray_0.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-1115" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-1115" class="konkursnid" type="hidden" name="konkursnid" value="1115"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td></tr><tr class="row-8"><td class="col-1 col-first">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/peyzazhi" >Пейзажи родного края</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/peyzazhi" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/peyzazh_-_diplom_1_stepeni.jpg?itok=cyQZUku7" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/peyzazh_-_diplom_1_stepeni.jpg?itok=mLpA78Ew" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Пейзажи родного края" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/peyzazhi" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/peyzazh_-sertifikat_uchastnika_15.jpg?itok=ZAGUSJAs" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/peyzazh_-sertifikat_uchastnika_15.jpg?itok=y6Rrr5v0" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Пейзажи родного края"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-114"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/peyzazhi" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-peizagi_0.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-peizagi_0.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-peizagi_0.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-114" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-114" class="konkursnid" type="hidden" name="konkursnid" value="114"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td><td class="col-2 col-last">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/ecolog" >Юный эколог</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/ecolog" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_ecolog.jpg?itok=p0he-52C" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_ecolog.jpg?itok=_4mJ3iMy" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Юный эколог" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/ecolog" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_ecolog.jpg?itok=PIWAakRC" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_ecolog.jpg?itok=ezqLP_Cz" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Юный эколог"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-63066"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/ecolog" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-ecolog.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-ecolog.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-ecolog.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-63066" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-63066" class="konkursnid" type="hidden" name="konkursnid" value="63066"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td></tr><tr class="row-9"><td class="col-1 col-first">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/podvodnyy-mir" >Подводный мир</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/podvodnyy-mir" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/dipl1_podvodnmir.jpg?itok=mTxnAi7a" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/dipl1_podvodnmir.jpg?itok=nCLlwUlS" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Подводный мир" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/podvodnyy-mir" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_podvodnmir.jpg?itok=9TGWAsIs" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_podvodnmir.jpg?itok=IKnuGQ26" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Подводный мир"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-50386"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/podvodnyy-mir" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-podvodnyi-mir.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-podvodnyi-mir.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-podvodnyi-mir.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-50386" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-50386" class="konkursnid" type="hidden" name="konkursnid" value="50386"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td><td class="col-2 col-last">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/skazochnyy-geroy" >Любимый сказочный герой</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/skazochnyy-geroy" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_skazgeroy.jpg?itok=_B3ICQnX" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_skazgeroy.jpg?itok=DpqbM5o1" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Любимый сказочный герой" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/skazochnyy-geroy" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_skazgeroy.jpg?itok=ydci5_LF" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_skazgeroy.jpg?itok=1JvpRcYv" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Любимый сказочный герой"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-1119"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/skazochnyy-geroy" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-skazochnyy-geroy.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-skazochnyy-geroy.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-skazochnyy-geroy.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-1119" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-1119" class="konkursnid" type="hidden" name="konkursnid" value="1119"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td></tr><tr class="row-10"><td class="col-1 col-first">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/geroi-lyubimyh-multfilmov" >Герои любимых мультфильмов</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/geroi-lyubimyh-multfilmov" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_geroi_lubimih_multfilmov.jpg?itok=sLsMTaEd" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_geroi_lubimih_multfilmov.jpg?itok=A_rUF2aI" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Герои любимых мультфильмов" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/geroi-lyubimyh-multfilmov" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_geroi_lubimih_multfilmov.jpg?itok=u612pFBH" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_geroi_lubimih_multfilmov.jpg?itok=-nPNUjCu" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Герои любимых мультфильмов"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-50684"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/geroi-lyubimyh-multfilmov" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-geroi-multfilmov_0.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-geroi-multfilmov_0.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-geroi-multfilmov_0.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-50684" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-50684" class="konkursnid" type="hidden" name="konkursnid" value="50684"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td><td class="col-2 col-last">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/doctor" >Спасибо скажем ДОКТОРАМ!</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/doctor" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/universalnyy_diplom_1_stepeni_4.jpg?itok=fo3GTRly" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/universalnyy_diplom_1_stepeni_4.jpg?itok=uavDSV9M" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Спасибо скажем ДОКТОРАМ!" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/doctor" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/universalnyy_sertifikat_5.jpg?itok=aOfY0ykw" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/universalnyy_sertifikat_5.jpg?itok=AXnSkg46" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Спасибо скажем ДОКТОРАМ!"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-36524"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/doctor" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-doctor.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-doctor.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-doctor.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-36524" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-36524" class="konkursnid" type="hidden" name="konkursnid" value="36524"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td></tr><tr class="row-11"><td class="col-1 col-first">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/territoriya-bezopasnosti" >СТОП, УГРОЗА. Территория БЕЗопасности!</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/territoriya-bezopasnosti" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/universalnyy_diplom_1_stepeni_3.jpg?itok=RGs-P8HH" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/universalnyy_diplom_1_stepeni_3.jpg?itok=CXsGoeFy" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса СТОП, УГРОЗА. Территория БЕЗопасности!" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/territoriya-bezopasnosti" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/universalnyy_sertifikat_3.jpg?itok=mQR_eUqg" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/universalnyy_sertifikat_3.jpg?itok=dFODmmTF" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса СТОП, УГРОЗА. Территория БЕЗопасности!"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-1113"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/territoriya-bezopasnosti" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-territoriya-bezopasnosti_0.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-territoriya-bezopasnosti_0.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-territoriya-bezopasnosti_0.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-1113" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-1113" class="konkursnid" type="hidden" name="konkursnid" value="1113"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td><td class="col-2 col-last">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/fantazii" >Детские фантазии</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/fantazii" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/universalnyy_diplom_1_stepeni_1.jpg?itok=C_sywX-2" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/universalnyy_diplom_1_stepeni_1.jpg?itok=VrI3rgPm" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Детские фантазии" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/fantazii" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/universalnyy_sertifikat_1.jpg?itok=SQt4IhAV" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/universalnyy_sertifikat_1.jpg?itok=TZ5SC2DG" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Детские фантазии"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-882"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/fantazii" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-fantazii_0.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-fantazii_0.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-fantazii_0.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-882" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-882" class="konkursnid" type="hidden" name="konkursnid" value="882"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td></tr><tr class="row-12"><td class="col-1 col-first">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/sport" >Спорт в моей жизни</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/sport" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_sport.jpg?itok=0dpBWIhY" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_sport.jpg?itok=U-xIneAx" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Спорт в моей жизни" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/sport" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_sport.jpg?itok=0LULsYfO" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_sport.jpg?itok=i_5O1NDc" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Спорт в моей жизни"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-50388"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/sport" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-_sport.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-_sport.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-_sport.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-50388" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-50388" class="konkursnid" type="hidden" name="konkursnid" value="50388"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td><td class="col-2 col-last">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/zima" >Зимние забавы</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/zima" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_zima.jpg?itok=5PsDn5zH" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_zima.jpg?itok=21RTEOJ7" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Зимние забавы" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/zima" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_zima.jpg?itok=ndhP9Pi9" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_zima.jpg?itok=t6V0zHkY" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Зимние забавы"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-5143"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/zima" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-zima.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-zima.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-zima.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-5143" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-5143" class="konkursnid" type="hidden" name="konkursnid" value="5143"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td></tr><tr class="row-13"><td class="col-1 col-first">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/leto" >Краски лета</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/leto" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_leto.jpg?itok=m4ROMs86" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_leto.jpg?itok=yFQJQoCx" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Краски лета" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/leto" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_leto.jpg?itok=aqr5kBhF" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_leto.jpg?itok=SldFAr7f" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Краски лета"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-883"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/leto" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-leto.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-leto.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-leto.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-883" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-883" class="konkursnid" type="hidden" name="konkursnid" value="883"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td><td class="col-2 col-last">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/osennie-fantazii" >Осенние фантазии</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/osennie-fantazii" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_osen_0.jpg?itok=bwdH5m27" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_osen_0.jpg?itok=RNFYbVFg" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Осенние фантазии" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/osennie-fantazii" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_osen_0.jpg?itok=CdFP2s1j" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_osen_0.jpg?itok=ownHVr7b" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Осенние фантазии"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-1118"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/osennie-fantazii" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-osennie-fantazii.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-osennie-fantazii.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-osennie-fantazii.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-1118" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-1118" class="konkursnid" type="hidden" name="konkursnid" value="1118"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td></tr><tr class="row-14"><td class="col-1 col-first">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/my-vstrechaem-novyy-god" >Мы встречаем НОВЫЙ ГОД</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/my-vstrechaem-novyy-god" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_novgod_0.jpg?itok=E1NNvxYJ" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_novgod_0.jpg?itok=eHbnw7o3" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Мы встречаем НОВЫЙ ГОД" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/my-vstrechaem-novyy-god" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_novgod_0.jpg?itok=SWSM7piZ" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_novgod_0.jpg?itok=V2JzUUo7" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Мы встречаем НОВЫЙ ГОД"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-2914"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/my-vstrechaem-novyy-god" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-vstrechaem-novyy-god.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-vstrechaem-novyy-god.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-vstrechaem-novyy-god.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-2914" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki" >  
					<input id="konkursnid-2914" class="konkursnid" type="hidden" name="konkursnid" value="2914"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						

	</div>

</div>





</span>  </div>  

  </td><td class="col-2 col-last">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/peyzazh" >Мой любимый пейзаж</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/peyzazh" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_mou_lubimiy_peizaj.jpg?itok=B4uQa6kP" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_mou_lubimiy_peizaj.jpg?itok=yXhjQnZG" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Мой любимый пейзаж" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/peyzazh" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_mou_lubimiy_peizaj.jpg?itok=j7LIkAnt" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_mou_lubimiy_peizaj.jpg?itok=58lfFm5p" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Мой любимый пейзаж"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-61407"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/peyzazh" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-peyzazh.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-peyzazh.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-peyzazh.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-61407" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/konkurs/peyzazh?art=1#div-main-zayvka-new" >  
					<input id="konkursnid-61407" class="konkursnid" type="hidden" name="konkursnid" value="61407"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						<div class="div-img-palitra" >
						<img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/konkurs/button/palitra.png"  height="27" width="34"   style="width:34px;float:left;" alt="конкурс для художественных школ, изостудий"/>
						<span style="color:#b2b2b2;">Для художественных школ, изостудий и других проф.&nbsp;учреждений</span>
				</div>
						

	</div>

</div>





</span>  </div>  

  </td></tr><tr class="row-15"><td class="col-1 col-first">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/rodnoy-kray" >Конкурс пленэрных работ 'Мой родной край!'</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/rodnoy-kray" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_univ.jpg?itok=QKz4f2A8" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_univ.jpg?itok=wChqDGgv" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Конкурс пленэрных работ 'Мой родной край!'" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/rodnoy-kray" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_univ.jpg?itok=8qRyRiDW" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_univ.jpg?itok=3eiK6dw6" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Конкурс пленэрных работ 'Мой родной край!'"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-49040"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/rodnoy-kray" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-rodnoy-kray.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-rodnoy-kray.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-rodnoy-kray.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-49040" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/konkurs/rodnoy-kray?art=1#div-main-zayvka-new" >  
					<input id="konkursnid-49040" class="konkursnid" type="hidden" name="konkursnid" value="49040"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						<div class="div-img-palitra" >
						<img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/konkurs/button/palitra.png"  height="27" width="34"   style="width:34px;float:left;" alt="конкурс для художественных школ, изостудий"/>
						<span style="color:#b2b2b2;">Для художественных школ, изостудий и других проф.&nbsp;учреждений</span>
				</div>
						

	</div>

</div>





</span>  </div>  

  </td><td class="col-2 col-last">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/risyi-s-nami-final" >РИСУЙ С НАМИ! (финальный этап всероссийского конкурса талантов)</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/risyi-s-nami-final" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom_risyisnami_final_jury.jpg?itok=4bRN6mhV" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom_risyisnami_final_jury.jpg?itok=hHuEMNPz" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса РИСУЙ С НАМИ! (финальный этап всероссийского конкурса талантов)" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/risyi-s-nami-final" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_risyisnami_final.jpg?itok=Bmh8u1B5" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_risyisnami_final.jpg?itok=neOBLeF3" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса РИСУЙ С НАМИ! (финальный этап всероссийского конкурса талантов)"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-285899"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/risyi-s-nami-final" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie_risyisnami_23_1.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie_risyisnami_23_1.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie_risyisnami_23_1.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-285899" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/konkurs-talantov" >  
					<input id="konkursnid-285899" class="konkursnid" type="hidden" name="konkursnid" value="285899"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
								<div class="div-img-palitra" >
						<img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/minobr/minobr.png"  height="27" width="34"   style="width:34px;float:left;" alt="конкурс минпросвещения"/>
						<span style="color:#b2b2b2;"> &nbsp;Утвержден приказом Минпросвещения России</span>
				</div>
				

	</div>

</div>





</span>  </div>  

  </td></tr><tr class="row-16"><td class="col-1 col-first">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/syuzhety-skazok" >Сюжеты сказок России и мира</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/syuzhety-skazok" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/dipl_1_prof_skazka_0.jpg?itok=IwDKdJSr" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/dipl_1_prof_skazka_0.jpg?itok=bVcvl7ms" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Сюжеты сказок России и мира" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/syuzhety-skazok" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_prof_skazka_0.jpg?itok=eHW6B2Lh" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_prof_skazka_0.jpg?itok=JTvfa4m9" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Сюжеты сказок России и мира"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-11693"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/syuzhety-skazok" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-syuzhety-skazok.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-syuzhety-skazok.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-syuzhety-skazok.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-11693" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/konkurs/syuzhety-skazok?art=1#div-main-zayvka-new" >  
					<input id="konkursnid-11693" class="konkursnid" type="hidden" name="konkursnid" value="11693"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						<div class="div-img-palitra" >
						<img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/konkurs/button/palitra.png"  height="27" width="34"   style="width:34px;float:left;" alt="конкурс для художественных школ, изостудий"/>
						<span style="color:#b2b2b2;">Для художественных школ, изостудий и других проф.&nbsp;учреждений</span>
				</div>
						

	</div>

</div>





</span>  </div>  

  </td><td class="col-2 col-last">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/natyurmort" >Натюрморт</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/natyurmort" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/dipl_1_natyurmort_0.jpg?itok=jbpMk7so" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/dipl_1_natyurmort_0.jpg?itok=D_Jm1p3K" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Натюрморт" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/natyurmort" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_natyurmort.jpg.jpg?itok=mCOQoGjY" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_natyurmort.jpg.jpg?itok=6hMyinLT" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Натюрморт"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-11204"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/natyurmort" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-natyurmort.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-natyurmort.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-natyurmort.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-11204" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/konkurs/natyurmort?art=1#div-main-zayvka-new" >  
					<input id="konkursnid-11204" class="konkursnid" type="hidden" name="konkursnid" value="11204"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
						<div class="div-img-palitra" >
						<img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/konkurs/button/palitra.png"  height="27" width="34"   style="width:34px;float:left;" alt="конкурс для художественных школ, изостудий"/>
						<span style="color:#b2b2b2;">Для художественных школ, изостудий и других проф.&nbsp;учреждений</span>
				</div>
						

	</div>

</div>





</span>  </div>  

  </td></tr><tr class="row-17 row-last"><td class="col-1 col-first">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/risyi-s-nami-distancionnyy" >РИСУЙ С НАМИ! (дистанционный этап всероссийского конкурса талантов)</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/risyi-s-nami-distancionnyy" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom1_universalnyi2_0.jpg?itok=xZ0D9bVb" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom1_universalnyi2_0.jpg?itok=0E2jaigT" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса РИСУЙ С НАМИ! (дистанционный этап всероссийского конкурса талантов)" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/risyi-s-nami-distancionnyy" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_universalnyi2_0.jpg?itok=MrGQHkwU" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_universalnyi2_0.jpg?itok=ZKwVPduc" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса РИСУЙ С НАМИ! (дистанционный этап всероссийского конкурса талантов)"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-285898"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/risyi-s-nami-distancionnyy" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie_risyisnami_23_0.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie_risyisnami_23_0.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie_risyisnami_23_0.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-285898" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/konkurs-talantov" >  
					<input id="konkursnid-285898" class="konkursnid" type="hidden" name="konkursnid" value="285898"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"   />
				</form>
			</div>
		</div>	
								<div class="div-img-palitra" >
						<img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/minobr/minobr.png"  height="27" width="34"   style="width:34px;float:left;" alt="конкурс минпросвещения"/>
						<span style="color:#b2b2b2;"> &nbsp;Утвержден приказом Минпросвещения России</span>
				</div>
				

	</div>

</div>





</span>  </div>  

  </td><td class="col-2 col-last">  
  <div class="views-field views-field-nid">        <span class="field-content">

<div class="my-div-description-konkursy" style="margin:0 auto;"> <!-- AVIS-->
		
		<div id="title-description-konkursy" ><a style="color: #ff7300;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/ya-hudozhnik-distancionnyy" >Я - художник! (дистанционный этап всероссийского конкурса талантов)</a></div>

	
	<div class="div-left-description-konkursy" style="display:inline-block;">
		<!--<div>-->
						<div class="div-img-doc-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/ya-hudozhnik-distancionnyy" title="диплом творческого конкурса" ><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style230x320/public/pictures/konkurs/shablon/diplom/diplom_ya_hudojnik1.jpg?itok=ZVBuU6-z" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style100x140/public/pictures/konkurs/shablon/diplom/diplom_ya_hudojnik1.jpg?itok=2o9yjlhf" height="152" width="110" class="img-doc-description-konkurs"  oncontextmenu="return false;" alt="диплом для конкурса Я - художник! (дистанционный этап всероссийского конкурса талантов)" /></a>
			</div>
						<div  style="padding-right:0;" class="div-img-doc-description-konkurs div-img-sert-description-konkurs">
				<a style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/ya-hudozhnik-distancionnyy" title="сертификат всероссийского творческого конкурса"><img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style300x230/public/pictures/konkurs/shablon/sertificat/sert_ya_hudojnik.jpg?itok=QCgR3OM7" data-src-mob="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/styles/style140x100/public/pictures/konkurs/shablon/sertificat/sert_ya_hudojnik.jpg?itok=yojYLbpz" height="78" width="110" class="img-doc-description-konkurs"   oncontextmenu="return false;" alt="сертификат для конкурса Я - художник! (дистанционный этап всероссийского конкурса талантов)"/></a>
				<div style="position: relative;text-align:center;font-size: 1.0em;text-decoration:unset"><a id="konkursy-btnPodrobnee-203321"  style="color: #00ade6;text-decoration:unset;" href="https://xn--80apbcqesjbs.xn--p1ai/konkurs/ya-hudozhnik-distancionnyy" >О КОНКУРСЕ</a></div>
			</div>

		<!--</div>-->

	</div>


	<div class="div-right-description-konkursy" style="display:inline-block;vertical-align:top;padding-left:4px;text-align:center;">
		<div style="display:inline-block;vertical-align:top;max-width:100%;">
			<div class="div-pologenie-description-konkursy" ><a style="color: #00ade6;text-decoration:unset;font-size: 94%;" href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-ya-hudozhnik-23.pdf" target="_blank" >ПОЛОЖЕНИЕ О КОНКУРСЕ</a></div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-ya-hudozhnik-23.pdf" target="_blank" ><button class="button_5" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">ЧИТАТЬ</button></a>
			</div>
			<div style="display:inline-block;max-width:48%;">
				<a  href="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/documents/pologenie_konkursy/polozenie-ya-hudozhnik-23.pdf" download ><button class="button_5 skachat" style="padding: 1px 10px;min-width:unset; height:20px;font-size:12px;">СКАЧАТЬ</button></a>
			</div>
			<div class="div-btn-uchastvovat" style="display:block;margin-top:14px;width:100%;">
			<!--  Кнопка участвовать  -->
							<form  id="formbtnzayvka-new-203321" method="POST" action="https://xn--80apbcqesjbs.xn--p1ai/zayavka-na-konkurs-ya-hudozhnik" >  
					<input id="konkursnid-203321" class="konkursnid" type="hidden" name="konkursnid" value="203321"> 
					<input class="button_2" style="width:100%;height:28px;" type="submit" value="УЧАСТВОВАТЬ" name="zayvkakonkurs"  onclick="alert(`Заявку на конкурс можно будет подать с 01 сентября 2024 года.`); return false;" />
				</form>
			</div>
		</div>	
								<div class="div-img-palitra" >
						<img data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/minobr/minobr.png"  height="27" width="34"   style="width:34px;float:left;" alt="конкурс минпросвещения"/>
						<span style="color:#b2b2b2;"> &nbsp;Утвержден приказом Минпросвещения России</span>
				</div>
				

	</div>

</div>





</span>  </div>  

  </td></tr>
АРХИВ ПОЛОЖЕНИЙ О КОНКУРСАХ
Скачать Архив за 2019-2020
Скачать Архив за 2020-2021
Скачать Архив за 2021-2022 часть 1
Скачать Архив за 2021-2022 часть 2
Скачать Архив за 2022-2023 часть 1
Скачать Архив за 2022-2023 часть 2
ПОЛОЖЕНИЯ
О КОНКУРСАХ
НОВИНКИ
ТАЛАНТЫ РОССИИ
- конкурс
"Я - художник"
КОНКУРС ТАЛАНТОВ
"Рисуй с нами"
ВИДЕОУРОКИ
- смотри и рисуй вместе с нами
ВНЕУРОЧКА
- материалы для творческого развития
«ТВОРЧЕСТВО БЕЗ ГРАНИЦ»
Педагогический журнал |
читать
ТОВАРЫ для ТВОРЧЕСТВА
В нашем магазине Вы можете приобрести товары для творчества!
В магазин
<div id="footer-columns" class="clearfix">  <div class="region region-footer-firstcolumn">
    <div id="block-block-28" class="block block-block">

    
  <div class="content">
    <div class="footer-new" id="footer-1"><img width="218" height="45" class="img-hidden-load" alt="официальный сайт творческих конкурсов рисунка" id="namesiteimg" data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/podval/namesite_podval.svg" />
<table id="podval-namesite" style="background:#fff; color:grey">
	<tbody>
		<tr>
			<td><a href="https://vk.com/risyi_s_nami" rel="noopener noreferrer" target="_blank" title="Мы в ВК"><img width="35" height="35"  alt="официальная группа  РИСУЙСНАМИ.РФ в ВК" class="myulogin-icon img-hidden-load" data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/button/socseti/vkontakte.svg" /></a>ПОДПИСЫВАЙТЕСЬ НА НАС</td>
		</tr>
		<tr>
			<td><a href="https://www.ok.ru/group/55324841738378" rel="noopener noreferrer" target="_blank" title="Мы в Одноклассниках"><img width="35" height="35"  alt="официальная страничка РИСУЙСНАМИ.РФ в Одноклассниках" class="myulogin-icon img-hidden-load" data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/button/socseti/odnoklassniki.svg" /></a>ДРУЖИТЕ С НАМИ</td>
		</tr>
		<!--<tr>
			<td><a href="https://www.instagram.com/risyi_s_nami/" rel="noopener noreferrer" target="_blank" title="Мы в Instagram"><img width="35" height="35"  alt="официальная страничка  РИСУЙСНАМИ.РФ в Instagram" class="myulogin-icon img-hidden-load" data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/button/socseti/instagram.svg" /></a>СЛЕДИТЕ ЗА НАМИ</td>
		</tr>-->
		 <tr>
			<td><a href="https://t.me/+ev-jCxovFUcwODVi" rel="noopener noreferrer" target="_blank" title="Мы в Телеграм"><img width="35" height="35"  alt="официальная страничка  РИСУЙСНАМИ.РФ в telegram" class="myulogin-icon img-hidden-load" data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/button/socseti/telegram.png" /></a>СЛЕДИТЕ ЗА НАМИ</td>
		</tr>

	</tbody>
</table>
</div>
  </div>
</div>
  </div>
  <div class="region region-footer-secondcolumn">
    <div id="block-block-29" class="block block-block">

    
  <div class="content">
    <table id="footer-2" itemscope itemtype="http://schema.org/SiteNavigationElement">
	<tbody>
		<tr>
			<td id="podval-menu-1" style="width:50%">
			<ul>
				<li   itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/main">ГЛАВНАЯ</a></li>
				<li   itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/content/oformlenie-zayavki">ЗАЯВКА НА КОНКУРС</a></li>
				<li   itemprop="name" ><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/my-diplom-sertificat">ДИПЛОМЫ И СЕРТИФИКАТЫ</a></li>
				<li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/blagodarstvennoe-pismo">БЛАГОДАРСТВЕННЫЕ ПИСЬМА</a></li>
				<li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/descriptionkonkurs">ПОЛОЖЕНИЯ О КОНКУРСАХ</a></li>
				<li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/vneurochka">ВНЕУРОЧКА</a></li>
				<li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/baza-znaniy/service-homework">ДОМАШКА</a></li>
				<li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/raboty_uchastnikov">ГАЛЕРЕЯ</a></li>
                                <li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/">КОНКУРСЫ</a></li>
				<li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/content/rezultaty">РЕЗУЛЬТАТЫ</a></li>
				<li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/master-class-all">ВИДЕОУРОКИ</a></li>
				<li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/all-otzyvy">ОТЗЫВЫ</a></li>
				<li><a href="https://xn--80apbcqesjbs.xn--p1ai/ya-hudozhnik">ТАЛАНТЫ РОССИИ ("Я - художник")</a></li>
				<li><a href="https://xn--80apbcqesjbs.xn--p1ai/konkurs-talantov">КОНКУРС ТАЛАНТОВ ("РИСУЙ С НАМИ")</a></li>
				<!--<li><a class="colorbox-node" href="/bazaznaniy?width=300&amp;height=200">БАЗА ЗНАНИЙ</a></li>-->
                                			</ul>
			</td>
			<td id="podval-menu-2" style="width:50%">
			<ul>
				<li><a href="https://xn--80apbcqesjbs.xn--p1ai/ya-hudozhnik">ТАЛАНТЫ РОССИИ ("Я - художник")</a></li>
				<li><a href="https://xn--80apbcqesjbs.xn--p1ai/konkurs-talantov">КОНКУРС ТАЛАНТОВ ("РИСУЙ С НАМИ")</a></li>
				<li><a href="https://xn--80apbcqesjbs.xn--p1ai/my-diplom-sertificat">ЛИЧНЫЙ КАБИНЕТ</a></li>
				<li><a href="https://xn--80apbcqesjbs.xn--p1ai/homework" rel="nofollow">СОЗДАТЬ ДОМАШНЕЕ ЗАДАНИЕ</a></li>
				<li><a href="https://xn--80apbcqesjbs.xn--p1ai/homework/send" rel="nofollow">ПРОВЕРКА ДОМАШНЕГО ЗАДАНИЯ</a></li>
                                <li ><a href="https://xn--80apbcqesjbs.xn--p1ai/">ТВОРЧЕСКИЕ КОНКУРСЫ </a></li>
				<li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/konkursy-art">КОНКУРСЫ ХУДОЖЕСТВЕННЫХ ШКОЛ</a></li>
				<li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/journal">ПЕДАГОГИЧЕСКИЙ ЖУРНАЛ</a></li>
				<li><a href="https://xn--80apbcqesjbs.xn--p1ai/paint-step">УЧИМСЯ РИСОВАТЬ ПОЭТАПНО</a></li>
				<li><a href="https://xn--80apbcqesjbs.xn--p1ai/vneurochka-raskraska">РАСКРАСКИ</a></li>
                                <li><a href="https://xn--80apbcqesjbs.xn--p1ai/new-interview">ИНТЕРВЬЮ</a></li>
				<li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/content/o-nas">О НАС</a></li>
				<li  itemprop="name"><a itemprop="url" href="https://xn--80apbcqesjbs.xn--p1ai/itogi-2020">ИТОГИ 2020</a></li>

				<!--<li><a href="/content/nashi-uslugi">УСЛУГИ</a></li>-->
			</ul>
			</td>
		</tr>
	</tbody>
</table>
  </div>
</div>
  </div>
  <div class="region region-footer-thirdcolumn">
    <div id="block-block-30" class="block block-block">

    
  <div class="content">
    <div><a href="https://рисуйснами.рф/journal" style="text-decoration:none;">Педагогический журнал<br />
<strong>ТВОРЧЕСТВО БЕЗ ГРАНИЦ</strong> </a>
<div style="text-align:center;">
<a href="https://рисуйснами.рф/journal" style="text-decoration:none;" title="читать журнал"><img  width="125" height="166" alt="Творчество без границ - конкурсы рисунков" class="img-hidden-load" data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/journal/title/title_current.png" style="width:125px" title="читать журнал"> </a>
<a href="https://рисуйснами.рф/journal" style="text-decoration:none;" title="читать журнал"><button class="button_3" style="margin-top: 8px;">Читать</button> </a>
<p>&nbsp;</p>
</div>
</div>
  </div>
</div>
  </div>
  <div class="region region-footer-fourthcolumn">
    <div id="block-block-31" class="block block-block">

    
  <div class="content">
    <div style="color:#00ade6;"><strong><span style="color:#00ade6;font-size:1em;">ДЕЛАЕМ ТВОРЧЕСТВО ДОСТУПНЕЕ<br />
ДЛЯ КАЖДОГО!</span></strong></div>

<div style="float:left;">
<span style="font-size:12px;"><br />
Руководитель<br />
и учредитель<br />
творческой<br />
мастерской<br />
<br />
</span>
<strong ><span style="color:#00ade6;font-size:1em;">ПЁТР<br />
ИСУПОВ </span></strong></div>

<div style="margin-top: -10px;">
<p><img  width="135" height="135" class="img-hidden-load" alt="всероссийские творческие конкурсы рисунка" data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/podval/ipv.jpg" style="width:130px;padding-top: 5px;padding-left: 2px;" title="творческая мастерская РИСУЙ С НАМИ" /></p>
</div>
<div style="height:30px;"></div >
<div >

<a href="https://vk.com/market-217779020" title="товары для творчества" rel="nofollow" target="_blank"><img  width="130" height="44" class="" alt="детский летний творческий онлайн лагерь" data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/VK/all_goods_nadpis.jpg" style="width:100% !important;min-width:100%;padding-top: 5px;padding-left: 2px;" title="товары для творчества" /></a>
<!--
<a href="https://рисуйснами.рф/detskiy-online-lager" title="детский творческий онлайн лагерь"><img  width="230" height="144" class="" alt="детский летний творческий онлайн лагерь" data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/lager/online_lager_600.jpg" style="width:100% !important;min-width:100%;padding-top: 5px;padding-left: 2px;border-radius:unset;" title="детский летний творческий онлайн лагерь" /></a>
-->
</div>
  </div>
</div>
<div id="block-block-35" class="block block-block">

    
  <div class="content">
    <div id="menu-block-left" class="menu-block-left" >
    <div id="arrow-show-menu" class="menu1" onclick="if (document.getElementById('menu-block-left-li').style.display==='none') {document.getElementById('menu-block-left-li').style.display='block';document.getElementById('prev-arrow-left-menu').style.display='block'; document.getElementById('next-arrow-left-menu').style.display='none';document.getElementById('arrow-show-menu').style.padding='5px 11px';sessionStorage.clickcount=0;}else{document.getElementById('menu-block-left-li').style.display='none';document.getElementById('prev-arrow-left-menu').style.display='none'; document.getElementById('next-arrow-left-menu').style.display='block';document.getElementById('arrow-show-menu').style.padding='5px 4px';sessionStorage.clickcount=1;}"  title="Показать/скрыть меню">
      <img id="prev-arrow-left-menu" width="26" height="12" data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/konkurs/button/left.svg" style="" alt="l" />
      <img id="next-arrow-left-menu" width="26" height="12" data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/konkurs/button/right.svg" style="" alt="r" />
   </div>
   <div id="menu-block-left-li">
	<div class="menu-line" style="padding-top:5px;" >
		<a href="https://рисуйснами.рф/my-diplom-sertificat" class="menu-line"><div  title="Здесь можно оплатить и скачать дипломы и сертификаты" class="menu1 icon-trophy">
			<span class="name-menu-left">ДИПЛОМЫ И СЕРТИФИКАТЫ</span></div></a>
	</div>

	<div class="menu-line" >
		<a  href="https://рисуйснами.рф/blagodarstvennoe-pismo" class="menu-line" title="Заказ Благодарственных писем">
                <div class="menu1 icon-files-empty">
			<span class="name-menu-left">БЛАГОДАРСТВЕННЫЕ ПИСЬМА</span></div></a>
	</div>
       <div class="separator"></div>
      <div class="menu-line" >
		<a  href="https://рисуйснами.рф/main" class="menu-line" title="Перейти к Главной странице"><div class="menu1 icon-home">
			<span class="name-menu-left">ГЛАВНАЯ</span></div></a>
	</div>

       <div class="menu-line">
		<a href="/" class="menu-line" title="Перейти к списку бесплатных всероссийских творческих конкурсов"><div class="menu1 icon-images">
			<span class="name-menu-left">КОНКУРСЫ</span></div></a>
	</div>

	<div class="menu-line">
		<a href="https://рисуйснами.рф/content/oformlenie-zayavki" class="menu-line" title="Перейти к оформлению заявки"><div class="menu1 icon-profile">
			<span class="name-menu-left">ЗАЯВКА НА КОНКУРС</span></div></a>
	</div>
       
       <div class="menu-line">
		<a href="https://рисуйснами.рф/journal" class="menu-line" title="Читать педагогический журнал"><div class="menu1 icon-books">
			<span class="name-menu-left">ПЕД. ЖУРНАЛ "ТВОРЧЕСТВО БЕЗ ГРАНИЦ"</span></div></a>
	</div>
         <div class="menu-line">
		<a href="https://рисуйснами.рф/descriptionkonkurs" class="menu-line" title="Посмотреть положения о конкурсах"><div class="menu1 icon-stack">
			<span class="name-menu-left">ПОЛОЖЕНИЯ О КОНКУРСАХ</span></div></a>
	</div>

	<div class="separator"></div>

        <div class="menu-line">
		<a href="https://рисуйснами.рф/homework/send" rel="nofollow" class="menu-line" title="Перейти к сервису Домашних заданий"><div class="menu1 icon-book">
			<span class="name-menu-left">ДОМАШКА</span></div></a>
	</div>
	<div class="menu-line">
		<a href="https://рисуйснами.рф/vneurochka" class="menu-line" title="Перейти к материалам внеурочной работы"><div style="display:inline-block;" class="menu1 icon-library">
			<span class="name-menu-left">ВНЕУРОЧКА</span></div></a>
	</div>
	<div class="menu-line">
		<a href="https://рисуйснами.рф/master-class-all" class="menu-line" title="Перейти к видеоурокам по рисованию"><div style="display:inline-block;" class="menu1 icon-video-camera">
			<span class="name-menu-left">ВИДЕОУРОКИ</span></div></a>
	</div>
<div style="height:10px;"></div >
<div >
<a href="https://рисуйснами.рф/prikaz-minobr" title="приказ министерства просвещения о конкурсах"><img  width="230" height="116" class="" alt="приказ минпросвещения о конкурсах" 
data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/minobr/logo_minobr_600_b_23_24.jpg" style="width:234 !important;padding-top: 5px;padding-left: 2px;border-radius:10px;" title="приказ министерства просвещения о конкурсах" /></a>
<!--<a href="https://рисуйснами.рф/detskiy-online-lager" title="детский творческий онлайн лагерь"><img  width="230" height="144" class="" alt="детский творческий онлайн лагерь" data-src="https://xn--80apbcqesjbs.xn--p1ai/sites/default/files/pictures/lager/online_lager_600.jpg" style="width:230px !important;padding-top: 5px;padding-left: 2px;border-radius:12px;" title="детский творческий онлайн лагерь" /></a>-->
</div>
  </div>
</div>
  </div>
</div>
  </div>
</div>
Для улучшения работы сайта и его взаимодействия с пользователями мы используем файлы cookie. Продолжая работу с сайтом, Вы разрешаете использование cookie-файлов. Вы всегда можете отключить файлы cookie в настройках Вашего браузера.
Ok