<|UlJfU1RSSU5HX1BST1RFQ1RJT05fU1RBUlQ=<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="nl-nl" lang="nl-nl">
<head>
  <base href="http://www.druturnia.nl/content/nieuws/laatste-nieuws" />
  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
  <meta name="robots" content="index, follow" />
  <meta name="keywords" content="Druturnia, Druten, turnen, jazzdance, streetdance, aerobics, jazz, sport, gymnastiek vereniging, dans, jeugd, Gemeente Druten, Horssen, Afferden, Deest, Puiflijk, Appeltern, Altforst, Boven-Leeuwen, Wamel, Winssen, Ewijk" />
  <meta name="description" content="Druturnia Druten is een actieve en groeiende vereniging voor turnen, jazz en streetdance. Kijk eens rond op onze website, je komt alles over ons te weten..." />
  <meta name="generator" content="Druturnia CMS" />
  <title>Druturnia - Laatste nieuws</title>
  <link href="/content/nieuws/laatste-nieuws?format=feed&amp;type=rss" rel="alternate" type="application/rss+xml" title="RSS 2.0" />
  <link href="/content/nieuws/laatste-nieuws?format=feed&amp;type=atom" rel="alternate" type="application/atom+xml" title="Atom 1.0" />
  <link href="/content/templates/ja_purity/favicon.ico" rel="shortcut icon" type="image/x-icon" />
  <link rel="stylesheet" href="http://www.druturnia.nl/content/plugins/system/yvsmiley/default.css" type="text/css" />
  <link rel="stylesheet" href="http://www.druturnia.nl/content/components/com_jtags/style.css" type="text/css" />
  <link rel="stylesheet" href="http://www.druturnia.nl/content/plugins/content/mavikthumbnails/slimbox/css/slimbox.css" type="text/css" />
  <script type="text/javascript" src="http://www.druturnia.nl/content/plugins/system/yvsmiley/default.js"></script>
  <script type="text/javascript" src="/content/media/system/js/mootools.js"></script>
  <script type="text/javascript" src="/content/media/system/js/caption.js"></script>
  <script type="text/javascript" src="http://www.druturnia.nl/content/plugins/content/mavikthumbnails/slimbox/js/slimbox.js"></script>
  <script type="text/javascript" src="/content/plugins/content/avreloaded/silverlight.js"></script>
  <script type="text/javascript" src="/content/plugins/content/avreloaded/wmvplayer.js"></script>
  <script type="text/javascript" src="/content/plugins/content/avreloaded/swfobject.js"></script>
  <script type="text/javascript" src="/content/plugins/content/avreloaded/avreloaded.js"></script>

<link rel="stylesheet" href="http://www.druturnia.nl/content/templates/system/css/combinedcss.css" type="text/css" />
<script language="javascript" type="text/javascript" src="http://www.druturnia.nl/content/templates/ja_purity/js/ja.script.js"></script>
<script language="javascript" type="text/javascript">

var rightCollapseDefault='hide';

var excludeModules='49,95,88,89,16,96,107';

</script>
<script language="javascript" type="text/javascript" src="http://www.druturnia.nl/content/templates/ja_purity/js/ja.rightcol.js"></script>
<script language="javascript" type="text/javascript" src="http://www.druturnia.nl/content/templates/ja_purity/js/ja.cssmenu.js"></script>
<!--[if IE 7.0]>

<style type="text/css">

.clearfix {display: inline-block;}

</style>

<![endif]-->
<style type="text/css">
#ja-header, #ja-mainnav, #ja-container, #ja-botsl, #ja-footer {
width: 97%;
	margin: 0 auto;
}
#ja-wrapper {
min-width: 100%;
}
</style>
</head>
<body id="bd" class="fs3 Others" >
<a name="Top" id="Top"></a>
<ul class="accessibility">
  <li><a href="#ja-content" title="Overslaan naar artikel">Overslaan naar artikel</a></li>
  <li><a href="#ja-mainnav" title="Overslaan naar hoofdnavigatie">Overslaan naar hoofdnavigatie</a></li>
</ul>
<div id="ja-wrapper">
  <!-- BEGIN: HEADER -->
  <div id="ja-headerwrap">
    <div id="ja-header" class="clearfix" style="background: url(http://www.druturnia.nl/content/templates/ja_purity/images/header/header2.jpg) no-repeat top right;">
      <div class="ja-headermask">&nbsp;</div>
            <h1 class="logo"> <a href="/content/index.php" title="Druturnia"></a> </h1>
            <h1 class="logo-text"> <a href="/content/index.php" title="Druturnia"><span>Druturnia</span></a> </h1>
      <p class="site-slogan">Vereniging voor Turnen en Dans</p>
      		<ul class="ja-usertools-font">
	      <li><img style="cursor: pointer;" title="Vergroot lettergrootte" src="http://www.druturnia.nl/content/templates/ja_purity/images/user-increase.png" alt="Vergroot lettergrootte" id="ja-tool-increase" onclick="switchFontSize('ja_purity_ja_font','inc'); return false;" /></li>
		  <li><img style="cursor: pointer;" title="Standaard lettergrootte" src="http://www.druturnia.nl/content/templates/ja_purity/images/user-reset.png" alt="Standaard lettergrootte" id="ja-tool-reset" onclick="switchFontSize('ja_purity_ja_font',3); return false;" /></li>
		  <li><img style="cursor: pointer;" title="Verklein lettergrootte" src="http://www.druturnia.nl/content/templates/ja_purity/images/user-decrease.png" alt="Verklein lettergrootte" id="ja-tool-decrease" onclick="switchFontSize('ja_purity_ja_font','dec'); return false;" /></li>
		</ul>
		<script type="text/javascript">var CurrentFontSize=parseInt('3');</script>
		            <div id="ja-search">
        <form action="index.php" method="post">
	<div class="search">
		<input name="searchword" id="mod_search_searchword" maxlength="20" alt="Zoeken" class="inputbox" type="text" size="20" value="Zoeken"  onblur="if(this.value=='') this.value='Zoeken';" onfocus="if(this.value=='Zoeken') this.value='';" />	</div>
	<input type="hidden" name="task"   value="search" />
	<input type="hidden" name="option" value="com_search" />
</form>
      </div>
          </div>
  </div>
  <!-- END: HEADER -->
  <!-- BEGIN: MAIN NAVIGATION -->
    <div id="ja-mainnavwrap">
    <div id="ja-mainnav" class="clearfix">
      
<ul class="menu">
	<li class="parent active item1">
		<a href="http://www.druturnia.nl/content/">
			<span>Nieuws</span>
		</a>
		<ul>
			<li id="current" class="active item9">
				<a href="/content/nieuws/laatste-nieuws">
					<span>Laatste nieuws</span>
				</a>
			</li>
			<li class="item15">
				<a href="/content/nieuws/nieuwsarchief-categorie">
					<span>Nieuws per categorie</span>
				</a>
			</li>
			<li class="item49">
				<a href="/content/nieuws/nieuws-per-onderwerp">
					<span>Nieuws per onderwerp</span>
				</a>
			</li>
			<li class="item31">
				<a href="/content/nieuws/nieuwslijst">
					<span>Nieuwslijst</span>
				</a>
			</li>
		</ul>
	</li>
	<li class="parent item54">
		<a href="#">
			<span>Turnen</span>
		</a>
		<ul>
			<li class="item55">
				<a href="/content/turnen/introductie">
					<span>Introductie</span>
				</a>
			</li>
			<li class="item60">
				<a href="/content/turnen/lesrooster">
					<span>Lesrooster</span>
				</a>
			</li>
			<li class="item57">
				<a href="/content/turnen/nieuws">
					<span>Nieuws</span>
				</a>
			</li>
			<li class="item58">
				<a href="/content/turnen/uitslagen">
					<span>Uitslagen</span>
				</a>
			</li>
			<li class="item59">
				<a href="/content/turnen/videos">
					<span>Video's</span>
				</a>
			</li>
		</ul>
	</li>
	<li class="parent item61">
		<a href="#">
			<span>Dans</span>
		</a>
		<ul>
			<li class="item62">
				<a href="/content/dans/introductie">
					<span>Introductie</span>
				</a>
			</li>
			<li class="item65">
				<a href="/content/dans/lesrooster">
					<span>Lesrooster</span>
				</a>
			</li>
			<li class="item66">
				<a href="/content/dans/nieuws">
					<span>Nieuws</span>
				</a>
			</li>
			<li class="item80">
				<a href="/content/dans/playlist">
					<span>Playlist</span>
				</a>
			</li>
			<li class="item67">
				<a href="/content/dans/videos">
					<span>Video's</span>
				</a>
			</li>
		</ul>
	</li>
	<li class="parent item23">
		<a href="#">
			<span>Word lid</span>
		</a>
		<ul>
			<li class="item22">
				<a href="/content/word-lid/aanmelden">
					<span>Aanmelden</span>
				</a>
			</li>
			<li class="item24">
				<a href="/content/word-lid/contributie">
					<span>Contributie</span>
				</a>
			</li>
		</ul>
	</li>
	<li class="parent item25">
		<a href="#">
			<span>Algemeen</span>
		</a>
		<ul>
			<li class="item26">
				<a href="/content/algemeen/beleidsplan">
					<span>Beleidsplan</span>
				</a>
			</li>
			<li class="parent item28">
				<a href="http://www.druturnia.nl/content/algemeen/bestuursinformatie">
					<span>Bestuursinformatie</span>
				</a>
			</li>
			<li class="item27">
				<a href="/content/algemeen/kledingvoorschriften">
					<span>Kledingvoorschriften</span>
				</a>
			</li>
			<li class="item33">
				<a href="/content/algemeen/lesroosters">
					<span>Lesroosters</span>
				</a>
			</li>
			<li class="item8">
				<a href="/content/algemeen/sportruimten">
					<span>Sportruimten</span>
				</a>
			</li>
		</ul>
	</li>
	<li class="item44">
		<a href="/content/agenda">
			<span>Agenda</span>
		</a>
	</li>
	<li class="item79">
		<a href="/content/fotos">
			<span>Foto's</span>
		</a>
	</li>
	<li class="parent item18">
		<a href="#">
			<span>Reageer</span>
		</a>
		<ul>
			<li class="item17">
				<a href="/content/reageer/contact">
					<span>Bestuur</span>
				</a>
			</li>
			<li class="item30">
				<a href="/content/reageer/leiding">
					<span>Leiding</span>
				</a>
			</li>
			<li class="item29">
				<a href="/content/reageer/redactie-en-webbeheer">
					<span>Redactie en webbeheer</span>
				</a>
			</li>
			<li class="item45">
				<a href="/content/reageer/gastenboek">
					<span>Gastenboek</span>
				</a>
			</li>
		</ul>
	</li>
