<|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/component/xmap/" />
  <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="Joomla! 1.5 - Open Source Content Management" />
  <title>Druturnia - Druturnia</title>
  <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" />
  <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/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='show';
var excludeModules='';
</script>
<script language="javascript" type="text/javascript" src="http://www.druturnia.nl/content/templates/ja_purity/js/ja.rightcol.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>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:fb="http://www.facebook.com/2008/fbml"></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>
	<li><a href="#ja-col1" title="Overslaan naar eerste kolom">Overslaan naar eerste kolom</a></li>
	<li><a href="#ja-col2" title="Overslaan naar tweede kolom">Overslaan naar tweede kolom</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/header3.jpg) no-repeat top right;">

		<div class="ja-headermask">&nbsp;</div>

			<h1 class="logo">
			<a href="/content/index.php" title="Druturnia"><span>Druturnia</span></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" />
	<input type="hidden" name="Itemid" value="0" />
</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 item1">
		<a href="http://www.druturnia.nl/content/">
			<span>Nieuws</span>
		</a>
		<ul>
			<li class="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/bestuur">
					<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 id="ja-pathway">
				
			</div>
			
			﻿<div class="xmap"><div class="componentheading"></div><div class="contentpaneopen"><h2 class="menutitle">Menu</h2>
<ul class="level_0">
<li><a href="/content/nieuws" title="Nieuws">Nieuws</a>
<ul class="level_1">
<li><a href="/content/nieuws/laatste-nieuws" title="Laatste nieuws">Laatste nieuws</a>
<ul class="level_2">
<li><a href="/content/turnen/nieuws" title="Turnen">Turnen</a>
<ul class="level_3">
<li><a href="/content/turnen/nieuws/243-sportieve-workshops-en-bbq" title="Sportieve Workshops en BBQ">Sportieve Workshops en BBQ</a></li>
<li><a href="/content/turnen/nieuws/242-29-mei-2010-finale-van-de-6e-divisie" title="29 mei 2010 finale van de 6e divisie">29 mei 2010 finale van de 6e divisie</a></li>
<li><a href="/content/turnen/nieuws/235-nk-turnen-24-april" title="NK turnen 24 april">NK turnen 24 april</a></li>
<li><a href="/content/turnen/nieuws/234-de-regiofinale-in-doetinchem-17-april-2010" title="De regiofinale in Doetinchem, 17 april 2010">De regiofinale in Doetinchem, 17 april 2010</a></li>
<li><a href="/content/turnen/nieuws/247-wedstrijd-7e-divisie-en-pre-instappers-12-juni-2010" title="Wedstrijd 7e divisie en pre-instappers 12 juni 2010">Wedstrijd 7e divisie en pre-instappers 12 juni 2010</a></li>
<li><a href="/content/turnen/nieuws/233-6e-divisie-10-april" title="6e divisie 10 april">6e divisie 10 april</a></li>
<li><a href="/content/turnen/nieuws/232-regiofinale-4e-divisie-17-april" title="Regiofinale 4e divisie 17 april">Regiofinale 4e divisie 17 april</a></li>
<li><a href="/content/turnen/nieuws/231-7e-divisie-1e-wedstrijd-27-maart" title="7e divisie 1e wedstrijd 27 maart">7e divisie 1e wedstrijd 27 maart</a></li>
<li><a href="/content/turnen/nieuws/230-2-druturnia-meiden-4e-divisie-in-de-prijzen" title="2 Druturnia meiden 4e divisie in de prijzen!">2 Druturnia meiden 4e divisie in de prijzen!</a></li>
<li><a href="/content/turnen/nieuws/226-leuke-wedstrijd-met-goed-resultaat" title="Leuke wedstrijd, met goed resultaat!">Leuke wedstrijd, met goed resultaat!</a></li>
<li><a href="/content/turnen/nieuws/225-druturnia-turnsters-3e-divisie-allemaal-door-naar-regio-finale" title="Druturnia turnsters 3e divisie allemaal door naar regio finale!!">Druturnia turnsters 3e divisie allemaal door naar regio finale!!</a></li>
<li><a href="/content/turnen/nieuws/222-verslag-2e-plaatsingswedstrijd-4e-divisie-nijmegen" title="Verslag 2e plaatsingswedstrijd 4e divisie Nijmegen">Verslag 2e plaatsingswedstrijd 4e divisie Nijmegen</a></li>
<li><a href="/content/turnen/nieuws/221-een-zilveren-medaille-voor-fleur-sluijs" title="Een zilveren medaille voor Fleur Sluijs">Een zilveren medaille voor Fleur Sluijs</a></li>
<li><a href="/content/turnen/nieuws/219-samenvatting-1e-plaatsingswedstrijd-3e-divisie-19-12-2009" title="Samenvatting: 1e plaatsingswedstrijd 3e divisie 19-12-2009.">Samenvatting: 1e plaatsingswedstrijd 3e divisie 19-12-2009.</a></li>
<li><a href="/content/turnen/nieuws/218-succesvolle-instuif" title="Succesvolle instuif">Succesvolle instuif</a></li>
<li><a href="/content/turnen/nieuws/217-prima-resultaat-druturnia-op-wedstrijd-nijmegen" title="Prima resultaat Druturnia op wedstrijd Nijmegen">Prima resultaat Druturnia op wedstrijd Nijmegen</a></li>
<li><a href="/content/turnen/nieuws/213-druturnia-heeft-er-weer-2-nieuwe-assistentes-bij" title="Druturnia heeft er weer 2 nieuwe assistentes bij.">Druturnia heeft er weer 2 nieuwe assistentes bij.</a></li>
<li><a href="/content/turnen/nieuws/199-toestelkampioenschappen-in-doetinchem" title="Toestelkampioenschappen in Doetinchem">Toestelkampioenschappen in Doetinchem</a></li>
<li><a href="/content/turnen/nieuws/198-selectietraining-voor-plaats-in-selectiegroepen-turnen-" title="Selectietraining voor plaats in Selectiegroepen turnen ">Selectietraining voor plaats in Selectiegroepen turnen </a></li>
<li><a href="/content/turnen/nieuws/196-finale-van-de-5e-divisie-turnen-in-lelystad" title="Finale van de 5e divisie turnen in Lelystad">Finale van de 5e divisie turnen in Lelystad</a></li>
<li><a href="/content/turnen/nieuws/193-floortje-bevallen-van-tweede-zoon" title="Floortje bevallen van tweede zoon">Floortje bevallen van tweede zoon</a></li>
<li><a href="/content/turnen/nieuws/176-dertien-medailles-in-opheusden" title="Dertien medailles in Opheusden">Dertien medailles in Opheusden</a></li>
<li><a href="/content/turnen/nieuws/173-druturnia-heeft-9-nieuwe-assistent-leiders-erbij-gekregen" title="Druturnia heeft 9 nieuwe Assistent Leiders erbij gekregen!">Druturnia heeft 9 nieuwe Assistent Leiders erbij gekregen!</a></li>
<li><a href="/content/turnen/nieuws/164-top-prestaties-druturnia" title="Top prestaties Druturnia!!!">Top prestaties Druturnia!!!</a></li>
<li><a href="/content/turnen/nieuws/155-assistentencursus-2-praktijkdag" title="Assistentencursus 2 praktijkdag in De Lier in Puiflijk">Assistentencursus 2 praktijkdag in De Lier in Puiflijk</a></li>
<li><a href="/content/turnen/nieuws/148-wedstrijdverslag-pre-instap-en-7e-divisie" title="Wedstrijdverslag Pre Instap en 7e divisie">Wedstrijdverslag Pre Instap en 7e divisie</a></li>
<li><a href="/content/turnen/nieuws/156-berichtje-van-madelon" title="Berichtje van Madelon">Berichtje van Madelon</a></li>
<li><a href="/content/turnen/nieuws/139-jongens-zetten-beste-beentje-voor-in-hellendoorn" title="Jongens zetten beste beentje voor in Hellendoorn">Jongens zetten beste beentje voor in Hellendoorn</a></li>
<li><a href="/content/turnen/nieuws/128-3-meiden-door-naar-de-landelijke-finale" title="3 meiden door naar de landelijke finale!">3 meiden door naar de landelijke finale!</a></li>
<li><a href="/content/turnen/nieuws/122-druturnia-succesvol-tijdens-regiofinale-4e-divisie" title="Druturnia succesvol tijdens regiofinale 4e divisie!">Druturnia succesvol tijdens regiofinale 4e divisie!</a></li>
<li><a href="/content/turnen/nieuws/114-super-prestatie-voor-3e-divisie" title="Super prestatie voor 3e divisie">Super prestatie voor 3e divisie</a></li>
<li><a href="/content/turnen/nieuws/111-geslaagd-voor-de-jurycursus" title="Geslaagd voor de jurycursus">Geslaagd voor de jurycursus</a></li>
<li><a href="/content/turnen/nieuws/110-jongens-druturnia-goed-van-start" title="Jongens Druturnia goed van start">Jongens Druturnia goed van start</a></li>
<li><a href="/content/turnen/nieuws/109-druturnia-heeft-weer-succes-in-4e-divisie-" title="Druturnia heeft weer succes in 4e divisie! ">Druturnia heeft weer succes in 4e divisie! </a></li>
<li><a href="/content/turnen/nieuws/107-de-eerste-turnwedstrijd-in-het-nieuwe-seizoen" title="De eerste turnwedstrijd in het nieuwe seizoen!!">De eerste turnwedstrijd in het nieuwe seizoen!!</a></li>
<li><a href="/content/turnen/nieuws/105-druturnia-komt-met-4-medailles-terug-van-de-wedstrijd" title="Druturnia komt met 4 medailles terug van de wedstrijd">Druturnia komt met 4 medailles terug van de wedstrijd</a></li>
<li><a href="/content/turnen/nieuws/104-doldwaze-pietengym" title="Doldwaze Pietengym">Doldwaze Pietengym</a></li>
<li><a href="/content/turnen/nieuws/103-sportieve-zaterdag-voor-druturnia" title="Sportieve zaterdag voor Druturnia">Sportieve zaterdag voor Druturnia</a></li>
<li><a href="/content/turnen/nieuws/102-pietengym-2008" title="Pietengym 2008">Pietengym 2008</a></li>
<li><a href="/content/turnen/nieuws/99-succesvol-jaar-druturnia" title="Succesvol jaar Druturnia">Succesvol jaar Druturnia</a></li>
<li><a href="/content/turnen/nieuws/98-nieuwe-assistentes" title="Nieuwe assistentes">Nieuwe assistentes</a></li>
<li><a href="/content/turnen/nieuws/97-druturnia-jongens-succesvol-tijdens-finale-district-oost" title="Druturnia jongens succesvol tijdens Finale District Oost!">Druturnia jongens succesvol tijdens Finale District Oost!</a></li>
<li><a href="/content/turnen/nieuws/96-druturnia-in-de-waalkanter" title="Druturnia in de Waalkanter">Druturnia in de Waalkanter</a></li>
<li><a href="/content/turnen/nieuws/95-clubkampioenschappen-druturnia-groot-succes" title="Clubkampioenschappen Druturnia groot succes">Clubkampioenschappen Druturnia groot succes</a></li>
<li><a href="/content/turnen/nieuws/94-weer-medailles-voor-jongens-druturnia" title="Weer medailles voor jongens Druturnia">Weer medailles voor jongens Druturnia</a></li>
<li><a href="/content/turnen/nieuws/87-druturnia-op-clubteamwedstrijd" title="Druturnia op Clubteamwedstrijd">Druturnia op Clubteamwedstrijd</a></li>
<li><a href="/content/turnen/nieuws/86-pietengym-veel-nieuwe-pieten-bij-druturnia" title="Pietengym: Veel nieuwe Pieten bij Druturnia">Pietengym: Veel nieuwe Pieten bij Druturnia</a></li>
<li><a href="/content/turnen/nieuws/85-doldwaze-pietengym" title="Doldwaze Pietengym!!">Doldwaze Pietengym!!</a></li>
<li><a href="/content/turnen/nieuws/83-5-prijswinnaars-druturnia-op-springtoernooi" title="5 prijswinnaars Druturnia op Springtoernooi">5 prijswinnaars Druturnia op Springtoernooi</a></li>
<li><a href="/content/turnen/nieuws/82-springtoernooi-in-ochten" title="Springtoernooi in Ochten">Springtoernooi in Ochten</a></li>
<li><a href="/content/turnen/nieuws/76-districtfinale-4e-divisie" title="Districtfinale 4e divisie">Districtfinale 4e divisie</a></li>
<li><a href="/content/turnen/nieuws/77-zaterdag-14-april-landelijke-finale-te-franeker" title="Zaterdag 14 april: Landelijke finale te Franeker">Zaterdag 14 april: Landelijke finale te Franeker</a></li>
<li><a href="/content/turnen/nieuws/75-verslag-wedstrijd-7e-divisie" title="Verslag wedstrijd 7e divisie">Verslag wedstrijd 7e divisie</a></li>
<li><a href="/content/turnen/nieuws/73-succes-in-de-6de-divisie" title="Succes in de 6de divisie">Succes in de 6de divisie</a></li>
<li><a href="/content/turnen/nieuws/70-en-de-wedstrijden-gaan-maar-door" title="En de wedstrijden gaan maar door!">En de wedstrijden gaan maar door!</a></li>
<li><a href="/content/turnen/nieuws/69-goed-begin-van-het-jaar-voor-druturnia" title="Goed begin van het jaar voor Druturnia!">Goed begin van het jaar voor Druturnia!</a></li>
<li><a href="/content/turnen/nieuws/66-goud-voor-roos-smits" title="Goud voor Roos Smits">Goud voor Roos Smits</a></li>
<li><a href="/content/turnen/nieuws/65-2e-wedstrijd-4e-divisie-weer-een-succes" title="2e wedstrijd 4e divisie weer een succes">2e wedstrijd 4e divisie weer een succes</a></li>
<li><a href="/content/turnen/nieuws/64-goede-wedstrijdprestaties-druturnia" title="Goede wedstrijdprestaties Druturnia">Goede wedstrijdprestaties Druturnia</a></li>
<li><a href="/content/turnen/nieuws/63-eerste-wedstrijd-van-het-seizoen-2-medailles" title="Eerste wedstrijd van het seizoen, 2 medailles!!">Eerste wedstrijd van het seizoen, 2 medailles!!</a></li>
<li><a href="/content/turnen/nieuws/62-een-dolle-pietenboel" title="Een dolle pietenboel">Een dolle pietenboel</a></li>
<li><a href="/content/turnen/nieuws/61-pietengym-2006" title="Pietengym 2006">Pietengym 2006</a></li>
<li><a href="/content/turnen/nieuws/60-gym-doe-dag-2006" title="Gym Doe Dag 2006">Gym Doe Dag 2006</a></li>
<li><a href="/content/turnen/nieuws/56-plaatsingswedstrijden-enschede-en-doetinchem" title="Plaatsingswedstrijden Enschede en Doetinchem">Plaatsingswedstrijden Enschede en Doetinchem</a></li>
<li><a href="/content/turnen/nieuws/54-druturnia-succesvol-bij-regiofinales-in-de-4e-divisie" title="Druturnia succesvol bij regiofinales in de 4e divisie">Druturnia succesvol bij regiofinales in de 4e divisie</a></li>
<li><a href="/content/turnen/nieuws/53-druturnia-op-3-fronten-goed-bezig" title="Druturnia op 3 fronten goed bezig">Druturnia op 3 fronten goed bezig</a></li>
<li><a href="/content/turnen/nieuws/52-alle-turndames-door-naar-de-4e-divisie-regiofinale" title="Alle turndames door naar de 4e divisie regiofinale">Alle turndames door naar de 4e divisie regiofinale</a></li>
<li><a href="/content/turnen/nieuws/51-tumblingbaan-dankzij-actie" title="Tumblingbaan dankzij actie">Tumblingbaan dankzij actie</a></li>
<li><a href="/content/turnen/nieuws/50-pietengym-voor-druturnia-leden" title="Pietengym voor Druturnia-leden">Pietengym voor Druturnia-leden</a></li>
<li><a href="/content/turnen/nieuws/41-eveline-van-de-werf-tweede-in-de-turnfinale-in-rheden" title="Eveline van de Werf tweede in de turnfinale in Rheden">Eveline van de Werf tweede in de turnfinale in Rheden</a></li>
<li><a href="/content/turnen/nieuws/39-druturnia-haalt-medailles-alsof-het-niets-is" title="Druturnia haalt medailles alsof het niets is">Druturnia haalt medailles alsof het niets is</a></li>
<li><a href="/content/turnen/nieuws/38-finale-afvaardiging-van-5-druturnia-dames" title="Finale afvaardiging van 5 Druturnia dames">Finale afvaardiging van 5 Druturnia dames</a></li>
<li><a href="/content/turnen/nieuws/37-druturnia-geeft-visitekaartje-af" title="Druturnia geeft visitekaartje af">Druturnia geeft visitekaartje af</a></li>
<li><a href="/content/turnen/nieuws/36-weer-goede-turnprestaties-druturnia" title="Weer goede turnprestaties Druturnia">Weer goede turnprestaties Druturnia</a></li>
<li><a href="/content/turnen/nieuws/35-onze-wedstrijdturnsters-in-doetinchem" title="Onze wedstrijdturnsters in Doetinchem">Onze wedstrijdturnsters in Doetinchem</a></li>
<li><a href="/content/turnen/nieuws/34-recreantenmeiden-in-dodewaard" title="Recreantenmeiden in Dodewaard">Recreantenmeiden in Dodewaard</a></li>
<li><a href="/content/turnen/nieuws/33-opheusden-15-januari-groep-3" title="Opheusden, 15 januari - Groep 3">Opheusden, 15 januari - Groep 3</a></li>
<li><a href="/content/turnen/nieuws/30-gym-doe-dag-in-zetten" title="Gym Doe Dag in Zetten">Gym Doe Dag in Zetten</a></li>
<li><a href="/content/turnen/nieuws/29-eerste-toernooi-van-het-seizoen-voor-druturnia-turnsters" title="Eerste toernooi van het seizoen voor Druturnia turn(st)ers.">Eerste toernooi van het seizoen voor Druturnia turn(st)ers.</a></li>
<li><a href="/content/turnen/nieuws/26-clubkampioenschappen-turnen-2004" title="Clubkampioenschappen Turnen 2004">Clubkampioenschappen Turnen 2004</a></li>
<li><a href="/content/turnen/nieuws/22-recreanten-springtoernooi-in-ochten" title="Recreanten springtoernooi in Ochten">Recreanten springtoernooi in Ochten</a></li>
<li><a href="/content/turnen/nieuws/21-gesponsorde-rugtassen-ims-heftrucks-en-tms-heftrucks" title="Gesponsorde rugtassen I.M.S. Heftrucks en T.M.S. Heftrucks">Gesponsorde rugtassen I.M.S. Heftrucks en T.M.S. Heftrucks</a></li>
<li><a href="/content/turnen/nieuws/20-druturnia-met-2-turnsters-door-naar-de-districtsfinale-27-maart-2004-in-vries" title="Druturnia met 2 turnsters door naar de districtsfinale 27 maart 2004 in Vries">Druturnia met 2 turnsters door naar de districtsfinale 27 maart 2004 in Vries</a></li>
<li><a href="/content/turnen/nieuws/18-uit-de-waalkanter-qdruturnia-recreanten-laten-zich-niet-kennenq" title="Uit de Waalkanter: &quot;Druturnia recreanten laten zich niet kennen&quot;">Uit de Waalkanter: &quot;Druturnia recreanten laten zich niet kennen&quot;</a></li>
<li><a href="/content/turnen/nieuws/16-pietengym-op-29-november-2003" title="Pietengym op 29 november 2003">Pietengym op 29 november 2003</a></li>
<li><a href="/content/turnen/nieuws/4-gym-doe-dag" title="Gym Doe Dag">Gym Doe Dag</a></li>
<li><a href="/content/turnen/nieuws/2-sponsoren-voor-wedstrijdturn-groepen" title="Sponsoren voor wedstrijdturn-groepen">Sponsoren voor wedstrijdturn-groepen</a></li>
</ul>
</li><li><a href="/content/nieuws/laatste-nieuws/6-overig" title="Overig">Overig</a>
<ul class="level_3">
<li><a href="/content/nieuws/laatste-nieuws/6-overig/246-druturnia-clubkampioenschappen-en-dope-dance-award" title="Druturnia Clubkampioenschappen en DOPE Dance award">Druturnia Clubkampioenschappen en DOPE Dance award</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/224-steun" title="(S)teun">(S)teun</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/210-lekker-meeturnen-en-dansen-bij-druturnia" title="Lekker meeturnen en dansen bij Druturnia">Lekker meeturnen en dansen bij Druturnia</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/208-druturnia-zoekt-bestuursleden" title="Druturnia zoekt bestuursleden">Druturnia zoekt bestuursleden</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/203-druturnia-clubdag-2009" title="Druturnia Clubdag 2009">Druturnia Clubdag 2009</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/202-aankondiging-druturnia-clubdag-12-juli-2009" title="Aankondiging: Druturnia Clubdag 12 juli 2009">Aankondiging: Druturnia Clubdag 12 juli 2009</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/163-jeugdcommissie-aan-de-slag" title="Jeugdcommissie aan de slag">Jeugdcommissie aan de slag</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/158-zwemfestijn" title="Spetterend zwemfestijn">Spetterend zwemfestijn</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/149-spitter-spetter-spater-lekker-in-het-water" title="SPITTER SPETTER SPATER, lekker in het water…">SPITTER SPETTER SPATER, lekker in het water…</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/140-druturnia-site-gepimpt" title="Druturnia-site gepimpt">Druturnia-site gepimpt</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/106-nieuwjaarswens" title="Nieuwjaarswens">Nieuwjaarswens</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/101-kijk-en-meedoelessen-dansen-en-turnen" title="Kijk- en meedoelessen dansen en turnen">Kijk- en meedoelessen dansen en turnen</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/100-uit-de-waalkanter-van-16-juli-2008" title="Uit de Waalkanter van 16 juli 2008:">Uit de Waalkanter van 16 juli 2008:</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/93-doorsparen-bij-plus-gubbels" title="Doorsparen bij Plus Gubbels">Doorsparen bij Plus Gubbels</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/92-sponsoractie-bij-plus-gubbels-in-druten" title="Sponsoractie bij Plus Gubbels in Druten">Sponsoractie bij Plus Gubbels in Druten</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/90-uitnodiging-jaarvergadering" title="Uitnodiging jaarvergadering">Uitnodiging jaarvergadering</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/91-discozwemparty-groot-succes" title="Discozwemparty groot succes">Discozwemparty groot succes</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/89-een-spetterende-dag-met-druturnia" title="Een spetterende dag met Druturnia">Een spetterende dag met Druturnia</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/88-happy-newyear" title="Happy newyear!">Happy newyear!</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/81-actief-weekend-voor-druturnia" title="Actief weekend voor Druturnia">Actief weekend voor Druturnia</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/80-einde-zomervakantie" title="Einde zomervakantie">Einde zomervakantie</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/79-druturnia-schittert-op-vlaggenparade" title="Druturnia schittert op Vlaggenparade!">Druturnia schittert op Vlaggenparade!</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/78-zomervakantie-en-vlaggenparade" title="Zomervakantie en vlaggenparade">Zomervakantie en vlaggenparade</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/74-clubdag-druturnia-groot-succes" title="Clubdag Druturnia groot succes!">Clubdag Druturnia groot succes!</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/72-aankondiging-clubdag-druturnia" title="Aankondiging Clubdag Druturnia">Aankondiging Clubdag Druturnia</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/68-girlsnight-en-afternoonparty" title="Girlsnight en afternoonparty">Girlsnight en afternoonparty</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/67-floortje-bevallen-van-een-zoon" title="Floortje bevallen van een zoon">Floortje bevallen van een zoon</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/59-nieuw-seizoen-van-start" title="Nieuw seizoen van start">Nieuw seizoen van start</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/57-girls-night-voor-herhaling-vatbaar" title="Girls Night voor herhaling vatbaar?">Girls Night voor herhaling vatbaar?</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/49-hij-komt-hij-komt-die-lieve-goede-sint" title="Hij komt, hij komt, die lieve goede Sint...">Hij komt, hij komt, die lieve goede Sint...</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/48-drukke-tijden-breken-aan" title="Drukke tijden breken aan">Drukke tijden breken aan</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/46-frisse-start" title="Frisse start">Frisse start</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/45-zomervakantie" title="Zomervakantie">Zomervakantie</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/43-druturnia-promotiemiddag" title="Druturnia Promotiemiddag">Druturnia Promotiemiddag</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/40-vossenjacht" title="Vossenjacht">Vossenjacht</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/32-al-het-goede-gewenst-voor-2005" title="Al het goede gewenst voor 2005">Al het goede gewenst voor 2005</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/31-fijne-kerstdagen-en-een-gelukkig-2005" title="Fijne Kerstdagen en een Gelukkig 2005!">Fijne Kerstdagen en een Gelukkig 2005!</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/27-uitmarkt-2004" title="Uitmarkt 2004">Uitmarkt 2004</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/23-uitslag-van-de-loterij-28-maart-2004" title="Uitslag van de loterij 28 maart 2004">Uitslag van de loterij 28 maart 2004</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/17-wij-wensen-jullie-allen-een-sportief-en-gezond-2004-toe" title="Wij wensen jullie allen een sportief en gezond 2004 toe">Wij wensen jullie allen een sportief en gezond 2004 toe</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/3-winnaars-kleurwedstrijd-uit-nieuwsbrief" title="Winnaars kleurwedstrijd uit Nieuwsbrief">Winnaars kleurwedstrijd uit Nieuwsbrief</a></li>
</ul>
</li><li><a href="/content/dans/nieuws" title="Dans">Dans</a>
<ul class="level_3">
<li><a href="/content/dans/nieuws/241-geweldig-resultaat-voor-druturnia-op-nk-in-mill-" title="Geweldig resultaat voor Druturnia op NK in Mill ">Geweldig resultaat voor Druturnia op NK in Mill </a></li>
<li><a href="/content/dans/nieuws/240-uitnodiging-dansvoorstelling-druturnia" title="Uitnodiging Dansvoorstelling Druturnia">Uitnodiging Dansvoorstelling Druturnia</a></li>
<li><a href="/content/dans/nieuws/220-druturnia-scoort-in-zierikzee" title="Druturnia scoort in Zierikzee">Druturnia scoort in Zierikzee</a></li>
<li><a href="/content/dans/nieuws/216-druturnias-definition-of-dance-naar-het-wereldkampioenschap-showdance" title="Druturnia’s Definition of Dance naar het Wereldkampioenschap Showdance!">Druturnia’s Definition of Dance naar het Wereldkampioenschap Showdance!</a></li>
<li><a href="/content/dans/nieuws/215-toch-een-beker-voor-druturnia" title="Toch een beker voor Druturnia!">Toch een beker voor Druturnia!</a></li>
<li><a href="/content/dans/nieuws/214-uit-de-waalkanter" title="Uit de waalkanter">Uit de waalkanter</a></li>
<li><a href="/content/dans/nieuws/211-definition-of-dance-2de-plaats-op-nk-showdance" title="Definition of Dance 2de plaats op NK Showdance">Definition of Dance 2de plaats op NK Showdance</a></li>
<li><a href="/content/dans/nieuws/194-druturnia-laat-danssporen-achter-in-putten" title="Druturnia laat danssporen achter in Putten">Druturnia laat danssporen achter in Putten</a></li>
<li><a href="/content/dans/nieuws/115-druturnia-in-actie-op-het-open-nk-streetdancehip-hop-in-mill" title="Druturnia in actie op het Open NK Streetdance/Hip Hop in Mill">Druturnia in actie op het Open NK Streetdance/Hip Hop in Mill</a></li>
<li><a href="/content/dans/nieuws/108-streetdemo" title="Streetdemo">Streetdemo</a></li>
<li><a href="/content/dans/nieuws/84-definition-of-dance" title="Definition of dance!">Definition of dance!</a></li>
<li><a href="/content/dans/nieuws/71-demogyjada-in-apeldoorn" title="Demogyjada in Apeldoorn">Demogyjada in Apeldoorn</a></li>
<li><a href="/content/dans/nieuws/58-de-jazztak-van-druturnia-scoort-ook" title="De Jazztak van Druturnia scoort ook!">De Jazztak van Druturnia scoort ook!</a></li>
<li><a href="/content/dans/nieuws/55-helaas-dit-seizoen-geen-jazzvoorstelling" title="Helaas, dit seizoen geen jazzvoorstelling…">Helaas, dit seizoen geen jazzvoorstelling…</a></li>
<li><a href="/content/dans/nieuws/47-dvd-neverending-" title="DVD Neverending …">DVD Neverending …</a></li>
<li><a href="/content/dans/nieuws/44-de-neverending-story-of-dance" title="De “Neverending story of dance”">De “Neverending story of dance”</a></li>
<li><a href="/content/dans/nieuws/42-jaarlijkse-jazzdance-voorstelling-in-dn-bogerd" title="Jaarlijkse Jazzdance voorstelling in d’n Bogerd">Jaarlijkse Jazzdance voorstelling in d’n Bogerd</a></li>
<li><a href="/content/dans/nieuws/28-streetdance" title="Streetdance">Streetdance</a></li>
<li><a href="/content/dans/nieuws/25-dvdvideo-en-foto-cd-rom-van-hollywood" title="DVD/Video en foto cd-rom van Hollywood">DVD/Video en foto cd-rom van Hollywood</a></li>
<li><a href="/content/dans/nieuws/24-hollywood-spektakel-inspireert-30-plussers" title="Hollywood spektakel inspireert 30-plussers?!?">Hollywood spektakel inspireert 30-plussers?!?</a></li>
<li><a href="/content/dans/nieuws/19-definition-of-dance-op-weg-naar-dn-bogerd" title="Definition of Dance op weg naar d’n Bogerd">Definition of Dance op weg naar d’n Bogerd</a></li>
<li><a href="/content/dans/nieuws/1-demo-en-workshop-deester-feestweek" title="Demo en Workshop Deester Feestweek">Demo en Workshop Deester Feestweek</a></li>
</ul>
</li></ul>
</li><li><a href="/content/nieuws/nieuws-per-onderwerp" title="Nieuws per onderwerp">Nieuws per onderwerp</a>
<ul class="level_2">
<li><a href="/content/turnen/nieuws" title="Turnen">Turnen</a>
<ul class="level_3">
<li><a href="/content/turnen/nieuws/243-sportieve-workshops-en-bbq" title="Sportieve Workshops en BBQ">Sportieve Workshops en BBQ</a></li>
<li><a href="/content/turnen/nieuws/242-29-mei-2010-finale-van-de-6e-divisie" title="29 mei 2010 finale van de 6e divisie">29 mei 2010 finale van de 6e divisie</a></li>
<li><a href="/content/turnen/nieuws/235-nk-turnen-24-april" title="NK turnen 24 april">NK turnen 24 april</a></li>
<li><a href="/content/turnen/nieuws/234-de-regiofinale-in-doetinchem-17-april-2010" title="De regiofinale in Doetinchem, 17 april 2010">De regiofinale in Doetinchem, 17 april 2010</a></li>
<li><a href="/content/turnen/nieuws/247-wedstrijd-7e-divisie-en-pre-instappers-12-juni-2010" title="Wedstrijd 7e divisie en pre-instappers 12 juni 2010">Wedstrijd 7e divisie en pre-instappers 12 juni 2010</a></li>
<li><a href="/content/turnen/nieuws/233-6e-divisie-10-april" title="6e divisie 10 april">6e divisie 10 april</a></li>
<li><a href="/content/turnen/nieuws/232-regiofinale-4e-divisie-17-april" title="Regiofinale 4e divisie 17 april">Regiofinale 4e divisie 17 april</a></li>
<li><a href="/content/turnen/nieuws/231-7e-divisie-1e-wedstrijd-27-maart" title="7e divisie 1e wedstrijd 27 maart">7e divisie 1e wedstrijd 27 maart</a></li>
<li><a href="/content/turnen/nieuws/230-2-druturnia-meiden-4e-divisie-in-de-prijzen" title="2 Druturnia meiden 4e divisie in de prijzen!">2 Druturnia meiden 4e divisie in de prijzen!</a></li>
<li><a href="/content/turnen/nieuws/226-leuke-wedstrijd-met-goed-resultaat" title="Leuke wedstrijd, met goed resultaat!">Leuke wedstrijd, met goed resultaat!</a></li>
<li><a href="/content/turnen/nieuws/225-druturnia-turnsters-3e-divisie-allemaal-door-naar-regio-finale" title="Druturnia turnsters 3e divisie allemaal door naar regio finale!!">Druturnia turnsters 3e divisie allemaal door naar regio finale!!</a></li>
<li><a href="/content/turnen/nieuws/222-verslag-2e-plaatsingswedstrijd-4e-divisie-nijmegen" title="Verslag 2e plaatsingswedstrijd 4e divisie Nijmegen">Verslag 2e plaatsingswedstrijd 4e divisie Nijmegen</a></li>
<li><a href="/content/turnen/nieuws/221-een-zilveren-medaille-voor-fleur-sluijs" title="Een zilveren medaille voor Fleur Sluijs">Een zilveren medaille voor Fleur Sluijs</a></li>
<li><a href="/content/turnen/nieuws/219-samenvatting-1e-plaatsingswedstrijd-3e-divisie-19-12-2009" title="Samenvatting: 1e plaatsingswedstrijd 3e divisie 19-12-2009.">Samenvatting: 1e plaatsingswedstrijd 3e divisie 19-12-2009.</a></li>
<li><a href="/content/turnen/nieuws/218-succesvolle-instuif" title="Succesvolle instuif">Succesvolle instuif</a></li>
<li><a href="/content/turnen/nieuws/217-prima-resultaat-druturnia-op-wedstrijd-nijmegen" title="Prima resultaat Druturnia op wedstrijd Nijmegen">Prima resultaat Druturnia op wedstrijd Nijmegen</a></li>
<li><a href="/content/turnen/nieuws/213-druturnia-heeft-er-weer-2-nieuwe-assistentes-bij" title="Druturnia heeft er weer 2 nieuwe assistentes bij.">Druturnia heeft er weer 2 nieuwe assistentes bij.</a></li>
<li><a href="/content/turnen/nieuws/199-toestelkampioenschappen-in-doetinchem" title="Toestelkampioenschappen in Doetinchem">Toestelkampioenschappen in Doetinchem</a></li>
<li><a href="/content/turnen/nieuws/198-selectietraining-voor-plaats-in-selectiegroepen-turnen-" title="Selectietraining voor plaats in Selectiegroepen turnen ">Selectietraining voor plaats in Selectiegroepen turnen </a></li>
<li><a href="/content/turnen/nieuws/196-finale-van-de-5e-divisie-turnen-in-lelystad" title="Finale van de 5e divisie turnen in Lelystad">Finale van de 5e divisie turnen in Lelystad</a></li>
<li><a href="/content/turnen/nieuws/193-floortje-bevallen-van-tweede-zoon" title="Floortje bevallen van tweede zoon">Floortje bevallen van tweede zoon</a></li>
<li><a href="/content/turnen/nieuws/176-dertien-medailles-in-opheusden" title="Dertien medailles in Opheusden">Dertien medailles in Opheusden</a></li>
<li><a href="/content/turnen/nieuws/173-druturnia-heeft-9-nieuwe-assistent-leiders-erbij-gekregen" title="Druturnia heeft 9 nieuwe Assistent Leiders erbij gekregen!">Druturnia heeft 9 nieuwe Assistent Leiders erbij gekregen!</a></li>
<li><a href="/content/turnen/nieuws/164-top-prestaties-druturnia" title="Top prestaties Druturnia!!!">Top prestaties Druturnia!!!</a></li>
<li><a href="/content/turnen/nieuws/155-assistentencursus-2-praktijkdag" title="Assistentencursus 2 praktijkdag in De Lier in Puiflijk">Assistentencursus 2 praktijkdag in De Lier in Puiflijk</a></li>
<li><a href="/content/turnen/nieuws/148-wedstrijdverslag-pre-instap-en-7e-divisie" title="Wedstrijdverslag Pre Instap en 7e divisie">Wedstrijdverslag Pre Instap en 7e divisie</a></li>
<li><a href="/content/turnen/nieuws/156-berichtje-van-madelon" title="Berichtje van Madelon">Berichtje van Madelon</a></li>
<li><a href="/content/turnen/nieuws/139-jongens-zetten-beste-beentje-voor-in-hellendoorn" title="Jongens zetten beste beentje voor in Hellendoorn">Jongens zetten beste beentje voor in Hellendoorn</a></li>
<li><a href="/content/turnen/nieuws/128-3-meiden-door-naar-de-landelijke-finale" title="3 meiden door naar de landelijke finale!">3 meiden door naar de landelijke finale!</a></li>
<li><a href="/content/turnen/nieuws/122-druturnia-succesvol-tijdens-regiofinale-4e-divisie" title="Druturnia succesvol tijdens regiofinale 4e divisie!">Druturnia succesvol tijdens regiofinale 4e divisie!</a></li>
<li><a href="/content/turnen/nieuws/114-super-prestatie-voor-3e-divisie" title="Super prestatie voor 3e divisie">Super prestatie voor 3e divisie</a></li>
<li><a href="/content/turnen/nieuws/111-geslaagd-voor-de-jurycursus" title="Geslaagd voor de jurycursus">Geslaagd voor de jurycursus</a></li>
<li><a href="/content/turnen/nieuws/110-jongens-druturnia-goed-van-start" title="Jongens Druturnia goed van start">Jongens Druturnia goed van start</a></li>
<li><a href="/content/turnen/nieuws/109-druturnia-heeft-weer-succes-in-4e-divisie-" title="Druturnia heeft weer succes in 4e divisie! ">Druturnia heeft weer succes in 4e divisie! </a></li>
<li><a href="/content/turnen/nieuws/107-de-eerste-turnwedstrijd-in-het-nieuwe-seizoen" title="De eerste turnwedstrijd in het nieuwe seizoen!!">De eerste turnwedstrijd in het nieuwe seizoen!!</a></li>
<li><a href="/content/turnen/nieuws/105-druturnia-komt-met-4-medailles-terug-van-de-wedstrijd" title="Druturnia komt met 4 medailles terug van de wedstrijd">Druturnia komt met 4 medailles terug van de wedstrijd</a></li>
<li><a href="/content/turnen/nieuws/104-doldwaze-pietengym" title="Doldwaze Pietengym">Doldwaze Pietengym</a></li>
<li><a href="/content/turnen/nieuws/103-sportieve-zaterdag-voor-druturnia" title="Sportieve zaterdag voor Druturnia">Sportieve zaterdag voor Druturnia</a></li>
<li><a href="/content/turnen/nieuws/102-pietengym-2008" title="Pietengym 2008">Pietengym 2008</a></li>
<li><a href="/content/turnen/nieuws/99-succesvol-jaar-druturnia" title="Succesvol jaar Druturnia">Succesvol jaar Druturnia</a></li>
<li><a href="/content/turnen/nieuws/98-nieuwe-assistentes" title="Nieuwe assistentes">Nieuwe assistentes</a></li>
<li><a href="/content/turnen/nieuws/97-druturnia-jongens-succesvol-tijdens-finale-district-oost" title="Druturnia jongens succesvol tijdens Finale District Oost!">Druturnia jongens succesvol tijdens Finale District Oost!</a></li>
<li><a href="/content/turnen/nieuws/96-druturnia-in-de-waalkanter" title="Druturnia in de Waalkanter">Druturnia in de Waalkanter</a></li>
<li><a href="/content/turnen/nieuws/95-clubkampioenschappen-druturnia-groot-succes" title="Clubkampioenschappen Druturnia groot succes">Clubkampioenschappen Druturnia groot succes</a></li>
<li><a href="/content/turnen/nieuws/94-weer-medailles-voor-jongens-druturnia" title="Weer medailles voor jongens Druturnia">Weer medailles voor jongens Druturnia</a></li>
<li><a href="/content/turnen/nieuws/87-druturnia-op-clubteamwedstrijd" title="Druturnia op Clubteamwedstrijd">Druturnia op Clubteamwedstrijd</a></li>
<li><a href="/content/turnen/nieuws/86-pietengym-veel-nieuwe-pieten-bij-druturnia" title="Pietengym: Veel nieuwe Pieten bij Druturnia">Pietengym: Veel nieuwe Pieten bij Druturnia</a></li>
<li><a href="/content/turnen/nieuws/85-doldwaze-pietengym" title="Doldwaze Pietengym!!">Doldwaze Pietengym!!</a></li>
<li><a href="/content/turnen/nieuws/83-5-prijswinnaars-druturnia-op-springtoernooi" title="5 prijswinnaars Druturnia op Springtoernooi">5 prijswinnaars Druturnia op Springtoernooi</a></li>
<li><a href="/content/turnen/nieuws/82-springtoernooi-in-ochten" title="Springtoernooi in Ochten">Springtoernooi in Ochten</a></li>
<li><a href="/content/turnen/nieuws/76-districtfinale-4e-divisie" title="Districtfinale 4e divisie">Districtfinale 4e divisie</a></li>
<li><a href="/content/turnen/nieuws/77-zaterdag-14-april-landelijke-finale-te-franeker" title="Zaterdag 14 april: Landelijke finale te Franeker">Zaterdag 14 april: Landelijke finale te Franeker</a></li>
<li><a href="/content/turnen/nieuws/75-verslag-wedstrijd-7e-divisie" title="Verslag wedstrijd 7e divisie">Verslag wedstrijd 7e divisie</a></li>
<li><a href="/content/turnen/nieuws/73-succes-in-de-6de-divisie" title="Succes in de 6de divisie">Succes in de 6de divisie</a></li>
<li><a href="/content/turnen/nieuws/70-en-de-wedstrijden-gaan-maar-door" title="En de wedstrijden gaan maar door!">En de wedstrijden gaan maar door!</a></li>
<li><a href="/content/turnen/nieuws/69-goed-begin-van-het-jaar-voor-druturnia" title="Goed begin van het jaar voor Druturnia!">Goed begin van het jaar voor Druturnia!</a></li>
<li><a href="/content/turnen/nieuws/66-goud-voor-roos-smits" title="Goud voor Roos Smits">Goud voor Roos Smits</a></li>
<li><a href="/content/turnen/nieuws/65-2e-wedstrijd-4e-divisie-weer-een-succes" title="2e wedstrijd 4e divisie weer een succes">2e wedstrijd 4e divisie weer een succes</a></li>
<li><a href="/content/turnen/nieuws/64-goede-wedstrijdprestaties-druturnia" title="Goede wedstrijdprestaties Druturnia">Goede wedstrijdprestaties Druturnia</a></li>
<li><a href="/content/turnen/nieuws/63-eerste-wedstrijd-van-het-seizoen-2-medailles" title="Eerste wedstrijd van het seizoen, 2 medailles!!">Eerste wedstrijd van het seizoen, 2 medailles!!</a></li>
<li><a href="/content/turnen/nieuws/62-een-dolle-pietenboel" title="Een dolle pietenboel">Een dolle pietenboel</a></li>
<li><a href="/content/turnen/nieuws/61-pietengym-2006" title="Pietengym 2006">Pietengym 2006</a></li>
<li><a href="/content/turnen/nieuws/60-gym-doe-dag-2006" title="Gym Doe Dag 2006">Gym Doe Dag 2006</a></li>
<li><a href="/content/turnen/nieuws/56-plaatsingswedstrijden-enschede-en-doetinchem" title="Plaatsingswedstrijden Enschede en Doetinchem">Plaatsingswedstrijden Enschede en Doetinchem</a></li>
<li><a href="/content/turnen/nieuws/54-druturnia-succesvol-bij-regiofinales-in-de-4e-divisie" title="Druturnia succesvol bij regiofinales in de 4e divisie">Druturnia succesvol bij regiofinales in de 4e divisie</a></li>
<li><a href="/content/turnen/nieuws/53-druturnia-op-3-fronten-goed-bezig" title="Druturnia op 3 fronten goed bezig">Druturnia op 3 fronten goed bezig</a></li>
<li><a href="/content/turnen/nieuws/52-alle-turndames-door-naar-de-4e-divisie-regiofinale" title="Alle turndames door naar de 4e divisie regiofinale">Alle turndames door naar de 4e divisie regiofinale</a></li>
<li><a href="/content/turnen/nieuws/51-tumblingbaan-dankzij-actie" title="Tumblingbaan dankzij actie">Tumblingbaan dankzij actie</a></li>
<li><a href="/content/turnen/nieuws/50-pietengym-voor-druturnia-leden" title="Pietengym voor Druturnia-leden">Pietengym voor Druturnia-leden</a></li>
<li><a href="/content/turnen/nieuws/41-eveline-van-de-werf-tweede-in-de-turnfinale-in-rheden" title="Eveline van de Werf tweede in de turnfinale in Rheden">Eveline van de Werf tweede in de turnfinale in Rheden</a></li>
<li><a href="/content/turnen/nieuws/39-druturnia-haalt-medailles-alsof-het-niets-is" title="Druturnia haalt medailles alsof het niets is">Druturnia haalt medailles alsof het niets is</a></li>
<li><a href="/content/turnen/nieuws/38-finale-afvaardiging-van-5-druturnia-dames" title="Finale afvaardiging van 5 Druturnia dames">Finale afvaardiging van 5 Druturnia dames</a></li>
<li><a href="/content/turnen/nieuws/37-druturnia-geeft-visitekaartje-af" title="Druturnia geeft visitekaartje af">Druturnia geeft visitekaartje af</a></li>
<li><a href="/content/turnen/nieuws/36-weer-goede-turnprestaties-druturnia" title="Weer goede turnprestaties Druturnia">Weer goede turnprestaties Druturnia</a></li>
<li><a href="/content/turnen/nieuws/35-onze-wedstrijdturnsters-in-doetinchem" title="Onze wedstrijdturnsters in Doetinchem">Onze wedstrijdturnsters in Doetinchem</a></li>
<li><a href="/content/turnen/nieuws/34-recreantenmeiden-in-dodewaard" title="Recreantenmeiden in Dodewaard">Recreantenmeiden in Dodewaard</a></li>
<li><a href="/content/turnen/nieuws/33-opheusden-15-januari-groep-3" title="Opheusden, 15 januari - Groep 3">Opheusden, 15 januari - Groep 3</a></li>
<li><a href="/content/turnen/nieuws/30-gym-doe-dag-in-zetten" title="Gym Doe Dag in Zetten">Gym Doe Dag in Zetten</a></li>
<li><a href="/content/turnen/nieuws/29-eerste-toernooi-van-het-seizoen-voor-druturnia-turnsters" title="Eerste toernooi van het seizoen voor Druturnia turn(st)ers.">Eerste toernooi van het seizoen voor Druturnia turn(st)ers.</a></li>
<li><a href="/content/turnen/nieuws/26-clubkampioenschappen-turnen-2004" title="Clubkampioenschappen Turnen 2004">Clubkampioenschappen Turnen 2004</a></li>
<li><a href="/content/turnen/nieuws/22-recreanten-springtoernooi-in-ochten" title="Recreanten springtoernooi in Ochten">Recreanten springtoernooi in Ochten</a></li>
<li><a href="/content/turnen/nieuws/21-gesponsorde-rugtassen-ims-heftrucks-en-tms-heftrucks" title="Gesponsorde rugtassen I.M.S. Heftrucks en T.M.S. Heftrucks">Gesponsorde rugtassen I.M.S. Heftrucks en T.M.S. Heftrucks</a></li>
<li><a href="/content/turnen/nieuws/20-druturnia-met-2-turnsters-door-naar-de-districtsfinale-27-maart-2004-in-vries" title="Druturnia met 2 turnsters door naar de districtsfinale 27 maart 2004 in Vries">Druturnia met 2 turnsters door naar de districtsfinale 27 maart 2004 in Vries</a></li>
<li><a href="/content/turnen/nieuws/18-uit-de-waalkanter-qdruturnia-recreanten-laten-zich-niet-kennenq" title="Uit de Waalkanter: &quot;Druturnia recreanten laten zich niet kennen&quot;">Uit de Waalkanter: &quot;Druturnia recreanten laten zich niet kennen&quot;</a></li>
<li><a href="/content/turnen/nieuws/16-pietengym-op-29-november-2003" title="Pietengym op 29 november 2003">Pietengym op 29 november 2003</a></li>
<li><a href="/content/turnen/nieuws/4-gym-doe-dag" title="Gym Doe Dag">Gym Doe Dag</a></li>
<li><a href="/content/turnen/nieuws/2-sponsoren-voor-wedstrijdturn-groepen" title="Sponsoren voor wedstrijdturn-groepen">Sponsoren voor wedstrijdturn-groepen</a></li>
</ul>
</li><li><a href="/content/nieuws/laatste-nieuws/6-overig" title="Overig">Overig</a>
<ul class="level_3">
<li><a href="/content/nieuws/laatste-nieuws/6-overig/246-druturnia-clubkampioenschappen-en-dope-dance-award" title="Druturnia Clubkampioenschappen en DOPE Dance award">Druturnia Clubkampioenschappen en DOPE Dance award</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/224-steun" title="(S)teun">(S)teun</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/210-lekker-meeturnen-en-dansen-bij-druturnia" title="Lekker meeturnen en dansen bij Druturnia">Lekker meeturnen en dansen bij Druturnia</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/208-druturnia-zoekt-bestuursleden" title="Druturnia zoekt bestuursleden">Druturnia zoekt bestuursleden</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/203-druturnia-clubdag-2009" title="Druturnia Clubdag 2009">Druturnia Clubdag 2009</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/202-aankondiging-druturnia-clubdag-12-juli-2009" title="Aankondiging: Druturnia Clubdag 12 juli 2009">Aankondiging: Druturnia Clubdag 12 juli 2009</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/163-jeugdcommissie-aan-de-slag" title="Jeugdcommissie aan de slag">Jeugdcommissie aan de slag</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/158-zwemfestijn" title="Spetterend zwemfestijn">Spetterend zwemfestijn</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/149-spitter-spetter-spater-lekker-in-het-water" title="SPITTER SPETTER SPATER, lekker in het water…">SPITTER SPETTER SPATER, lekker in het water…</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/140-druturnia-site-gepimpt" title="Druturnia-site gepimpt">Druturnia-site gepimpt</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/106-nieuwjaarswens" title="Nieuwjaarswens">Nieuwjaarswens</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/101-kijk-en-meedoelessen-dansen-en-turnen" title="Kijk- en meedoelessen dansen en turnen">Kijk- en meedoelessen dansen en turnen</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/100-uit-de-waalkanter-van-16-juli-2008" title="Uit de Waalkanter van 16 juli 2008:">Uit de Waalkanter van 16 juli 2008:</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/93-doorsparen-bij-plus-gubbels" title="Doorsparen bij Plus Gubbels">Doorsparen bij Plus Gubbels</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/92-sponsoractie-bij-plus-gubbels-in-druten" title="Sponsoractie bij Plus Gubbels in Druten">Sponsoractie bij Plus Gubbels in Druten</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/90-uitnodiging-jaarvergadering" title="Uitnodiging jaarvergadering">Uitnodiging jaarvergadering</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/91-discozwemparty-groot-succes" title="Discozwemparty groot succes">Discozwemparty groot succes</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/89-een-spetterende-dag-met-druturnia" title="Een spetterende dag met Druturnia">Een spetterende dag met Druturnia</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/88-happy-newyear" title="Happy newyear!">Happy newyear!</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/81-actief-weekend-voor-druturnia" title="Actief weekend voor Druturnia">Actief weekend voor Druturnia</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/80-einde-zomervakantie" title="Einde zomervakantie">Einde zomervakantie</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/79-druturnia-schittert-op-vlaggenparade" title="Druturnia schittert op Vlaggenparade!">Druturnia schittert op Vlaggenparade!</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/78-zomervakantie-en-vlaggenparade" title="Zomervakantie en vlaggenparade">Zomervakantie en vlaggenparade</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/74-clubdag-druturnia-groot-succes" title="Clubdag Druturnia groot succes!">Clubdag Druturnia groot succes!</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/72-aankondiging-clubdag-druturnia" title="Aankondiging Clubdag Druturnia">Aankondiging Clubdag Druturnia</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/68-girlsnight-en-afternoonparty" title="Girlsnight en afternoonparty">Girlsnight en afternoonparty</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/67-floortje-bevallen-van-een-zoon" title="Floortje bevallen van een zoon">Floortje bevallen van een zoon</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/59-nieuw-seizoen-van-start" title="Nieuw seizoen van start">Nieuw seizoen van start</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/57-girls-night-voor-herhaling-vatbaar" title="Girls Night voor herhaling vatbaar?">Girls Night voor herhaling vatbaar?</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/49-hij-komt-hij-komt-die-lieve-goede-sint" title="Hij komt, hij komt, die lieve goede Sint...">Hij komt, hij komt, die lieve goede Sint...</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/48-drukke-tijden-breken-aan" title="Drukke tijden breken aan">Drukke tijden breken aan</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/46-frisse-start" title="Frisse start">Frisse start</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/45-zomervakantie" title="Zomervakantie">Zomervakantie</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/43-druturnia-promotiemiddag" title="Druturnia Promotiemiddag">Druturnia Promotiemiddag</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/40-vossenjacht" title="Vossenjacht">Vossenjacht</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/32-al-het-goede-gewenst-voor-2005" title="Al het goede gewenst voor 2005">Al het goede gewenst voor 2005</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/31-fijne-kerstdagen-en-een-gelukkig-2005" title="Fijne Kerstdagen en een Gelukkig 2005!">Fijne Kerstdagen en een Gelukkig 2005!</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/27-uitmarkt-2004" title="Uitmarkt 2004">Uitmarkt 2004</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/23-uitslag-van-de-loterij-28-maart-2004" title="Uitslag van de loterij 28 maart 2004">Uitslag van de loterij 28 maart 2004</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/17-wij-wensen-jullie-allen-een-sportief-en-gezond-2004-toe" title="Wij wensen jullie allen een sportief en gezond 2004 toe">Wij wensen jullie allen een sportief en gezond 2004 toe</a></li>
<li><a href="/content/nieuws/laatste-nieuws/6-overig/3-winnaars-kleurwedstrijd-uit-nieuwsbrief" title="Winnaars kleurwedstrijd uit Nieuwsbrief">Winnaars kleurwedstrijd uit Nieuwsbrief</a></li>
</ul>
</li><li><a href="/content/dans/nieuws" title="Dans">Dans</a>
<ul class="level_3">
<li><a href="/content/dans/nieuws/241-geweldig-resultaat-voor-druturnia-op-nk-in-mill-" title="Geweldig resultaat voor Druturnia op NK in Mill ">Geweldig resultaat voor Druturnia op NK in Mill </a></li>
<li><a href="/content/dans/nieuws/240-uitnodiging-dansvoorstelling-druturnia" title="Uitnodiging Dansvoorstelling Druturnia">Uitnodiging Dansvoorstelling Druturnia</a></li>
<li><a href="/content/dans/nieuws/220-druturnia-scoort-in-zierikzee" title="Druturnia scoort in Zierikzee">Druturnia scoort in Zierikzee</a></li>
<li><a href="/content/dans/nieuws/216-druturnias-definition-of-dance-naar-het-wereldkampioenschap-showdance" title="Druturnia’s Definition of Dance naar het Wereldkampioenschap Showdance!">Druturnia’s Definition of Dance naar het Wereldkampioenschap Showdance!</a></li>
<li><a href="/content/dans/nieuws/215-toch-een-beker-voor-druturnia" title="Toch een beker voor Druturnia!">Toch een beker voor Druturnia!</a></li>
<li><a href="/content/dans/nieuws/214-uit-de-waalkanter" title="Uit de waalkanter">Uit de waalkanter</a></li>
<li><a href="/content/dans/nieuws/211-definition-of-dance-2de-plaats-op-nk-showdance" title="Definition of Dance 2de plaats op NK Showdance">Definition of Dance 2de plaats op NK Showdance</a></li>
<li><a href="/content/dans/nieuws/194-druturnia-laat-danssporen-achter-in-putten" title="Druturnia laat danssporen achter in Putten">Druturnia laat danssporen achter in Putten</a></li>
<li><a href="/content/dans/nieuws/115-druturnia-in-actie-op-het-open-nk-streetdancehip-hop-in-mill" title="Druturnia in actie op het Open NK Streetdance/Hip Hop in Mill">Druturnia in actie op het Open NK Streetdance/Hip Hop in Mill</a></li>
<li><a href="/content/dans/nieuws/108-streetdemo" title="Streetdemo">Streetdemo</a></li>
<li><a href="/content/dans/nieuws/84-definition-of-dance" title="Definition of dance!">Definition of dance!</a></li>
<li><a href="/content/dans/nieuws/71-demogyjada-in-apeldoorn" title="Demogyjada in Apeldoorn">Demogyjada in Apeldoorn</a></li>
<li><a href="/content/dans/nieuws/58-de-jazztak-van-druturnia-scoort-ook" title="De Jazztak van Druturnia scoort ook!">De Jazztak van Druturnia scoort ook!</a></li>
<li><a href="/content/dans/nieuws/55-helaas-dit-seizoen-geen-jazzvoorstelling" title="Helaas, dit seizoen geen jazzvoorstelling…">Helaas, dit seizoen geen jazzvoorstelling…</a></li>
<li><a href="/content/dans/nieuws/47-dvd-neverending-" title="DVD Neverending …">DVD Neverending …</a></li>
<li><a href="/content/dans/nieuws/44-de-neverending-story-of-dance" title="De “Neverending story of dance”">De “Neverending story of dance”</a></li>
<li><a href="/content/dans/nieuws/42-jaarlijkse-jazzdance-voorstelling-in-dn-bogerd" title="Jaarlijkse Jazzdance voorstelling in d’n Bogerd">Jaarlijkse Jazzdance voorstelling in d’n Bogerd</a></li>
<li><a href="/content/dans/nieuws/28-streetdance" title="Streetdance">Streetdance</a></li>
<li><a href="/content/dans/nieuws/25-dvdvideo-en-foto-cd-rom-van-hollywood" title="DVD/Video en foto cd-rom van Hollywood">DVD/Video en foto cd-rom van Hollywood</a></li>
<li><a href="/content/dans/nieuws/24-hollywood-spektakel-inspireert-30-plussers" title="Hollywood spektakel inspireert 30-plussers?!?">Hollywood spektakel inspireert 30-plussers?!?</a></li>
<li><a href="/content/dans/nieuws/19-definition-of-dance-op-weg-naar-dn-bogerd" title="Definition of Dance op weg naar d’n Bogerd">Definition of Dance op weg naar d’n Bogerd</a></li>
<li><a href="/content/dans/nieuws/1-demo-en-workshop-deester-feestweek" title="Demo en Workshop Deester Feestweek">Demo en Workshop Deester Feestweek</a></li>
</ul>
</li></ul>
</li></ul>
</li><li><a href="http://www.druturnia.nl/#" title="Turnen">Turnen</a>
<ul class="level_1">
<li><a href="/content/turnen/introductie" title="Introductie">Introductie</a></li>
<li><a href="/content/turnen/lesrooster" title="Lesrooster">Lesrooster</a></li>
<li><a href="/content/turnen/nieuws" title="Nieuws">Nieuws</a>
<ul class="level_2">
<li><a href="/content/turnen/nieuws/243-sportieve-workshops-en-bbq" title="Sportieve Workshops en BBQ">Sportieve Workshops en BBQ</a></li>
<li><a href="/content/turnen/nieuws/242-29-mei-2010-finale-van-de-6e-divisie" title="29 mei 2010 finale van de 6e divisie">29 mei 2010 finale van de 6e divisie</a></li>
<li><a href="/content/turnen/nieuws/235-nk-turnen-24-april" title="NK turnen 24 april">NK turnen 24 april</a></li>
<li><a href="/content/turnen/nieuws/234-de-regiofinale-in-doetinchem-17-april-2010" title="De regiofinale in Doetinchem, 17 april 2010">De regiofinale in Doetinchem, 17 april 2010</a></li>
<li><a href="/content/turnen/nieuws/247-wedstrijd-7e-divisie-en-pre-instappers-12-juni-2010" title="Wedstrijd 7e divisie en pre-instappers 12 juni 2010">Wedstrijd 7e divisie en pre-instappers 12 juni 2010</a></li>
<li><a href="/content/turnen/nieuws/233-6e-divisie-10-april" title="6e divisie 10 april">6e divisie 10 april</a></li>
<li><a href="/content/turnen/nieuws/232-regiofinale-4e-divisie-17-april" title="Regiofinale 4e divisie 17 april">Regiofinale 4e divisie 17 april</a></li>
<li><a href="/content/turnen/nieuws/231-7e-divisie-1e-wedstrijd-27-maart" title="7e divisie 1e wedstrijd 27 maart">7e divisie 1e wedstrijd 27 maart</a></li>
<li><a href="/content/turnen/nieuws/230-2-druturnia-meiden-4e-divisie-in-de-prijzen" title="2 Druturnia meiden 4e divisie in de prijzen!">2 Druturnia meiden 4e divisie in de prijzen!</a></li>
<li><a href="/content/turnen/nieuws/226-leuke-wedstrijd-met-goed-resultaat" title="Leuke wedstrijd, met goed resultaat!">Leuke wedstrijd, met goed resultaat!</a></li>
<li><a href="/content/turnen/nieuws/225-druturnia-turnsters-3e-divisie-allemaal-door-naar-regio-finale" title="Druturnia turnsters 3e divisie allemaal door naar regio finale!!">Druturnia turnsters 3e divisie allemaal door naar regio finale!!</a></li>
<li><a href="/content/turnen/nieuws/222-verslag-2e-plaatsingswedstrijd-4e-divisie-nijmegen" title="Verslag 2e plaatsingswedstrijd 4e divisie Nijmegen">Verslag 2e plaatsingswedstrijd 4e divisie Nijmegen</a></li>
<li><a href="/content/turnen/nieuws/221-een-zilveren-medaille-voor-fleur-sluijs" title="Een zilveren medaille voor Fleur Sluijs">Een zilveren medaille voor Fleur Sluijs</a></li>
<li><a href="/content/turnen/nieuws/219-samenvatting-1e-plaatsingswedstrijd-3e-divisie-19-12-2009" title="Samenvatting: 1e plaatsingswedstrijd 3e divisie 19-12-2009.">Samenvatting: 1e plaatsingswedstrijd 3e divisie 19-12-2009.</a></li>
<li><a href="/content/turnen/nieuws/218-succesvolle-instuif" title="Succesvolle instuif">Succesvolle instuif</a></li>
<li><a href="/content/turnen/nieuws/217-prima-resultaat-druturnia-op-wedstrijd-nijmegen" title="Prima resultaat Druturnia op wedstrijd Nijmegen">Prima resultaat Druturnia op wedstrijd Nijmegen</a></li>
<li><a href="/content/turnen/nieuws/213-druturnia-heeft-er-weer-2-nieuwe-assistentes-bij" title="Druturnia heeft er weer 2 nieuwe assistentes bij.">Druturnia heeft er weer 2 nieuwe assistentes bij.</a></li>
<li><a href="/content/turnen/nieuws/199-toestelkampioenschappen-in-doetinchem" title="Toestelkampioenschappen in Doetinchem">Toestelkampioenschappen in Doetinchem</a></li>
<li><a href="/content/turnen/nieuws/198-selectietraining-voor-plaats-in-selectiegroepen-turnen-" title="Selectietraining voor plaats in Selectiegroepen turnen ">Selectietraining voor plaats in Selectiegroepen turnen </a></li>
<li><a href="/content/turnen/nieuws/196-finale-van-de-5e-divisie-turnen-in-lelystad" title="Finale van de 5e divisie turnen in Lelystad">Finale van de 5e divisie turnen in Lelystad</a></li>
<li><a href="/content/turnen/nieuws/193-floortje-bevallen-van-tweede-zoon" title="Floortje bevallen van tweede zoon">Floortje bevallen van tweede zoon</a></li>
<li><a href="/content/turnen/nieuws/176-dertien-medailles-in-opheusden" title="Dertien medailles in Opheusden">Dertien medailles in Opheusden</a></li>
<li><a href="/content/turnen/nieuws/173-druturnia-heeft-9-nieuwe-assistent-leiders-erbij-gekregen" title="Druturnia heeft 9 nieuwe Assistent Leiders erbij gekregen!">Druturnia heeft 9 nieuwe Assistent Leiders erbij gekregen!</a></li>
<li><a href="/content/turnen/nieuws/164-top-prestaties-druturnia" title="Top prestaties Druturnia!!!">Top prestaties Druturnia!!!</a></li>
<li><a href="/content/turnen/nieuws/155-assistentencursus-2-praktijkdag" title="Assistentencursus 2 praktijkdag in De Lier in Puiflijk">Assistentencursus 2 praktijkdag in De Lier in Puiflijk</a></li>
<li><a href="/content/turnen/nieuws/148-wedstrijdverslag-pre-instap-en-7e-divisie" title="Wedstrijdverslag Pre Instap en 7e divisie">Wedstrijdverslag Pre Instap en 7e divisie</a></li>
<li><a href="/content/turnen/nieuws/156-berichtje-van-madelon" title="Berichtje van Madelon">Berichtje van Madelon</a></li>
<li><a href="/content/turnen/nieuws/139-jongens-zetten-beste-beentje-voor-in-hellendoorn" title="Jongens zetten beste beentje voor in Hellendoorn">Jongens zetten beste beentje voor in Hellendoorn</a></li>
<li><a href="/content/turnen/nieuws/128-3-meiden-door-naar-de-landelijke-finale" title="3 meiden door naar de landelijke finale!">3 meiden door naar de landelijke finale!</a></li>
<li><a href="/content/turnen/nieuws/122-druturnia-succesvol-tijdens-regiofinale-4e-divisie" title="Druturnia succesvol tijdens regiofinale 4e divisie!">Druturnia succesvol tijdens regiofinale 4e divisie!</a></li>
<li><a href="/content/turnen/nieuws/114-super-prestatie-voor-3e-divisie" title="Super prestatie voor 3e divisie">Super prestatie voor 3e divisie</a></li>
<li><a href="/content/turnen/nieuws/111-geslaagd-voor-de-jurycursus" title="Geslaagd voor de jurycursus">Geslaagd voor de jurycursus</a></li>
<li><a href="/content/turnen/nieuws/110-jongens-druturnia-goed-van-start" title="Jongens Druturnia goed van start">Jongens Druturnia goed van start</a></li>
<li><a href="/content/turnen/nieuws/109-druturnia-heeft-weer-succes-in-4e-divisie-" title="Druturnia heeft weer succes in 4e divisie! ">Druturnia heeft weer succes in 4e divisie! </a></li>
<li><a href="/content/turnen/nieuws/107-de-eerste-turnwedstrijd-in-het-nieuwe-seizoen" title="De eerste turnwedstrijd in het nieuwe seizoen!!">De eerste turnwedstrijd in het nieuwe seizoen!!</a></li>
<li><a href="/content/turnen/nieuws/105-druturnia-komt-met-4-medailles-terug-van-de-wedstrijd" title="Druturnia komt met 4 medailles terug van de wedstrijd">Druturnia komt met 4 medailles terug van de wedstrijd</a></li>
<li><a href="/content/turnen/nieuws/104-doldwaze-pietengym" title="Doldwaze Pietengym">Doldwaze Pietengym</a></li>
<li><a href="/content/turnen/nieuws/103-sportieve-zaterdag-voor-druturnia" title="Sportieve zaterdag voor Druturnia">Sportieve zaterdag voor Druturnia</a></li>
<li><a href="/content/turnen/nieuws/102-pietengym-2008" title="Pietengym 2008">Pietengym 2008</a></li>
<li><a href="/content/turnen/nieuws/99-succesvol-jaar-druturnia" title="Succesvol jaar Druturnia">Succesvol jaar Druturnia</a></li>
<li><a href="/content/turnen/nieuws/98-nieuwe-assistentes" title="Nieuwe assistentes">Nieuwe assistentes</a></li>
<li><a href="/content/turnen/nieuws/97-druturnia-jongens-succesvol-tijdens-finale-district-oost" title="Druturnia jongens succesvol tijdens Finale District Oost!">Druturnia jongens succesvol tijdens Finale District Oost!</a></li>
<li><a href="/content/turnen/nieuws/96-druturnia-in-de-waalkanter" title="Druturnia in de Waalkanter">Druturnia in de Waalkanter</a></li>
<li><a href="/content/turnen/nieuws/95-clubkampioenschappen-druturnia-groot-succes" title="Clubkampioenschappen Druturnia groot succes">Clubkampioenschappen Druturnia groot succes</a></li>
<li><a href="/content/turnen/nieuws/94-weer-medailles-voor-jongens-druturnia" title="Weer medailles voor jongens Druturnia">Weer medailles voor jongens Druturnia</a></li>
<li><a href="/content/turnen/nieuws/87-druturnia-op-clubteamwedstrijd" title="Druturnia op Clubteamwedstrijd">Druturnia op Clubteamwedstrijd</a></li>
<li><a href="/content/turnen/nieuws/86-pietengym-veel-nieuwe-pieten-bij-druturnia" title="Pietengym: Veel nieuwe Pieten bij Druturnia">Pietengym: Veel nieuwe Pieten bij Druturnia</a></li>
<li><a href="/content/turnen/nieuws/85-doldwaze-pietengym" title="Doldwaze Pietengym!!">Doldwaze Pietengym!!</a></li>
<li><a href="/content/turnen/nieuws/83-5-prijswinnaars-druturnia-op-springtoernooi" title="5 prijswinnaars Druturnia op Springtoernooi">5 prijswinnaars Druturnia op Springtoernooi</a></li>
<li><a href="/content/turnen/nieuws/82-springtoernooi-in-ochten" title="Springtoernooi in Ochten">Springtoernooi in Ochten</a></li>
<li><a href="/content/turnen/nieuws/76-districtfinale-4e-divisie" title="Districtfinale 4e divisie">Districtfinale 4e divisie</a></li>
<li><a href="/content/turnen/nieuws/77-zaterdag-14-april-landelijke-finale-te-franeker" title="Zaterdag 14 april: Landelijke finale te Franeker">Zaterdag 14 april: Landelijke finale te Franeker</a></li>
<li><a href="/content/turnen/nieuws/75-verslag-wedstrijd-7e-divisie" title="Verslag wedstrijd 7e divisie">Verslag wedstrijd 7e divisie</a></li>
<li><a href="/content/turnen/nieuws/73-succes-in-de-6de-divisie" title="Succes in de 6de divisie">Succes in de 6de divisie</a></li>
<li><a href="/content/turnen/nieuws/70-en-de-wedstrijden-gaan-maar-door" title="En de wedstrijden gaan maar door!">En de wedstrijden gaan maar door!</a></li>
<li><a href="/content/turnen/nieuws/69-goed-begin-van-het-jaar-voor-druturnia" title="Goed begin van het jaar voor Druturnia!">Goed begin van het jaar voor Druturnia!</a></li>
<li><a href="/content/turnen/nieuws/66-goud-voor-roos-smits" title="Goud voor Roos Smits">Goud voor Roos Smits</a></li>
<li><a href="/content/turnen/nieuws/65-2e-wedstrijd-4e-divisie-weer-een-succes" title="2e wedstrijd 4e divisie weer een succes">2e wedstrijd 4e divisie weer een succes</a></li>
<li><a href="/content/turnen/nieuws/64-goede-wedstrijdprestaties-druturnia" title="Goede wedstrijdprestaties Druturnia">Goede wedstrijdprestaties Druturnia</a></li>
<li><a href="/content/turnen/nieuws/63-eerste-wedstrijd-van-het-seizoen-2-medailles" title="Eerste wedstrijd van het seizoen, 2 medailles!!">Eerste wedstrijd van het seizoen, 2 medailles!!</a></li>
<li><a href="/content/turnen/nieuws/62-een-dolle-pietenboel" title="Een dolle pietenboel">Een dolle pietenboel</a></li>
<li><a href="/content/turnen/nieuws/61-pietengym-2006" title="Pietengym 2006">Pietengym 2006</a></li>
<li><a href="/content/turnen/nieuws/60-gym-doe-dag-2006" title="Gym Doe Dag 2006">Gym Doe Dag 2006</a></li>
<li><a href="/content/turnen/nieuws/56-plaatsingswedstrijden-enschede-en-doetinchem" title="Plaatsingswedstrijden Enschede en Doetinchem">Plaatsingswedstrijden Enschede en Doetinchem</a></li>
<li><a href="/content/turnen/nieuws/54-druturnia-succesvol-bij-regiofinales-in-de-4e-divisie" title="Druturnia succesvol bij regiofinales in de 4e divisie">Druturnia succesvol bij regiofinales in de 4e divisie</a></li>
<li><a href="/content/turnen/nieuws/53-druturnia-op-3-fronten-goed-bezig" title="Druturnia op 3 fronten goed bezig">Druturnia op 3 fronten goed bezig</a></li>
<li><a href="/content/turnen/nieuws/52-alle-turndames-door-naar-de-4e-divisie-regiofinale" title="Alle turndames door naar de 4e divisie regiofinale">Alle turndames door naar de 4e divisie regiofinale</a></li>
<li><a href="/content/turnen/nieuws/51-tumblingbaan-dankzij-actie" title="Tumblingbaan dankzij actie">Tumblingbaan dankzij actie</a></li>
<li><a href="/content/turnen/nieuws/50-pietengym-voor-druturnia-leden" title="Pietengym voor Druturnia-leden">Pietengym voor Druturnia-leden</a></li>
<li><a href="/content/turnen/nieuws/41-eveline-van-de-werf-tweede-in-de-turnfinale-in-rheden" title="Eveline van de Werf tweede in de turnfinale in Rheden">Eveline van de Werf tweede in de turnfinale in Rheden</a></li>
<li><a href="/content/turnen/nieuws/39-druturnia-haalt-medailles-alsof-het-niets-is" title="Druturnia haalt medailles alsof het niets is">Druturnia haalt medailles alsof het niets is</a></li>
<li><a href="/content/turnen/nieuws/38-finale-afvaardiging-van-5-druturnia-dames" title="Finale afvaardiging van 5 Druturnia dames">Finale afvaardiging van 5 Druturnia dames</a></li>
<li><a href="/content/turnen/nieuws/37-druturnia-geeft-visitekaartje-af" title="Druturnia geeft visitekaartje af">Druturnia geeft visitekaartje af</a></li>
<li><a href="/content/turnen/nieuws/36-weer-goede-turnprestaties-druturnia" title="Weer goede turnprestaties Druturnia">Weer goede turnprestaties Druturnia</a></li>
<li><a href="/content/turnen/nieuws/35-onze-wedstrijdturnsters-in-doetinchem" title="Onze wedstrijdturnsters in Doetinchem">Onze wedstrijdturnsters in Doetinchem</a></li>
<li><a href="/content/turnen/nieuws/34-recreantenmeiden-in-dodewaard" title="Recreantenmeiden in Dodewaard">Recreantenmeiden in Dodewaard</a></li>
<li><a href="/content/turnen/nieuws/33-opheusden-15-januari-groep-3" title="Opheusden, 15 januari - Groep 3">Opheusden, 15 januari - Groep 3</a></li>
<li><a href="/content/turnen/nieuws/30-gym-doe-dag-in-zetten" title="Gym Doe Dag in Zetten">Gym Doe Dag in Zetten</a></li>
<li><a href="/content/turnen/nieuws/29-eerste-toernooi-van-het-seizoen-voor-druturnia-turnsters" title="Eerste toernooi van het seizoen voor Druturnia turn(st)ers.">Eerste toernooi van het seizoen voor Druturnia turn(st)ers.</a></li>
<li><a href="/content/turnen/nieuws/26-clubkampioenschappen-turnen-2004" title="Clubkampioenschappen Turnen 2004">Clubkampioenschappen Turnen 2004</a></li>
<li><a href="/content/turnen/nieuws/22-recreanten-springtoernooi-in-ochten" title="Recreanten springtoernooi in Ochten">Recreanten springtoernooi in Ochten</a></li>
<li><a href="/content/turnen/nieuws/21-gesponsorde-rugtassen-ims-heftrucks-en-tms-heftrucks" title="Gesponsorde rugtassen I.M.S. Heftrucks en T.M.S. Heftrucks">Gesponsorde rugtassen I.M.S. Heftrucks en T.M.S. Heftrucks</a></li>
<li><a href="/content/turnen/nieuws/20-druturnia-met-2-turnsters-door-naar-de-districtsfinale-27-maart-2004-in-vries" title="Druturnia met 2 turnsters door naar de districtsfinale 27 maart 2004 in Vries">Druturnia met 2 turnsters door naar de districtsfinale 27 maart 2004 in Vries</a></li>
<li><a href="/content/turnen/nieuws/18-uit-de-waalkanter-qdruturnia-recreanten-laten-zich-niet-kennenq" title="Uit de Waalkanter: &quot;Druturnia recreanten laten zich niet kennen&quot;">Uit de Waalkanter: &quot;Druturnia recreanten laten zich niet kennen&quot;</a></li>
<li><a href="/content/turnen/nieuws/16-pietengym-op-29-november-2003" title="Pietengym op 29 november 2003">Pietengym op 29 november 2003</a></li>
<li><a href="/content/turnen/nieuws/4-gym-doe-dag" title="Gym Doe Dag">Gym Doe Dag</a></li>
<li><a href="/content/turnen/nieuws/2-sponsoren-voor-wedstrijdturn-groepen" title="Sponsoren voor wedstrijdturn-groepen">Sponsoren voor wedstrijdturn-groepen</a></li>
</ul>
</li><li><a href="/content/turnen/uitslagen" title="Uitslagen">Uitslagen</a></li>
<li><a href="/content/turnen/videos" title="Video's">Video's</a></li>
</ul>
</li><li><a href="http://www.druturnia.nl/#" title="Dans">Dans</a>
<ul class="level_1">
<li><a href="/content/dans/introductie" title="Introductie">Introductie</a></li>
<li><a href="/content/dans/lesrooster" title="Lesrooster">Lesrooster</a></li>
<li><a href="/content/dans/nieuws" title="Nieuws">Nieuws</a>
<ul class="level_2">
<li><a href="/content/dans/nieuws/241-geweldig-resultaat-voor-druturnia-op-nk-in-mill-" title="Geweldig resultaat voor Druturnia op NK in Mill ">Geweldig resultaat voor Druturnia op NK in Mill </a></li>
<li><a href="/content/dans/nieuws/240-uitnodiging-dansvoorstelling-druturnia" title="Uitnodiging Dansvoorstelling Druturnia">Uitnodiging Dansvoorstelling Druturnia</a></li>
<li><a href="/content/dans/nieuws/220-druturnia-scoort-in-zierikzee" title="Druturnia scoort in Zierikzee">Druturnia scoort in Zierikzee</a></li>
<li><a href="/content/dans/nieuws/216-druturnias-definition-of-dance-naar-het-wereldkampioenschap-showdance" title="Druturnia’s Definition of Dance naar het Wereldkampioenschap Showdance!">Druturnia’s Definition of Dance naar het Wereldkampioenschap Showdance!</a></li>
<li><a href="/content/dans/nieuws/215-toch-een-beker-voor-druturnia" title="Toch een beker voor Druturnia!">Toch een beker voor Druturnia!</a></li>
<li><a href="/content/dans/nieuws/214-uit-de-waalkanter" title="Uit de waalkanter">Uit de waalkanter</a></li>
<li><a href="/content/dans/nieuws/211-definition-of-dance-2de-plaats-op-nk-showdance" title="Definition of Dance 2de plaats op NK Showdance">Definition of Dance 2de plaats op NK Showdance</a></li>
<li><a href="/content/dans/nieuws/194-druturnia-laat-danssporen-achter-in-putten" title="Druturnia laat danssporen achter in Putten">Druturnia laat danssporen achter in Putten</a></li>
<li><a href="/content/dans/nieuws/115-druturnia-in-actie-op-het-open-nk-streetdancehip-hop-in-mill" title="Druturnia in actie op het Open NK Streetdance/Hip Hop in Mill">Druturnia in actie op het Open NK Streetdance/Hip Hop in Mill</a></li>
<li><a href="/content/dans/nieuws/108-streetdemo" title="Streetdemo">Streetdemo</a></li>
<li><a href="/content/dans/nieuws/84-definition-of-dance" title="Definition of dance!">Definition of dance!</a></li>
<li><a href="/content/dans/nieuws/71-demogyjada-in-apeldoorn" title="Demogyjada in Apeldoorn">Demogyjada in Apeldoorn</a></li>
<li><a href="/content/dans/nieuws/58-de-jazztak-van-druturnia-scoort-ook" title="De Jazztak van Druturnia scoort ook!">De Jazztak van Druturnia scoort ook!</a></li>
<li><a href="/content/dans/nieuws/55-helaas-dit-seizoen-geen-jazzvoorstelling" title="Helaas, dit seizoen geen jazzvoorstelling…">Helaas, dit seizoen geen jazzvoorstelling…</a></li>
<li><a href="/content/dans/nieuws/47-dvd-neverending-" title="DVD Neverending …">DVD Neverending …</a></li>
<li><a href="/content/dans/nieuws/44-de-neverending-story-of-dance" title="De “Neverending story of dance”">De “Neverending story of dance”</a></li>
<li><a href="/content/dans/nieuws/42-jaarlijkse-jazzdance-voorstelling-in-dn-bogerd" title="Jaarlijkse Jazzdance voorstelling in d’n Bogerd">Jaarlijkse Jazzdance voorstelling in d’n Bogerd</a></li>
<li><a href="/content/dans/nieuws/28-streetdance" title="Streetdance">Streetdance</a></li>
<li><a href="/content/dans/nieuws/25-dvdvideo-en-foto-cd-rom-van-hollywood" title="DVD/Video en foto cd-rom van Hollywood">DVD/Video en foto cd-rom van Hollywood</a></li>
<li><a href="/content/dans/nieuws/24-hollywood-spektakel-inspireert-30-plussers" title="Hollywood spektakel inspireert 30-plussers?!?">Hollywood spektakel inspireert 30-plussers?!?</a></li>
<li><a href="/content/dans/nieuws/19-definition-of-dance-op-weg-naar-dn-bogerd" title="Definition of Dance op weg naar d’n Bogerd">Definition of Dance op weg naar d’n Bogerd</a></li>
<li><a href="/content/dans/nieuws/1-demo-en-workshop-deester-feestweek" title="Demo en Workshop Deester Feestweek">Demo en Workshop Deester Feestweek</a></li>
</ul>
</li><li><a href="/content/dans/playlist" title="Playlist">Playlist</a></li>
<li><a href="/content/dans/videos" title="Video's">Video's</a></li>
</ul>
</li><li><a href="http://www.druturnia.nl/#" title="Word lid">Word lid</a>
<ul class="level_1">
<li><a href="/content/word-lid/aanmelden" title="Aanmelden">Aanmelden</a></li>
<li><a href="/content/word-lid/contributie" title="Contributie">Contributie</a></li>
</ul>
</li><li><a href="http://www.druturnia.nl/#" title="Algemeen">Algemeen</a>
<ul class="level_1">
<li><a href="/content/algemeen/beleidsplan" title="Beleidsplan">Beleidsplan</a></li>
<li><a href="/content/algemeen/bestuursinformatie" title="Bestuursinformatie">Bestuursinformatie</a>
<ul class="level_2">
<li><a href="/content/algemeen/bestuursinformatie/notulen-jaarvergadering-druturnia-dd-2-maart-2009" title="Notulen jaarvergadering Druturnia d.d. 2 maart 2009">Notulen jaarvergadering Druturnia d.d. 2 maart 2009</a></li>
</ul>
</li><li><a href="/content/algemeen/kledingvoorschriften" title="Kledingvoorschriften">Kledingvoorschriften</a></li>
<li><a href="/content/algemeen/lesroosters" title="Lesroosters">Lesroosters</a></li>
<li><a href="/content/algemeen/sportruimten" title="Sportruimten">Sportruimten</a></li>
</ul>
</li><li><a href="/content/agenda" title="Agenda">Agenda</a></li>
<li><a href="/content/fotos" title="Foto's">Foto's</a></li>
<li><a href="http://www.druturnia.nl/#" title="Reageer">Reageer</a>
<ul class="level_1">
<li><a href="/content/reageer/bestuur" title="Bestuur">Bestuur</a></li>
<li><a href="/content/reageer/leiding" title="Leiding">Leiding</a></li>
<li><a href="/content/reageer/redactie-en-webbeheer" title="Redactie en webbeheer">Redactie en webbeheer</a></li>
<li><a href="/content/reageer/gastenboek" title="Gastenboek">Gastenboek</a></li>
</ul>
</li></ul>
<div style="clear:left"></div></div></div>


			
		</div>
		</div>
		<!-- END: CONTENT -->

		
		</div>

				<!-- BEGIN: RIGHT COLUMN -->
		<div id="ja-col2">
					<div class="jamod module" id="Mod115">
			<div>
				<div>
					<div>
																		<h3 class="show"><span>Volg druturnia op Twitter</span></h3>
												<div class="jamod-content"><a href="http://www.twitter.com/druturnia"><img src="http://twitter-badges.s3.amazonaws.com/follow_me-a.png" alt="Volg druturnia op Twitter"/></a></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-full" style="width: 99;">
			
	  </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>

	<br />
</div>
</div>
<!-- END: FOOTER -->

</div>



<div id="fb-root"></div>
<script>
window.fbAsyncInit = function() { FB.init({appId: '156911407657341', status: true, cookie: true, xfbml: true}); };
(function() { var e = document.createElement('script');
e.type = 'text/javascript';
e.src = document.location.protocol + '//connect.facebook.net/nl_NL/all.js';
e.async = true;
document.getElementById('fb-root').appendChild(e);
}());
</script></body>

</html>UlJfU1RSSU5HX1BST1RFQ1RJT05fRU5E|>