</ul>
    </div>
  </div>
    <!-- END: MAIN NAVIGATION -->
  <div id="ja-containerwrap-fl">
    <div id="ja-containerwrap2">
      <div id="ja-container">
        <div id="ja-container2" class="clearfix">
          <div id="ja-mainbody-fl" class="clearfix">
<!-- BEGIN: CONTENT -->
<div id="ja-contentwrap"><div id="ja-content"><div class="componentheading">
	Laatste nieuws</div>
<table class="blog" cellpadding="0" cellspacing="0">
<tr>
	<td valign="top">
				<br />
		<br />
	</td>
</tr>
<tr>
	<td valign="top">
					<div>
		
<div class="contentpaneopen">

<h2 class="contentheading">
		<a href="/content/turnen/nieuws/226-leuke-wedstrijd-met-goed-resultaat" class="contentpagetitle">
		Leuke wedstrijd, met goed resultaat!	</a>
	</h2>


<div class="article-tools">
<div class="article-meta">

	<span class="createdate">
		dinsdag, 09 februari 2010 22:23	</span>

	<span class="createby">
		Marloes van Dilgt	</span>

</div>

<div class="buttonheading">
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/226-leuke-wedstrijd-met-goed-resultaat?tmpl=component&amp;print=1&amp;layout=default&amp;page=" title="Afdrukken" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/printButton.png" alt="Afdrukken"  /></a>	</span>
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/226-leuke-wedstrijd-met-goed-resultaat?format=pdf" title="PDF" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/pdf_button.png" alt="PDF"  /></a>	</span>
	</div>

</div>


<div class="article-content">
Zaterdag 30 januari was de eerste wedstrijd van het seizoen van de 6e divisie. Ik zat met 5 meisjes van leeftijd instap, en 4 andere junioren/senioren van Druturnia in de eerste wedstrijd. Voor mij was het de eerste wedstrijd sinds de afgelopen clubkampioenschappen, en zowel voor mij als voor Annefleur en Liza was het ook de eerste keer wedstrijd in de 6e divisie.  Susan en Lotte van Druturnia zaten te jureren, Manon liep met de instappers mee en Roos met onze groep.<br/>
<br/>
We begonnen op brug. Dit toestel ging bij iedereen van Druturnia heel erg goed, vooral de salto’s af. Vervolgens balk. Dat ging niet zo heel erg goed bij mij, aangezien ik er drie keer vanaf viel. Dat was natuurlijk wel even balen, maarja, kan gebeuren. Vloer ging goed. Intussen hadden we al wel door dat we een paar hele goede tegenstanders hadden: er sprongen er best veel arabier-flikflak op vloer!<br/>
<br/>
Ons laatste toestel was sprong. Sharon en Rachel sprongen met plank, Liza, Annefleur en ik nog met trampoline. Sprong is Liza’s best toestel, en zij sprong dus ook heel mooi, maar Annefleur en ik vinden die pegasus op 1.30m soms best hoog. Maar met de wedstrijd sprongen we er allebei zonder hulp overheen. We waren dus heel erg tevreden. 
Toen iedereen klaar was, moesten we vervolgens ontzettend lang wachten op de prijsuitreiking. Maar in de kleedkamers was het heel erg gezellig met iedereen van Druturnia uit de eerste en de tweede wedstrijd. Toen mochten we eindelijk opmarcheren en begon de prijsuitreiking. Rachel werd eerste en daar was iedereen natuurlijk hartstikke trots op! Ik werd 10e, en daar was ik best tevreden mee. Behalve balk was immers alles best goed gegaan, helemaal voor de eerste wedstrijd. Ook de rest van Druturnia had vrij goed gescoord. Op 10 april is de volgende wedstrijd, en dan zijn wij er zeker weer bij!<br/>
<br/>
Groetjes Marloes van Dilgt<div class='yvComment'
   id='yvComment'>
	<div class='NumCommentsAlone'>
  <a href='/content/turnen/nieuws/226-leuke-wedstrijd-met-goed-resultaat#yvComment'>Voeg jouw reactie toe</a>	</div>
	
	
	
	
		  </div>
</div>



</div>

<span class="article_separator">&nbsp;</span>
		</div>
					<div>
		
<div class="contentpaneopen">

<h2 class="contentheading">
		<a href="/content/turnen/nieuws/225-druturnia-turnsters-3e-divisie-allemaal-door-naar-regio-finale" class="contentpagetitle">
		Druturnia turnsters 3e divisie allemaal door naar regio finale!!	</a>
	</h2>


<div class="article-tools">
<div class="article-meta">

	<span class="createdate">
		dinsdag, 09 februari 2010 22:18	</span>

	<span class="createby">
		Susan Hopmans	</span>

</div>

<div class="buttonheading">
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/225-druturnia-turnsters-3e-divisie-allemaal-door-naar-regio-finale?tmpl=component&amp;print=1&amp;layout=default&amp;page=" title="Afdrukken" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/printButton.png" alt="Afdrukken"  /></a>	</span>
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/225-druturnia-turnsters-3e-divisie-allemaal-door-naar-regio-finale?format=pdf" title="PDF" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/pdf_button.png" alt="PDF"  /></a>	</span>
	</div>

</div>


<div class="article-content">
<a class="thumbnail" href="/content/images/stories/newsphoto/2010/20100209turnen3edivisie.jpg" rel="lightbox[225]" title="Druturnia turnsters 3e divisie allemaal door naar regio finale" target="_blank"><img style="float: left;" alt="Druturnia turnsters 3e divisie allemaal door naar regio finale" height="157" width="200" src="/content/images/stories/newsphoto/thumbnails/200x157-images-stories-newsphoto-2010-20100209turnen3edivisie.jpg" /></a>Na 3 plaatsingswedstrijden in de regio Gelderse vallei en Gelderland Oost hebben alle turnsters 3e divisie van Druturnia zich weten te plaatsen voor de regiofinale op 6 maart in Doetinchem. Dit is echt een enorme prestatie en ook voor het eerst in de geschiedenis van Druturnia dat 100% zich geplaatst heeft voor deze finale. Op de regiofinale kunnen onze turnsters zich plaatsen voor de districtsfinale en op de districtsfinale kunnen ze zich zelfs plaatsen voor de landelijke finale oftewel Nederlands Kampioenschap 3e divisie.<br /> <br /> In de eerste wedstrijd was het heel erg spannend, onze instappers niveau 9 Pleun Hoes en Evi Derks moesten een goede wedstrijd turnen om door te mogen naar de finale. Er gaan 21 turnsters door naar de regiofinale. We hadden het allemaal niet verwacht maar beide zijn net door naar de finale Pleun als 21e en Evi als 20e. Ook onze jeugd niveau 6 turnster Didi Peters moest een goede wedstrijd turnen, dit omdat ze 1 wedstrijd gemist had en dus maar 2 kansen heeft gehad. Didi turnde een hele sterke wedstrijd en eindigde zelfs als 5e en greep op 0.350 punt net naast de bronzen medaille. Er gingen 18 turnsters door en Didi is als 14e geplaatst.<br /> <br /> In de 2e wedstrijd mochten onze senioren niveau 4 Evelyn v/d Werff en Sanne steffek aan de bak, ook onze pupillen 1 niveau 8 Marthe van Herpen en Fleur v/d Sluijs mochten hun wedstrijd turnen. Sanne steffek had een dag voor de wedstrijd te kennen gegeven dat dit haar laatste wedstrijd zou worden, Sanne is net 21 geworden en heeft besloten om te gaan stoppen met turnen om haar visie op haar toekomst te kunnen richten. Ze heeft op de dag van de finale een open dag van haar toekomstige nieuwe opleiding. De laatste wedstrijd heeft Sanne keurig afgesloten met een 11e plek. Bij de senioren gingen er 26 turnsters door naar de finale. Sanne was als 16e geplaatst maar gaat helaas niet deelnemen aan deze wedstrijd, Evelyn plaatste zich als 25e en mag dus ook in de regiofinale uitkomen.<br /> <br /> Bij de pupillen 1 gaan er 25 turnsters door naar de regiofinale. Fleur draaide deze wedstrijd op alle toestellen de moeilijkste oefeningen van haar niveau en wist ondanks dat de zolendraai niet lukte een hele mooie Zilveren medaille te veroveren. Ze is zelfs als 1e geplaatst voor de regiofinale, wat natuurlijk een geweldige prestatie is. Marthe en ook Zoe zijn beide door naar de regiofinale, Marthe wist zich als 19e te plaatsen en Zoe is als 23e door naar de finale.<br /> <br /> In de 3e en laatste wedstrijd van deze dag was onze Debby Pouwels junior niveau 5 aan de beurt en ook de pupillen 2 niveau 7 Caya Verbruggen, Didi van Beuningen en Florens van Kesteren mochten hun turn kunsten vertonen. Debby zat lekker in haar vel en turnde dan ook de sterren van de hemel wat haar een hele mooie 4e plek opleverde. Op 0.10 punt na miste ze net de Bronzen medaille. Bij de junioren gingen er 19 turnsters door naar de finale. Debby is als 11e geplaatst. Bij de pupillen 2 mogen er 18 turnsters door naar de finale. Britt heeft zich als 11e geplaatst, Florens als 12e, Caya als 13e en Didi als 17e.<br /> <br /> Ik als trainster ben dan ook hartstikke trots op mijn meiden, en hoop dat er op 6 maart ook een aantal turnsters zich plaatsen voor de districtsfinale. We gaan er in elk geval kei hard voor trainen. Iedereen is super gemotiveerd en dat werkt aanstekelijk in de trainingen. Door deze goede motivatie is het ook super gezellig in de trainingen. Meiden jullie zijn TOP!!!<br /> <br /> Veel Turngroetjes, <br /><br /><em>Susan Hopmans <br />Trainster A selectie</em><div class='yvComment'
  >
	<div class='NumCommentsAlone'>
  <a href='/content/turnen/nieuws/225-druturnia-turnsters-3e-divisie-allemaal-door-naar-regio-finale#yvComment'>Reacties (1)</a>	</div>
	
	
	
	
		  </div>
</div>



</div>

<span class="article_separator">&nbsp;</span>
		</div>
					<div>
		
<div class="contentpaneopen">

<h2 class="contentheading">
		<a href="/content/nieuws/laatste-nieuws/6-overig/224-steun" class="contentpagetitle">
		(S)teun	</a>
	</h2>


<div class="article-tools">
<div class="article-meta">

	<span class="createdate">
		dinsdag, 09 februari 2010 22:07	</span>

	<span class="createby">
		Marloes van Dilgt	</span>

</div>

<div class="buttonheading">
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/6-overig/224-steun?tmpl=component&amp;print=1&amp;layout=default&amp;page=" title="Afdrukken" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/printButton.png" alt="Afdrukken"  /></a>	</span>
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/6-overig/224-steun?format=pdf" title="PDF" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/pdf_button.png" alt="PDF"  /></a>	</span>
	</div>

</div>


<div class="article-content">
<img style="float: left;" alt="Sponsoractie" height="240" width="200" src="/content/images/stories/newsphoto/2010/20100209steunvarkentje.jpg" />Ben jij lid van Druturnia? En wil jij graag nieuwe toestellen om op te turnen? Of wil jij ook een super leuke dansvoorstelling aan het einde van dit schooljaar? Doe dan in maart mee met de sponsoractie van Druturnia! <br /><br />Druturnia gaat met alle leden namelijk varkentjes wassen om geld op te halen! Natuurlijk ga je geen echte varkentjes wassen: de actie gaat als volgt: <br /> <br />De actie vind in maart plaats. De eerste twee weken van maart krijgt de ene helft van de vereniging  een boekje van (s)teun, en in de tweede twee weken van maart krijgt de andere helft van de vereniging een boekje. <br /><br />Bij een actie van (s)teun krijg je een groen boekje. Daarin staan 25 afbeeldingen van het spaarvarkentje ‘Teun’. Op een varkentje zit een kraslaag, met daaronder een bedrag variërend van €0,50 tot €2,50. Het is de bedoeling dat je andere mensen (bijvoorbeeld je opa, oma, tante, oom of buren) een of meer varkentjes laat ‘wassen’ (lees: openkrassen). Het bedrag dat onder de kraslaag staat is de bijdrage van de donateur. Als dank hiervoor krijgt de donateur per open gekrast varkentje één waardecouponvel, waarmee je korting krijgt op bijvoorbeeld winkels of pretparken. <br /> <br />Als je als Druturnia-lid een heel boekje vol hebt (dus 25 varkentjes hebt gewassen) krijg je een leuke prijs. Het bedrag dat je hebt opgehaald moet in een gesloten envelop samen met het boekje worden ingeleverd bij je leiding, een week nadat je het boekje hebt gekregen.  <br /><br /><span style="text-decoration: underline;">Let op</span>: Raak het boekje niet kwijt, want dat kost Druturnia heel veel geld en het levert natuurlijk niets op. <br /><br />Dus ga in maart met je (s)teun-boekje langs je vrienden en familie, en help zo Druturnia met de aanschaf voor nieuwe toestellen en de financiering voor de dansvoorstelling. <br /><br />Turn- en dansgroeten, <br /><br /><em>De jeugdcommisie van Druturnia: <br /> Farah, Lieke, Tanja, Ilse, Roos en Marloes.</em><div class='yvComment'
  >
	<div class='NumCommentsAlone'>
  <a href='/content/nieuws/laatste-nieuws/6-overig/224-steun#yvComment'>Reacties (2)</a>	</div>
	
	
	
	
		  </div>
</div>



</div>

<span class="article_separator">&nbsp;</span>
		</div>
					<div>
		
<div class="contentpaneopen">

<h2 class="contentheading">
		<a href="/content/turnen/nieuws/222-verslag-2e-plaatsingswedstrijd-4e-divisie-nijmegen" class="contentpagetitle">
		Verslag 2e plaatsingswedstrijd 4e divisie Nijmegen	</a>
	</h2>


<div class="article-tools">
<div class="article-meta">

	<span class="createdate">
		dinsdag, 26 januari 2010 15:31	</span>

	<span class="createby">
		Susan Hopmans	</span>

</div>

<div class="buttonheading">
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/222-verslag-2e-plaatsingswedstrijd-4e-divisie-nijmegen?tmpl=component&amp;print=1&amp;layout=default&amp;page=" title="Afdrukken" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/printButton.png" alt="Afdrukken"  /></a>	</span>
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/222-verslag-2e-plaatsingswedstrijd-4e-divisie-nijmegen?format=pdf" title="PDF" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/pdf_button.png" alt="PDF"  /></a>	</span>
	</div>

</div>


<div class="article-content">
<div style="margin: 1ex;">
<div>
<p><span style="font-family: Arial; font-size: small;"><a class="thumbnail" href="/content/images/stories/newsphoto/2010/20100126Nijmegen.jpg" rel="lightbox[222]" title="20100126Nijmegen" target="_blank"><img height="150" width="200" src="/content/images/stories/newsphoto/thumbnails/200x150-images-stories-newsphoto-2010-20100126Nijmegen.jpg" alt="20100126Nijmegen" style="float: left;" /></a>Op 23 januari was de 2<sup>e</sup> plaatsingswedstrijd voor de 4<sup>e</sup> divisie. Deze keer had Druturnia samen met de hazenkamp de organisatie van deze wedstrijd onder hun hoede. Dat betekende dat er een heel aantal vrijwilligers opgetrommeld moesten worden om deze wedstrijd weer tot een succes te maken.</span></p>
<p><span style="font-family: Arial; font-size: small;">Op de vrijdag voor de wedstrijd moest de zaal wedstrijdklaar gemaakt worden. Onze voorzitter Jac en onze klusjesman Johan hebben in een record tijd laten zien wat werken is en geholpen met een aantal mensen van de hazenkamp om de zaal picobello te krijgen. </span></p>
<p><span style="font-family: Arial; font-size: small;">Margot onze secretaris kwam in de vrijdagtraining nog even wat druturnia t-shirts brengen, zodat alle vrijwilligers netjes en verzorgd voor de dag konden komen. De doos met deze shirts had al een hele tijd ergens op zolder gestaan en de muizen hadden er flinke gaten in geknabbeld en er een warm nest van gebouwd. Gelukkig waren er nog een aantal t shirts heel en hoefde alleen de moeder van Plom nog even snel een ander shirt op te halen bij Margot, zodat iedereen netjes in Druturnia stijl voor de dag kwam.</span></p>
<h1><span style="font-family: Arial; font-size: small;"><strong>Wedstrijd 1</strong></span></h1>
<p><span style="font-family: Arial; font-size: small;">Op zaterdag stonden Marion de moeder van Plom en de moeder van Inge al vroeg paraat om de paspoorten in te nemen en de wedstrijdnummers uit te delen. Marion mocht de 1<sup>e</sup> wedstrijd aan elkaar praten en dit deed ze vol overtuiging en enthousiasme. Ook Esse onze stagiaire van de Cios was al aanwezig om met alles te helpen en samen met de moeder van Plom de wedstrijd te begeleiden via de speaker.</span></p>
<p><span style="font-family: Arial; font-size: small;">Onze klok en jury meisjes Didi Peters en Caya Verbruggen waren er ook helemaal klaar voor, toen bleek dat er geen stopwatches waren om te klokken, hadden ze alle tijd om de wedstrijd te bekijken. Er moest natuurlijk ook gewerkt worden, en ze waren er dan ook als de kippen bij om alle jurybriefjes op te halen bij de juryleden. Margot en Caya hebben de medailles uitgereikt, en Caya vond dit helemaal geweldig om te doen. Ook Lotte ons jurylid was deze dag aan het jureren, vandaag mocht ze vloer doen waar ze wel streng maar zeer rechtvaardig was.</span></p>
<p><span style="font-family: Arial; font-size: small;">Inge en plom onze instappers niveau 10  mochten deze wedstrijd beginnen op het zenuwtoestel balk. Inge turnde heel erg netjes en strak, maar moest helaas 2 keer de balk verlaten wat haar gelijk 2 punten kostte, Plom turnde ook een super mooie oefening en helaas viel ze toch 1 keer van de balk. Toch hielden ze allebei nog een mooie score over. Daarna was vloer aan de beurt, hier zat de jury echt nog een beetje te slapen want bij Plom hadden ze de spreidsprong niet gezien terwijl ze hem zeker wel gedaan heeft, wat haar niet alleen 2 punten kostte maar uiteindelijk ook haar zilveren medaille, dit vonden we natuurlijk erg oneerlijk en Susan was een beetje boos op de jury en heeft verhaal gehaald, maar er was niets meer aan te doen. De jury had geoordeeld en daar bleef het bij. Op sprong vloog Plom over de kast met een hele mooie overslag. Inge sprong ook een overslag met plank voor het eerst op een wedstrijd, alleen was ze ietsiepietsie de leeuw vergeten mee te nemen om haar harder te laten rennen. Volgende keer neemt ze hem zeker mee zodat ze nog harder gaat rennen en een nog veel mooiere overslag kan maken. Na sprong was brug aan de beurt waar beide meiden een super oefening lieten zien. Plom werd na 4 toestellen heel mooi 7<sup>e</sup> en Inge werd 21<sup>e</sup>.</span></p>
<p><span style="font-family: Arial; font-size: small;"><strong>Wedstrijd 2</strong> </span></p>
<p><span style="font-family: Arial; font-size: small;">In de 2<sup>e</sup> wedstrijd nam Esse plaats achter de speaker en mocht zij de wedstrijd in goede banen leiden wat ze wel erg spannend vond maar het ging hartstikke goed. Margot onze secretaris en moeder van Melle ging deze keer de paspoorten en nummers in orde maken en Caya, Debby en Didi haalde weer de jurybriefjes op, wat ze heel keurig deden, vaak stonden ze al paraat voordat de jury het goed en wel ingevuld hadden en konden de scores ook snel verwerkt worden. Margot en Caya hebben de medailles uitgereikt, helaas niet aan onze eigen turnsters.</span></p>
<p><span style="font-family: Arial; font-size: small;">Hilde, Nathalie, Melle en Marieke onze junioren niveau 6 begonnen vandaag op vloer. Melle verraste ons allemaal met de hoogste score niet alleen van Druturnia maar van alle junioren, Marieke had de op 1 na beste score ondanks dat haar streksalto met ½ schroef niet helemaal lukte zoals ze wilde. Nathalie en Hilde turnde allebei een stabiele mooie vloer oefening, alleen Nathalie vond de vloer wat te klein en kwam met 1 voet buiten de lijnen. Nu was sprong aan de beurt, de meiden sprongen allemaal 2 verschillende sprongen, ook hier scoorden de dames erg goed. Hilde had alleen overslag ingeturnd, en Susan had bedacht dat ze wel overslag met ½ draai kon springen en dit deed Hilde dan ook keurig. Na 2 toestellen stonden de meiden allemaal in de top 10. Brug is altijd erg zwaar en moeilijk ook hier wisten Hilde en melle een heel behoorlijke oefening neer te zetten. Marieke turnde heel erg strak en deze keer lukte de salto wel alleen met zolendraai ging ze net iets te hard waardoor ze de brug helaas moest verlaten wat haar een heel punt kost. Nathalie begon erg goed met haar brug oefening, alleen nu lukte de salto af bij haar niet. Marieke en Nathalie waren beide erg teleurgesteld. Als laatste mochten de meiden de balk op, helaas hadden vandaag alle meiden van Druturnia niet echt een geweldige balkdag en moesten alle 4 de meiden de balk minstens 1 keer verlaten. De meiden waren erg teleurgesteld, toch is Susan erg trots op ze want ze hebben alle 4 hun uiterste best gedaan. Zo’n wedstrijd is en blijft toch een moment opname en deze meiden hebben nu eenmaal de leeftijd dat het heel moeilijk is om over je teleurstelling heen te komen. Zelf waren ze dan ook niet geheel tevreden over hun prestaties. Behalve melle zij is echt een trainingsbeest en wedstrijden vindt ze eigenlijk maar niks. Hilde werd heel mooi 10e, Melle  12<sup>e</sup>,  Marieke 17<sup>e</sup> en Nathalie 24<sup>e</sup>.</span></p>
<h1><span style="font-family: Arial; font-size: small;"><strong>Wedstrijd 3</strong></span></h1>
<p><span style="font-family: Arial; font-size: small;">In de 3<sup>e</sup> en laatste wedstrijd nam Jan de vader van Lieke  en Marthe het stokje over en mocht hij de medailles uitreiken samen met Marthe en Jessica, ook verzorgde Jan de paspoorten en de nummers. Esse begeleidde deze wedstrijd weer met haar stem, wat ze inmiddels toch wel een beetje saai begon te vinden maar ze heeft het weer heel goed gedaan. Hilde en marieke bleven na hun wedstrijd om Lieke te supporten en te helpen met de jurybriefjes ook Debby, Jessica en Marthe kwamen helpen.</span></p>
<p><span style="font-family: Arial; font-size: small;">Zo was Lieke gelukkig niet helemaal in haar eentje op de wedstrijd en had ze een hele schare fans die Lieke goed aanmoedigde en haar over haar teleurstellingen heen hielpen. Gianna kwam nog even jureren de laatste wedstrijd, zodat een ander jurylid haar eigen dochter een keer kon zien turnen. Gianna had s’ochtends ook al i.p.v. lotte de lessen begeleid in druten, dus ook voor haar weer een druk turn dagje.</span></p>
<p><span style="font-family: Arial; font-size: small;">Lieke onze senior niveau 5 begon op sprong en daar kan ze wel 5 verschillende sprongen uitvoeren, je mag er alleen maar 2 doen. De eerste sprong was een half in half uit en die lukte prima. Lieke traint al een tijdje voor een overslag met hele draai en ze wilde hem dan ook graag doen op de wedstrijd de sprong zelf was bijna perfect alleen de landing was erg spectaculair ze tuimelde en viel, toch haalde ze met de sprong waarmee ze viel dezelfde score als met de eerste sprong. Daarna was brug aan de beurt en we hadden haar oefening iets makkelijker gemaakt waardoor ze zeker kon turnen en ook hier turnde ze een stabiele mooie oefening. Balk is niet favouriet bij Lieke en ze moest het toestel dan ook 3 keer verlaten wat gelijk 3 punten kost, dit was een enorme teleurstelling voor Lieke. Susan was echter heel erg trots, omdat Lieke de moeilijkste balkoefening heeft van alle meiden van druturnia zelfs nog moeilijker als de meiden in de 3<sup>e</sup> divisie. Op vrijdag in de training had ze voor het eerst arabier op de balk alleen gedaan en ook op de wedstrijd deed ze dit heel knap. Een balk is maar 10 centimeter breed en lieke mag ondanks haar vallen echt heel trots zijn op haar prestatie. Na de teleurstelling op balk moest ze de vloer nog op. Ze begon super goed, alleen met de laatste serie een arabier streksalto met ½ schroef had ze net te weinig vaart waardoor ze op haar zitvlak landde, wederom was de teleurstelling erg groot. Uiteindelijk werd Lieke toch nog 22<sup>e</sup> en ook al ging niet alles vlekkeloos Lieke mag trots op haar zelf zijn, ze is de enige die bijna alle eisen die Susan gesteld heeft, heeft gehaald en dat is heel veel waard!</span></p>
<p><span style="font-family: Arial; font-size: small;">De uitslagen zijn te vinden op deze site klik op turnen en dan klik op uitslagen.</span></p>
<p><span style="font-family: Arial; font-size: small;">Tot slot wil ik alle vrijwilligers enorm bedanken voor hun inzet tijdens deze wedstrijd, zonder deze mensen hadden we de wedstrijd niet tot zo’n groot succes kunnen maken. Super geweldig dat we dit met zijn allen hebben weten te bereiken. Ik hoop ook dat alle vrijwilligers het leuk vonden en dat ze wellicht meer te weten zijn gekomen over het reilen en zeilen van de turnsport en dan niet alleen het technische gedeelte maar ook alle perikelen die er komen kijken bij een turnwedstrijd en de organisatie daarvan.  Top dat jullie je zo belangeloos hebben ingezet en ik hoop dat ik een volgende keer weer een beroep op jullie kan doen!</span></p>
<p><span style="font-family: Arial; font-size: small;">Met turngroeten,</span></p>
<p><span style="font-family: Arial; font-size: small;">Susan Hopmans</span></p>
</div>
</div><div class='yvComment'
  >
	<div class='NumCommentsAlone'>
  <a href='/content/turnen/nieuws/222-verslag-2e-plaatsingswedstrijd-4e-divisie-nijmegen#yvComment'>Voeg jouw reactie toe</a>	</div>
	
	
	
	
		  </div>
</div>



</div>

<span class="article_separator">&nbsp;</span>
		</div>
					<div>
		
<div class="contentpaneopen">

<h2 class="contentheading">
		<a href="/content/turnen/nieuws/221-een-zilveren-medaille-voor-fleur-sluijs" class="contentpagetitle">
		Een zilveren medaille voor Fleur Sluijs	</a>
	</h2>


<div class="article-tools">
<div class="article-meta">

	<span class="createdate">
		dinsdag, 26 januari 2010 14:41	</span>

	<span class="createby">
		Irma van Woezik	</span>

</div>

<div class="buttonheading">
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/221-een-zilveren-medaille-voor-fleur-sluijs?tmpl=component&amp;print=1&amp;layout=default&amp;page=" title="Afdrukken" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/printButton.png" alt="Afdrukken"  /></a>	</span>
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/221-een-zilveren-medaille-voor-fleur-sluijs?format=pdf" title="PDF" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/pdf_button.png" alt="PDF"  /></a>	</span>
	</div>

</div>


<div class="article-content">
<p><a class="thumbnail" href="/content/images/stories/newsphoto/2010/20100116fleursluijs.jpg" rel="lightbox[221]" title="20100116fleursluijs" target="_blank"><img height="150" width="200" src="/content/images/stories/newsphoto/thumbnails/200x150-images-stories-newsphoto-2010-20100116fleursluijs.jpg" alt="20100116fleursluijs" style="float: left;" /></a>Verschillende meiden van Druturnia mochten 16 januari meedoen aan de 2e plaatsingswedstrijd 3e divisie. Tijdens deze wedstrijd werden er prachtige oefeningen geturnd met als uitblinker onze Fleur Sluijs!! <br /><br />Fleur begon op vloer met een prachtige oefening. Ze vloog vervolgens super mooi over de Pegasus heen en wist een goede brugoefening neer te zetten. Ook op haar laatste toestel balk liet ze een bijna foutloze oefening zien. Al met al een topdag voor Fleur. Die met een mooie zilveren medaille beloond werd!!</p>
<p>Druturnia is hartstikke trots op Fleur. Maar natuurlijk ook op alle andere deelnemers.</p>
<p><a href="/content/turnen/uitslagen">De uitslagen vind je terug op deze site.</a> We hebben onze turnsters ook nog vragen gesteld, lees de antwoorden hieronder!</p>
:<br /><br />
<div class="bubble3">
<div>
<div>
<div>
<div>
<div><strong>In welk leeftijdscategorie en niveau turn je? <br /></strong><br />Didi Peters: Jeugd niveau 6 <br />Evi Derks: Instap niveau 9 <br />Zoë Teunissen: Pupil 1 niveau 8 <br />Fleur v/d Sluijs Pupil 1 niveau 8 <br />Caya Verbruggen Pupil 2 niveau 7 <br />Pleun Hoes Instap niveau 9 <br />Didi van Beuningen Pupil 2 niveau 7 <br />Debby Pouwels Junior niveau 5 <br /><br />
</div>
</div>
</div>
</div>
</div>
<span class="author"></span></div>
<br /><br />

<div class="bubble3">
<div>
<div>
<div>
<div>
<div>
<strong>Hoe ging je wedstrijd? </strong><br /><br />Didi Peters: De wedstrijd ging wel goed, vloer en sprong gingen super, brug ging goed en balk verschrikkelijk slecht!! <br />Evi Derks: Goed, want ik viel niet van de balk af. En vloer ging ook goed. Dus ik ben tevreden. <br />Zoë Teunissen: Vloer ging wel goed alleen bruggetje niet zo. Sprong ging ook goed. Brug ging niet zo goed omdat ik geen salto af deed. Balk ging heel erg goed want ik bleef erop staan met de radslag. <br />Fleur v/d Sluijs: heel goed. Ik vond dat de balk, vloer en sprong erg goed ging. De brug ging ook goed, maar dat kon wel wat beter . Met de borstzwaaiom had ik de knieën iets rechter moeten doen. Verder ging alles wel goed. <br />Caya Verbruggen: Deze wedstrijd ging weer wat beter als de vorige. <br />Pleun Hoes: Goed. Brug ging niet geweldig. <br />Didi van Beuningen: De wedstrijd ging voor mij doen goed, maar was niet zo goed . <br />Debby Pouwels: Ik ben er wel tevreden mee. Ik had veel pijn in mijn hak, dat was wel iets minder. <br /><br />
</div>
</div>
</div>
</div>
</div>
<span class="author"></span></div>
<br /><br />

<div class="bubble3">
<div>
<div>
<div>
<div>
<div>
<strong>Waar was je trots op? <br /><br /></strong>Didi Peters: Op vloer en sprong. <br />Evi Derks: Op de brug, met de salto van de brug stond ik heel netjes stil. <br />Zoë Teunissen: Radslag op de balk <br />Fleur v/d Sluijs: balk en vloer omdat bij balk de radslag lukte en bij vloer de arabier flikflak en de stutrol wel goed ging. Vooral was ik er trots op dat ik tweede ben geworden!!! Waar ik ook trots op ben is dat de kip ook wel goed ging. <br />Caya Verbruggen: Ik had een heel goed cijfer voor sprong. <br />Pleun Hoes: Op sprong.ik had een 13,10!! <br />Didi van Beuningen: Dat ik de zolendraai had gedaan . En dat ik op de balk ben blijven staan. <br />Debby Pouwels: Dat ik op vloer weer overslag Arabier SALTO heb gedaan ( ben namelijk een keer met salto op me nek gevallen) en dat ik op brug ook de salto af gedaan heb<br /><br />
</div>
</div>
</div>
</div>
</div>
<span class="author"></span></div>
<br /><br />

<div class="bubble3">
<div>
<div>
<div>
<div>
<div>
<strong>Wat ging minder goed? <br /><br /></strong>Didi Peters: Zoals ik al schreef de balk, ik ben er 3x afgevallen, erg hé. <br />Evi Derks: Sprong, maar ik had toch een hoog punt omdat Susan mij goed hielp. <br />Zoë Teunissen: Salto van de brug. <br />Fleur v/d Sluijs: eigenlijk ging alles wel goed alleen bij brug met de borstzaaiom moesten de knieën wat rechter vond ik. Ik kon niet lachen op het podium. Raar he?? Dat zal wel door de spanning komen, maar natuurlijk wilde ik daar heel graag staan! <br />Caya Verbruggen: Op de vloer had ik nog veel kromme tenen en benen en bij de balk ben ik na het woordje stop van de balk gesprongen. Was niet de bedoeling. <br />Pleun Hoes: Brug. Ophurken ging niet goed. <br />Didi van Beuningen: vloer: Ik kan stutrol halve draai niet en daar kreeg ik op het laatste nog aftrek voor. Balk: Ik was een pasje vergeten en halve pirouette ook bijna maar Susan riep mij dat ik die moest doen en daar kreeg ik ook aftrek voor . <br />Debby Pouwels: De balk. Want ik heb namelijk maar een hele lage uitgangswaarde, dus moet ik de balk even aan passen, zodat ik een hogere UW krijg. <br /><br />
</div>
</div>
</div>
</div>
</div>
<span class="author"></span></div>
<br /><br />

<div class="bubble3">
<div>
<div>
<div>
<div>
<div>
<strong>Vond je het leuk/ spannend? <br /></strong>
<br />Didi Peters: Al met al vond ik het toch een leuke wedstrijd. <br />Evi Derks: Ik vond het leuk, maar wel een beetje spannend. <br />Zoë Teunissen: Ik vond het wel spannend <br />Fleur v/d Sluijs: best spannend en ook wel leuk. Spannend omdat ik dacht dat ik met de radslag van de balk af zou vallen, maar gelukkig is dat niet gebeurd. <br />Caya Verbruggen: Ik vond sprong superleuk! <br />Pleun Hoes: Vorige wedstrijd was enger dan deze wedstrijd. <br />Didi van Beuningen: Ik vond het leuk want ik vond dat het goed ging . En ook spannend want ik was een heel klein beetje zenuwachtig Debby Pouwels: Ja, ik was wel zenuwachtig voor de balk.. En voor vloer voor die salto. Ik vond het ook heel gezellig want ik zit een groepje met HORUS meiden die ik heel goed ken. <br /><br />
</div>
</div>
</div>
</div>
</div>
<span class="author"></span></div>
<br /><br />

<div class="bubble3">
<div>
<div>
<div>
<div>
<div>
<strong>Ben je tevreden over je wedstrijd?<br /></strong><br />Didi Peters: Natuurlijk wel over vloer en sprong maar helemaal niet over de balk. <br />Evi Derks: Ja, best wel. <br />Zoë Teunissen: Ja alleen niet over brug <br />Fleur v/d Sluijs: jaaaa heel erg, want ik ben tweede geworden!! <br />Caya Verbruggen: Ja, ik ben weer wat vooruit gegaan. <br />Pleun Hoes: Dik tevreden. <br />Didi van Beuningen: Ja, want ik heb mij doelen bereikt . <br />Debby Pouwels: Ja ben, wel tevreden. Maar heb nog geen wedstrijd gehad waar ik me echt goed bij voelde. Dus hopelijk komt dat nog de 3e wedstrijd. <br /><br />
</div>
</div>
</div>
</div>
</div>
<span class="author"></span></div>
<br /><br />

<div class="bubble3">
<div>
<div>
<div>
<div>
<div>
<strong>Heb jezelf nog iets te vertellen over de wedstrijd? <br /></strong><br />Didi Peters: Nee eigenlijk niet. <br />Evi Derks: Ik vond het wel gezellig met Pleun en Didi Peters en Susan. <br />Zoë Teunissen: Nee!! <br />Fleur v/d Sluijs: Ik vond het erg leuk dat mijn papa, mama, opa, oma en broertje Joep met mij mee zijn wezen kijken. Zij waren heel trots! Ik heb genoten. <br />Caya Verbruggen: Het was een hele leuke en gezellige wedstrijd en hij was zo voorbij. <br />Pleun Hoes: Goed ophurken op brug oefenen!!!!!!!!!!!!!!!!! <br />Didi van Beuningen: Het was ook heel gezellig met : Britt , Caya en Florens . We hielpen elkaar als het wat minder ging en we waren blij voor elkaar als het goed ging. <br />Debby Pouwels: Ja, dat het super gezellig was, met Britt , Florens, Caya, en Didi want normaal gesproken ben ik altijd alleen. Ook niemand in de andere baan. En nu was het wel zo.</div>
</div>
</div>
</div>
</div>
<span class="author"></span></div>
<br /><br /><div class='yvComment'
  >
	<div class='NumCommentsAlone'>
  <a href='/content/turnen/nieuws/221-een-zilveren-medaille-voor-fleur-sluijs#yvComment'>Reacties (1)</a>	</div>
	
	
	
	
		  </div>
</div>



</div>

<span class="article_separator">&nbsp;</span>
		</div>
		</td>
</tr>

<tr>
	<td valign="top">
		<table width="100%"  cellpadding="0" cellspacing="0">
		<tr>
						<td valign="top" width="100%" class="article_column">
				
<div class="contentpaneopen">

<h2 class="contentheading">
		<a href="/content/dans/nieuws/220-druturnia-scoort-in-zierikzee" class="contentpagetitle">
		Druturnia scoort in Zierikzee	</a>
	</h2>


<div class="article-tools">
<div class="article-meta">

	<span class="createdate">
		zondag, 27 december 2009 13:21	</span>

	<span class="createby">
		Nancy Norwega	</span>

</div>

<div class="buttonheading">
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/46-dans/220-druturnia-scoort-in-zierikzee?tmpl=component&amp;print=1&amp;layout=default&amp;page=" title="Afdrukken" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/printButton.png" alt="Afdrukken"  /></a>	</span>
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/46-dans/220-druturnia-scoort-in-zierikzee?format=pdf" title="PDF" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/pdf_button.png" alt="PDF"  /></a>	</span>
	</div>

</div>


<div class="article-content">
<p><a class="thumbnail" href="/content/images/stories/newsphoto/2009/20091227ZierikzeeBeatFreakers.jpg" rel="lightbox[220]" title="20091227ZierikzeeBeatFreakers" target="_blank"><img height="150" width="200" src="/content/images/stories/newsphoto/thumbnails/200x150-images-stories-newsphoto-2009-20091227ZierikzeeBeatFreakers.jpg" alt="20091227ZierikzeeBeatFreakers" style="float: left;" /></a>Op 12 december was de derde ranking wedstrijd van het seizoen voor de hip hop en streetdance groepen. Deze keer deden zowel de groepen als de solo's mee.</p>
<p>Na onze teleurstelling van de groepswedstijd in Alkmaar hadden de Beatfreakerz wel wat goed te maken. Ook de druk voor de solisten stond erg hoog. Vorige keer behaalde Tanja de tweede ronde niet en Mario en Omar namen bekers mee naar huis.</p>
<p>De spanning was te snijden voor de wedstijd.</p>
<p>De enige concurrenten die de Beatfreakerz hebben dit seizoen zijn Faith MSCD, uit Nijmegen.</p>
<p>Ranking kampionen van vorig seizoen maken het de Beatfreakerz niet makkelijk.<br />De groepswedstijden begonnen als eerste. De Beatfreakerz zette ondanks het overslaan van de muziek een goede performance neer. Door een fout kon Faith MSCD uiteindelijk niet mee doen, waardoor de druk om een goede finale te dansen gelijk weg was. We namen dus ook zonder moeite de eerste prijs mee naar huis!! Voor de ranking betekent dit dat de twee groepen gelijk staan in punten.</p>
<p>Na lang wachten, zo'n 4 uur, was het dan eindelijk de beurt voor de solo's. Tanja startte in de voorrondes. En het ging heel erg goed! Vol zelfvertrouwen wist ze deze keer de jury wel te overtuigen. Er deden maar liefst 64 solisten mee en Tanja behaalde een 6de plaats. Voor haar betekent dit dat ze van de 34ste naar de 18de plaats is geklommen op de ranking!</p>
<p>Toen konden eindelijk Omar en Mario van start. In de categorie waarin zij dansten deden er maar 7 solisten mee. De concurrentie was deze wedstrijd ook er zwaar. Allebei hadden ze erg goed gedanst. Maar helaas voor de jury niet goed genoeg. Na afgelopen wedstrijd zo goed te hebben gescoord eindigde Omar helaas als 7de en Mario werd toch nog 5de.</p>
<p>De volgende wedstrijd zal erg spannend worden. Want tijdens de Dutch Open wat plaats zal vinden op 30 en 31 januari te Mill, kunnen er dubbele ranking punten verdient worden.</p><div class='yvComment'
  >
	<div class='NumCommentsAlone'>
  <a href='/content/dans/nieuws/220-druturnia-scoort-in-zierikzee#yvComment'>Voeg jouw reactie toe</a>	</div>
	
	
	
	
		  </div>
</div>



</div>

<span class="article_separator">&nbsp;</span>

<div class="contentpaneopen">

<h2 class="contentheading">
		<a href="/content/turnen/nieuws/219-samenvatting-1e-plaatsingswedstrijd-3e-divisie-19-12-2009" class="contentpagetitle">
		Samenvatting: 1e plaatsingswedstrijd 3e divisie 19-12-2009.	</a>
	</h2>


<div class="article-tools">
<div class="article-meta">

	<span class="createdate">
		woensdag, 23 december 2009 22:27	</span>

	<span class="createby">
		Susan Hopmans	</span>

</div>

<div class="buttonheading">
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/219-samenvatting-1e-plaatsingswedstrijd-3e-divisie-19-12-2009?tmpl=component&amp;print=1&amp;layout=default&amp;page=" title="Afdrukken" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/printButton.png" alt="Afdrukken"  /></a>	</span>
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/219-samenvatting-1e-plaatsingswedstrijd-3e-divisie-19-12-2009?format=pdf" title="PDF" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/pdf_button.png" alt="PDF"  /></a>	</span>
	</div>

</div>


<div class="article-content">
<p><em>Afgelopen zaterdag waren de meiden van de 3<sup>e</sup> divisie aan de beurt om hun eerste wedstrijd van het seizoen te turnen. De meeste turnsters turnde vorig jaar nog in de 4<sup>e</sup> divisie, dus er zat flink wat uitdaging in. De verwachtingen lagen niet hoog, omdat we eerst maar even het nieuwe systeem moesten proeven en kijken waar we staan.<br /><br /></em><strong>Wedstrijd 1<br /><br /></strong><a class="thumbnail" href="/content/images/stories/newsphoto/2009/20091223wedstrijd_3e_divisie_007.jpg" rel="lightbox[219]" title="1e plaatsingswedstrijd 3e divisie 19-12-2009" target="_blank"><img height="150" width="200" src="/content/images/stories/newsphoto/thumbnails/200x150-images-stories-newsphoto-2009-20091223wedstrijd_3e_divisie_007.jpg" alt="1e plaatsingswedstrijd 3e divisie 19-12-2009" style="float: right;" /></a>In de 1<sup>e</sup> wedstrijd waren onze instappers niveau 9 Pleun en Evi aan de beurt. Ze begonnen op brug.  Evi heeft hard geknokt om met ophurken erop te blijven zitten. Helaas lukte dit net niet waardoor ze een heel punt aftrek kreeg. Jammer! toch hield toch nog een mooie 11.350 over.<br /><br />Pleun werkte super netjes en ophurken lukte ook prima. Haar salto was echter zoooo hoog dat ze bijna een dubbele salto deed ze landde zonder eerst haar voeten op de grond te plaatsen op haar billen! Door haar val hield ze een 10.950 over. <br /><br />Daarna was het zenuwtoestel balk aan de beurt. Ze begonnen beide heel erg netjes maar moesten allebei de balk helaas verlaten met de koprol wat weer 1 heel punt kost. Op vloer zat een erg strenge jury, de meiden gingen allebei de goede kant op wat een hele prestatie is omdat we dit in Druten niet heel goed kunnen oefenen.<br /><br />Evi luisterde heel goed naar de muziek. Toen ze merkte dat ze te laat was vergat ze de loopsprong wat haar 2 punten kostte. Op sprong vlogen beide meiden over de kast heen en dat leverde ook uitstekende punten op Evi 12.500 en Pleun 12.750. Uiteindelijk werd Pleun 21<sup>e</sup> en Evi 26<sup>e</sup>. Een prima wedstrijd dus!<br /><br /><strong>Wedstrijd 2<br /><br /></strong><a class="thumbnail" href="/content/images/stories/newsphoto/2009/20091223wedstrijd_3e_divisie_004.jpg" rel="lightbox[219]" title="1e plaatsingswedstrijd 3e divisie 19-12-2009" target="_blank"><img height="150" width="200" src="/content/images/stories/newsphoto/thumbnails/200x150-images-stories-newsphoto-2009-20091223wedstrijd_3e_divisie_004.jpg" alt="1e plaatsingswedstrijd 3e divisie 19-12-2009" style="float: left;" /></a>In de 2<sup>e</sup> wedstrijd waren onze pupillen 1 niveau 8 Zoe, Marthe en Fleur en onze senioren niveau 4 Sanne en Evelyn aan de beurt. Sanne en Evelyn zagen erg op tegen deze wedstrijd omdat ze het er niet mee eens waren dat ik ze in de 3<sup>e</sup> divisie had geplaatst. Maar na sprong zeiden beide meiden dat het toch wel meeviel en dat ze hier toch wel thuis hoorde.<br /><br />Zoe mocht als eerste beginnen op de balk, ze turnde een hele nette oefening maar moest helaas met de radslag de balk verlaten. Ook Marthe werkte heel netjes alleen haar overspreiden lukte niet helemaal en de koprol zat er bijna op (maar helaas niet helemaal). Fleur turnde een hele stabiele oefening wat haar dan 13.050 opleverde.<br /><br />Vervolgens was vloer aan de beurt, ze turnde alle 3 heel netjes, alleen de jury was erg streng. Sprong was het volgende toestel. Marthe durfde in de training alweer helemaal alleen over de pegasus, op de wedstrijd vond ze het toch wel erg eng maar ze heeft gesprongen en haalde nog een mooie 11.000. Zoe en Fleur sprongen ook echt heel netjes wat Zoe een 13.150 opleverde en Fleur zelfs een 13.350. Fleur, Marthe en Zoe moesten als laatste nog brug, zoe werkte erg netjes alleen bij de salto af heb ik haar geholpen omdat ze die niet alleen durfde. Marthe turnde ook een hele nette oefening, doordat ze in het verleden een keer heel hard gevallen is durft ze nu niet naar de hoge ligger te springen hiermee heb ik haar geholpen. De salto af ging super goed en ook heel hoog. Fleur draaide een super oefening en de zolendraai lukte. Bij de prijsuitreiking greep Fleur net naast de medailles en behaalde een heel mooie 4<sup>e</sup> plek. Zoe werd 19<sup>e</sup> en Marthe werd 21<sup>e</sup>.<br /><br />Sanne en Evelyn begonnen op sprong en hun mooie overslagen leverde een 11.100 op voor beide. Vervolgens mochten de meiden hun kunsten vertonen op de brug. De eisen op dit toestel zijn erg zwaar en bijna onmogelijk. Bij Sanne lukte de kip handstand en de losomhandstand! Alleen lukte het wippertje niet wat haar erg veel punten gekost heeft. Brug is niet het beste toestel van Evelyn maar ze hield uiteindelijk meer punten over dan Sanne. Sanne en Evelyn mochten vervolgens naar de balk. Ook hier voldoen ze nog niet geheel aan alle eisen maar beide meiden turnden erg netjes. Op vloer ging het niet helemaal volgens plan, Sanne stond met 2 voeten buiten de lijnen wat gelijk afgestraft wordt met 0.50 punt en Evelyn werkte niet zo netjes als ze normaal kan. Evelyn werd heel mooi 13<sup>e</sup> en Sanne vanwege haar mislukte brug 23<sup>e.<br /><br /></sup><strong>Wedstrijd 3<br /><br /></strong><a class="thumbnail" href="/content/images/stories/newsphoto/2009/20091223wedstrijd_3e_divisie_003.jpg" rel="lightbox[219]" title="1e plaatsingswedstrijd 3e divisie 19-12-2009" target="_blank"><img height="150" width="200" src="/content/images/stories/newsphoto/thumbnails/200x150-images-stories-newsphoto-2009-20091223wedstrijd_3e_divisie_003.jpg" alt="1e plaatsingswedstrijd 3e divisie 19-12-2009" style="float: right;" /></a>In de 3<sup>e</sup> en laatste wedstrijd waren onze pupillen 2 niveau 7 Caya en Britt aan de beurt en ook Debby die in junior niveau 5 turnt. Debby begon op brug waar ze een keurige oefening turnde, ook de salto af deed ze helemaal alleen en ze haalde op dit toestel dan ook haar hoogste cijfer een 11.250. Caya en Britt begonnen op sprong waar ze 2 verschillende sprongen moesten uitvoeren namelijk een salto voorover en een overslag over de pegasus. Briit haalde een mooie 12.900 en Caya een 12.750. Debby mocht daarna naar balk, ze is de laatste tijd wat onzeker wat je ook terug zag in haar balk oefening, toch turnde ze een stabiele oefening. Caya en Britt mochten nu naar brug, Caya had erg veel stopjes en tussen zwaaien maar de zolendraai lukte bijna. Ook Britt turnde goed op brug. Ze had een hele mooie hoge opzwaai en ook bij haar lukte de zolendraai bijna. Debby was alweer naar vloer waarbij bij het inturnen er iets mis ging waardoor ze in de wedstrijd haar salto niet durfde te springen wat haar een heel punt kostte. Haar oefening verder zag er strak en netjes uit. Caya en Britt gingen na brug de balk op Caya kan de radslag nog niet helemaal maar ze raakte toch met 1 grote teen de balk waardoor de radslag wel telde. Britt turnde een super oefening en scoorde een mooie 11.900.<br /><br />Na 3 toestellen stond Britt op een mooie 2<sup>e</sup> plaats alleen vloer moest nog komen en daar was de jury erg streng. Bij Caya lukte de arabier dubbel flikflak. Er moet alleen nog hard gewerkt worden aan netheid op vloer. Tot slot moest Debby nog even springen ze sprong 2 keer een hele mooie overslag hele draai tot stand. Britt werd uiteindelijk heel mooi 8<sup>e</sup> en Caya 12<sup>e</sup>. Debby eindigde als 13<sup>e</sup>.<br /><br /><a class="thumbnail" href="/content/images/stories/newsphoto/2009/20091223wedstrijd_3e_divisie_001.jpg" rel="lightbox[219]" title="1e plaatsingswedstrijd 3e divisie 19-12-2009" target="_blank"><img height="150" width="200" src="/content/images/stories/newsphoto/thumbnails/200x150-images-stories-newsphoto-2009-20091223wedstrijd_3e_divisie_001.jpg" alt="1e plaatsingswedstrijd 3e divisie 19-12-2009" style="float: left;" /></a>Didi van Beuningen, Didi Peters en Florens waren vanwege een heerlijke vakantie niet van de partij op de 1<sup>e</sup> wedstrijd. De volgende wedstrijden zullen zij zeker mee doen. Voor de eerste wedstrijd ben ik zeer tevreden over de meiden van de 3<sup>e</sup> divisie, we weten nu waar we nog aan moeten werken.<br /><br />Turngroeten,<br />Susan Hopmans<br />Trainster A selectie </p><div class='yvComment'
  >
	<div class='NumCommentsAlone'>
  <a href='/content/turnen/nieuws/219-samenvatting-1e-plaatsingswedstrijd-3e-divisie-19-12-2009#yvComment'>Voeg jouw reactie toe</a>	</div>
	
	
	
	
		  </div>
</div>



</div>

<span class="article_separator">&nbsp;</span>

<div class="contentpaneopen">

<h2 class="contentheading">
		<a href="/content/turnen/nieuws/218-succesvolle-instuif" class="contentpagetitle">
		Succesvolle instuif	</a>
	</h2>


<div class="article-tools">
<div class="article-meta">

	<span class="createdate">
		zondag, 20 december 2009 11:22	</span>

	<span class="createby">
		Susan Hopmans	</span>

</div>

<div class="buttonheading">
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/218-succesvolle-instuif?tmpl=component&amp;print=1&amp;layout=default&amp;page=" title="Afdrukken" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/printButton.png" alt="Afdrukken"  /></a>	</span>
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/218-succesvolle-instuif?format=pdf" title="PDF" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/pdf_button.png" alt="PDF"  /></a>	</span>
	</div>

</div>


<div class="article-content">
<a class="thumbnail" href="/content/images/stories/newsphoto/2009/20091220Instuif.jpg" rel="lightbox[218]" title="Druturnia Instuif" target="_blank"><img height="150" width="200" src="/content/images/stories/newsphoto/thumbnails/200x150-images-stories-newsphoto-2009-20091220Instuif.jpg" alt="Druturnia Instuif" style="float: left;" /></a>Op 29 oktober was de eerste activiteit georganiseerd door de jeugdcommissie van Druturnia: de Druturnia dans- en turninstuif.<br /><br />’s Ochtends om kwart over 9 was iedereen van de jeugdcommissie aanwezig, en ook de assistenten en leiding van het turnen en de dans waren er om te helpen met opbouwen. Ook de activiteitencommissie was van de partij om o.a. het geld in te nemen. Als eerste was de groep van kinderen van groep 1 tm groep 4 van de basisschool aan de beurt. De kinderen die binnenkwamen brachten we via de ‘blauwe loper’ naar de toneelzaal waar de dansleiding de warming-up zou gaan verzorgen. Om 10 uur was iedereen binnen: wel 80 kinderen vulden de toneelzaal. Na de warming-up werden de kinderen verdeeld in 6 groepen, en ging iedereen naar de plek waar hij of zij zou gaan beginnen. Iedereen ging dansen, en turnen op 5 toestellen: brug, balk, tumblingbaan, wandrek en trampoline. Er werd hard gedanst en geturnd, en iedereen liep geconcentreerd over de balk, klauterde als aapjes in het wandrek, danste een mooie dans in de toneelzaal, maakte koprollen aan de brug, en sprong op de trampoline en de tumblingbaan. Na anderhalf uur had iedereen dorst gekregen en gingen we naar de toneelzaal waar de kinderen limonade en een snoepje kregen van de activiteitencommissie. Ook kreeg iedereen een mooi diploma.<br /><br />Na de eerste groep gingen de leiding en assistenten eten, en daarna kwamen de kinderen van de tweede groep (van groep 5 tm groep 8 van de basisschool) al binnen. Deze groep was ook weer vol: bijna 50 kinderen. Ook hier werd de warming-up weer verzorgd door de dansleiding, en daarna gingen we weer twee uur dansen en turnen. In deze groep werd er ook weer flink gedanst, en geturnd op alle toestellen. Toen na twee uur iedereen een boel nieuwe dingen had geleerd en moe was van het dansen en turnen, gingen we weer terug naar de toneelzaal. Daar kreeg iedereen weer wat te drinken en een diploma, en toen gingen de kinderen van de tweede groep naar huis.<br /><br />Na een korte pauze van een half uurtje was de derde groep aan de beurt. Omdat hier wat minder kinderen waren, besloten we eerst gezamenlijk te gaan dansen, en daarna met z’n allen te gaan turnen. Leiding en assistenten deden in de laatste groep ook mee, en hielpen elkaar met turnen en dansen. Om 5 uur ruimden we de zaal op, bedankten iedereen die had geholpen, en gingen we met de jeugdcommissie en Susan (begleiding jeugdcommissie) pannenkoeken eten bij Marloes thuis. We bespraken de dag, en bekeken wat er nog beter kon voor een volgende keer. Daarna ging iedereen naar huis na een zeer geslaagde dag.<br /><br />We hopen dat iedereen die geweest is het leuk vond. Heb je nou voor de eerste keer gedanst of geturnd, en je wilt misschien wel lid worden? Kom dan gratis twee proeflessen mee doen! Kijk op deze site voor het lesrooster.<br /><div class='yvComment'
  >
	<div class='NumCommentsAlone'>
  <a href='/content/turnen/nieuws/218-succesvolle-instuif#yvComment'>Voeg jouw reactie toe</a>	</div>
	
	
	
	
		  </div>
</div>



</div>

<span class="article_separator">&nbsp;</span>

<div class="contentpaneopen">

<h2 class="contentheading">
		<a href="/content/turnen/nieuws/217-prima-resultaat-druturnia-op-wedstrijd-nijmegen" class="contentpagetitle">
		Prima resultaat Druturnia op wedstrijd Nijmegen	</a>
	</h2>


<div class="article-tools">
<div class="article-meta">

	<span class="createdate">
		zaterdag, 19 december 2009 12:52	</span>

	<span class="createby">
		Susan Hopmans	</span>

</div>

<div class="buttonheading">
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/217-prima-resultaat-druturnia-op-wedstrijd-nijmegen?tmpl=component&amp;print=1&amp;layout=default&amp;page=" title="Afdrukken" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/printButton.png" alt="Afdrukken"  /></a>	</span>
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/2-turnen/217-prima-resultaat-druturnia-op-wedstrijd-nijmegen?format=pdf" title="PDF" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/pdf_button.png" alt="PDF"  /></a>	</span>
	</div>

</div>


<div class="article-content">
<p>Normaal staat 5 december helemaal in het teken staat van Sinterklaas en pakjesavond. Maar dit jaar was dit voor een aantal meiden van Druturnia niet het geval. Zij moesten namelijk ‘vol aan de bak’ tijdens een turnwedstrijd in Nijmegen. Voor de meiden was dit de eerste wedstrijd volgens het nieuwe systeem…(vroeger kon je als turnster per oefening max tien punten halen, nu is de puntentelling veranderd en kun je zelf 14 punten halen per oefening. ).<br /><br />Plom en inge instap niveau 10 mochten heel vroeg in de ochtend hun wedstrijd laten zien. Plom was de avond ervoor nog naar het concert van Anouk geweest en had erg weinig geslapen maar turnde toch hele goede wedstrijd! Haar brug ging perfect en hier scoorde ze dan ook een dikke 12.150. Inge turnde ook een prima brugoefening en behaalde 11.850 punten (wat haar hoogste cijfer was van alle 4 de toestellen).<br /><br />Daarna was balk aan de beurt. Ze draaide allebei een keurig nette oefening alleen de koprol bij Plom lukte niet helemaal goed. Inge bleef er netjes op met de koprol. Alleen vergat Inge 2 onderdelen, wat haar gelijk 4 punten kostte. <br /><br />Inge en Plom pompte er allebei nog even een super goede vloeroefening uit. En gingen daarna door naar het laatste toestel, de Sprong. Bij sprong begon de vermoeidheid Plom toch toe te slaan… waardoor haar eerste overslag niet lukte en ze een nul kreeg. Gelukkig ging sprong nummer 2 wel heel goed en haalde ze toch een mooi punt. Inge mocht met trampoline springen en de overslag lukte dan ook prima. Inge werd uiteindelijk 27e en Plom 11e.<br /><br />Tijdens wedstrijd 2 mochten Hilde, Marieke en Nathalie zichzelf bewijzen in junior niveau 6. Ze begonnen op het zenuwtoestel balk. Nathalie en Hilde vielen helaas allebei een keer van de balk. En dan gaat er helaas direct een heel punt van het eindcijfer af. Marieke bleef keurig staan en had een dikke 12.200 gekregen voor haar fantastische oefening. Alle 3 hebben ze super netjes geturnd.<br /><br />Vloer ging ook super! De meiden straalde en zette alle drie een keurige oefening neer. Marieke had zelfs de hoogste D score van 3.70 en ook haar 1/2 schroef lukte. Na deze 2 toestellen stond Marieke 1e en Nathalie 3e. Toen was sprong aan de beurt. De dames vlogen over de Pegasus heen alsof het niks was en na het 3e toestel stond Marieke nog steeds 1e en Nathalie nog steeds 3e. Spannend dus!! <br /><br />Bij brug werd de druk dan toch echt wat te groot. Hilde begon goed en haar kippen lukte allebei, helaas ging ze met ophurken eraf wat afgestraft wordt met 1 punt aftrek. Nathalie turnde een mooie stabiele oefening, de jury was erg streng op brug waardoor de score een beetje tegen viel. Marieke had echt pech want ze ging eraf met de zolendraai en vervolgens durfde ze de salto niet. Marieke was heel erg teleurgesteld want deze 2 grote fouten koste haar de eerste plek. <br /><br />Bij de einduitslag werd Nathalie heel mooi 8e en Marieke 16e en Hilde 21e. Melle en Lieke konden helaas niet deelnemen aan de eerste wedstrijd. Lieke heeft een vervelende blessure aan haar enkel en Melle was net op een ongelukkig moment ziek. gelukkig zijn er 3 wedstrijden waarvan de beste 2 tellen dus in januari zijn deze meiden ook weer van de partij.<br /><br />We kunnen in elk geval terug kijken op een geslaagde 1e wedstrijd en we gaan weer hard aan de slag voor de 2e wedstrijd.</p><div class='yvComment'
  >
	<div class='NumCommentsAlone'>
  <a href='/content/turnen/nieuws/217-prima-resultaat-druturnia-op-wedstrijd-nijmegen#yvComment'>Voeg jouw reactie toe</a>	</div>
	
	
	
	
		  </div>
</div>



</div>

<span class="article_separator">&nbsp;</span>

<div class="contentpaneopen">

<h2 class="contentheading">
		<a href="/content/dans/nieuws/216-druturnias-definition-of-dance-naar-het-wereldkampioenschap-showdance" class="contentpagetitle">
		Druturnia’s Definition of Dance naar het Wereldkampioenschap Showdance!	</a>
	</h2>


<div class="article-tools">
<div class="article-meta">

	<span class="createdate">
		zondag, 06 december 2009 12:34	</span>

	<span class="createby">
		Gianna Reyers	</span>

</div>

<div class="buttonheading">
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/46-dans/216-druturnias-definition-of-dance-naar-het-wereldkampioenschap-showdance?tmpl=component&amp;print=1&amp;layout=default&amp;page=" title="Afdrukken" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/printButton.png" alt="Afdrukken"  /></a>	</span>
	
		<span>
	<a href="/content/nieuws/laatste-nieuws/46-dans/216-druturnias-definition-of-dance-naar-het-wereldkampioenschap-showdance?format=pdf" title="PDF" onclick="window.open(this.href,'win2','status=no,toolbar=no,scrollbars=yes,titlebar=no,menubar=no,resizable=yes,width=640,height=480,directories=no,location=no'); return false;" rel="nofollow"><img src="/content/templates/ja_purity/images/pdf_button.png" alt="PDF"  /></a>	</span>
	</div>

</div>


<div class="article-content">
<a class="thumbnail" href="/content/images/stories/newsphoto/2009/20091206definitionofdance.jpg" rel="lightbox[216]" title="Vlnr: Gianna, Josje, Mireille, Gwenda, Manon." target="_blank"><img longdesc="Vlnr: Gianna, Josje, Mireille, Gwenda, Manon." style="float: left;" title="Vlnr: Gianna, Josje, Mireille, Gwenda, Manon." alt="20091206definitionofdance" height="150" width="200" src="/content/images/stories/newsphoto/thumbnails/200x150-images-stories-newsphoto-2009-20091206definitionofdance.jpg" /></a>
<p>Op 27 nov jl. heeft Druturnia’s Definition of Dance Nederland vertegenwoordigd tijdens het wereldkampioenschap schowdance in Riesa.  Het niveau lag erg hoog maar ondanks dat wisten de 5 meiden toch een 37<sup>ste</sup> plaats te behalen van de 44 deelnemenden landen.</p>
<p>De  lange autorit was goed te doen dankzij de lekkere broodjes van bakkerij Vonk en leuke spelletjes. Om 22:00uur kwamen ze aan in Oost-Duitsland. De volgende ochtend ging de wekker al vroeg  want om half 10 begon het vloerverkennen. Van te voren moest er nog geschminkt worden en het haar moest worden gedaan. Snel nog ontbijten om vervolgens naar de sporthal te rijden.</p>
<p>De dansen in de categorie showdance zijn gebaseerd op een concept, verhaal, thema of idee en worden beoordeeld op Techniek, Compositie, Image en Show-waarde (entertainment).</p>
<p>Het thema van de dansgroep was “Drama-Queens”. Dit werd uitgebeeld dmv. een pittige dans met spiegels.</p>
<p>Al met al een leerzame ervaring en hopelijk kwalificeren ze zich volgend jaar weer en komen ze hoger op de wereldranglijst te staan!</p></div>



</div>

<span class="article_separator">&nbsp;</span>
				</td>
		 
		</tr>
		</table>
	</td>
</tr>

<tr>
	<td valign="top" align="center">
		<ul class="pagination"><li>&laquo;</li><li>&nbsp;<span>Start</span>&nbsp;</li><li>&nbsp;<span>Vorige</span>&nbsp;</li><li>&nbsp;<span>1</span>&nbsp;</li><li>&nbsp;<strong><a href="/content/nieuws/laatste-nieuws?start=10" title="2">2</a></strong>&nbsp;</li><li>&nbsp;<strong><a href="/content/nieuws/laatste-nieuws?start=20" title="3">3</a></strong>&nbsp;</li><li>&nbsp;<strong><a href="/content/nieuws/laatste-nieuws?start=30" title="4">4</a></strong>&nbsp;</li><li>&nbsp;<strong><a href="/content/nieuws/laatste-nieuws?start=40" title="5">5</a></strong>&nbsp;</li><li>&nbsp;<strong><a href="/content/nieuws/laatste-nieuws?start=50" title="6">6</a></strong>&nbsp;</li><li>&nbsp;<strong><a href="/content/nieuws/laatste-nieuws?start=60" title="7">7</a></strong>&nbsp;</li><li>&nbsp;<strong><a href="/content/nieuws/laatste-nieuws?start=70" title="8">8</a></strong>&nbsp;</li><li>&nbsp;<strong><a href="/content/nieuws/laatste-nieuws?start=80" title="9">9</a></strong>&nbsp;</li><li>&nbsp;<strong><a href="/content/nieuws/laatste-nieuws?start=90" title="10">10</a></strong>&nbsp;</li><li>&nbsp;<strong><a href="/content/nieuws/laatste-nieuws?start=10" title="Volgende">Volgende</a></strong>&nbsp;</li><li>&nbsp;<strong><a href="/content/nieuws/laatste-nieuws?start=130" title="Einde">Einde</a></strong>&nbsp;</li><li>&raquo;</li></ul>		<br /><br />
	</td>
</tr>
<tr>
	<td valign="top" align="center">
		Pagina 1 van 14	</td>
</tr>
</table>
</div></div>
<!-- END: CONTENT -->
                      </div>
                    <!-- BEGIN: RIGHT COLUMN -->
          <div id="ja-col2">
            		<div class="jamod module" id="Mod79">
			<div>
				<div>
					<div>
																		<h3 class="show"><span>Laatste reacties</span></h3>
												<div class="jamod-content">
  	<ul class="latestnews">
    			<li class="latestnews">
	      								<a href="/content/nieuws/laatste-nieuws/6-overig/224-steun#yvComment" class="latestnews" title="(S)teun">leuk</a>
	    </li>
	  			<li class="latestnews">
	      								<a href="/content/turnen/nieuws/225-druturnia-turnsters-3e-divisie-allemaal-door-naar-regio-finale#yvComment" class="latestnews" title="Druturnia turnsters 3e divisie allemaal door naar regio finale!!">3e divisie</a>
	    </li>
	  			<li class="latestnews">
	      								<a href="/content/nieuws/laatste-nieuws/6-overig/224-steun#yvComment" class="latestnews" title="(S)teun">.</a>
	    </li>
	  			<li class="latestnews">
	      								<a href="/content/turnen/nieuws/221-een-zilveren-medaille-voor-fleur-sluijs#yvComment" class="latestnews" title="Een zilveren medaille voor Fleur Sluijs">leuke 2e plaats</a>
	    </li>
	  			<li class="latestnews">
	      								<a href="/content/dans/nieuws/211-definition-of-dance-2de-plaats-op-nk-showdance#yvComment" class="latestnews" title="Definition of Dance 2de plaats op NK Showdance">NK showdance</a>
	    </li>
	    </ul> 
</div>
					</div>
				</div>
			</div>
		</div>
			<div class="jamod module" id="Mod97">
			<div>
				<div>
					<div>
																		<h3 class="show"><span>Populaire onderwerpen</span></h3>
												<div class="jamod-content"><a href="/content/component/jtags/Clubkampioenschappen/" ><span style="font-size:11px;" >Clubkampioenschappen</span></a> <a href="/content/component/jtags/Deester%20Feestweek/" ><span style="font-size:11px;" >Deester Feestweek</span></a> <a href="/content/component/jtags/Definition_of_Dance/" ><span style="font-size:12px;" >Definition_of_Dance</span></a> <a href="/content/component/jtags/Districtfinale/" ><span style="font-size:11px;" >Districtfinale</span></a> <a href="/content/component/jtags/Gym%20Doe%20Dag/" ><span style="font-size:12px;" >Gym Doe Dag</span></a> <a href="/content/component/jtags/Jazzdance/" ><span style="font-size:14px;" >Jazzdance</span></a> <a href="/content/component/jtags/Jongensturnen/" ><span style="font-size:11px;" >Jongensturnen</span></a> <a href="/content/component/jtags/Pietengym/" ><span style="font-size:13px;" >Pietengym</span></a> <a href="/content/component/jtags/Plus%20Gubbels/" ><span style="font-size:11px;" >Plus Gubbels</span></a> <a href="/content/component/jtags/Sponsors/" ><span style="font-size:12px;" >Sponsors</span></a> <a href="/content/component/jtags/Springgroep/" ><span style="font-size:11px;" >Springgroep</span></a> <a href="/content/component/jtags/Springtoernooi/" ><span style="font-size:12px;" >Springtoernooi</span></a> <a href="/content/component/jtags/Streetdance/" ><span style="font-size:13px;" >Streetdance</span></a> <a href="/content/component/jtags/Turnen/" ><span style="font-size:23px;" >Turnen</span></a> <a href="/content/component/jtags/Voorstelling/" ><span style="font-size:11px;" >Voorstelling</span></a> <p align="right"><a href="/content/component/jtags/" >+ Alle Onderwerpen</a></p></div>
					</div>
				</div>
			</div>
		</div>
	
          </div>
          <br />
          <!-- END: RIGHT COLUMN -->
                  </div>
      </div>
    </div>
  </div>
    <!-- BEGIN: BOTTOM SPOTLIGHT -->
  <div id="ja-botslwrap">
    <div id="ja-botsl" class="clearfix">
                  <div class="ja-box-left" style="width: 22%;">
        		<div class="moduletable">
					<span class="breadcrumbs pathway">
<a href="http://www.druturnia.nl/content/" class="pathway">Hoofdpagina</a> <img src="/content/templates/ja_purity/images/arrow.png" alt=""  /> <a href="/content/nieuws" class="pathway">Nieuws</a> <img src="/content/templates/ja_purity/images/arrow.png" alt=""  /> Laatste nieuws</span>
		</div>
	
      </div>
                        <div class="ja-box-right" style="width: 77%;">
        
      </div>
          </div>
  </div>
  <!-- END: BOTTOM SPOTLIGHT -->
    <!-- BEGIN: FOOTER -->
  <div id="ja-footerwrap">
    <div id="ja-footer" class="clearfix">
      <div id="ja-footnav">
        
      </div>
      <div class="copyright">
        <div>Copyright &#169; 2004 -  2010 Druturnia / Ramon Quadflieg.</div>
<div>Alle rechten voorbehouden.</div>
      </div>
      <div class="ja-cert">
        <a href="/content/component/xmap/?sitemap=1">Sitemap</a> /<a href="/content/nieuws/laatste-nieuws?format=feed&amp;type=rss">RSS 2.0</a> /<a href="/content/nieuws/laatste-nieuws?format=feed&amp;type=atom">Atom 1.0</a>
      </div>
      <br />
    </div>
  </div>
  <!-- END: FOOTER -->
</div>

</body>
</html>UlJfU1RSSU5HX1BST1RFQ1RJT05fRU5E|>