<div class="vce-row-container"><div class="vce-row vce-row--col-gap-30 vce-row-no-paddings vce-row-columns--top vce-row-content--middle" data-vce-full-width="true" id="el-4f6e14c8" data-vce-do-apply="all el-4f6e14c8" data-vce-stretch-content="true"><div class="vce-content-background-container"></div><div class="vce-row-content" data-vce-element-content="true" style=""><div class="vce-col vce-col--md-100p vce-col--xs-1 vce-col--xs-last vce-col--xs-first vce-col--sm-last vce-col--sm-first vce-col--md-last vce-col--lg-last vce-col--xl-last vce-col--md-first vce-col--lg-first vce-col--xl-first" id="el-1859f1c3" data-vce-do-apply="background border el-1859f1c3"><div class="vce-col-inner" data-vce-element-content="true" data-vce-do-apply="padding margin  el-1859f1c3"><div class="vce-col-content"><div class="vce-text-block"><div class="vce-text-block-wrapper vce" id="el-22c29e78" data-vce-do-apply="all el-22c29e78"><p>[vc_row full_width="stretch_row_content_no_spaces"][vc_column][vc_single_image image="4137" img_size="full" alignment="center"][/vc_column][/vc_row][vc_row full_width="stretch_row_content" css=".vc_custom_1526506936728{padding-top: 2% !important;padding-bottom: 2% !important;}"][vc_column][vc_text_separator title="sculptures" color="custom" el_width="80" accent_color="#ffc823" css=".vc_custom_1526216802819{padding-bottom: 2% !important;}"]			
			<div class="thumbs clearfix">
				<div class="grid-sizer"></div>						
				
					<div class="project small 120-x-45-x-210-cm-%c2%b7-steel effect-3 " id="project-3927">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">archers</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									120 x 45 x 210 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/archers/" alt="archers"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/04/archer-600x800.jpg" class=" wp-post-image" alt="archers" title="archers" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 210-x-40-x-80-cm-%c2%b7-steel effect-3 " id="project-3923">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">social conformism</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									210 x 40 x 80 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/social-conformism/" alt="social conformism"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/04/social-conformism-600x800.jpg" class=" wp-post-image" alt="social conformism" title="social conformism" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 74-x-40-x-40-%c2%b7-steel effect-3 " id="project-3941">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">insomnia</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									74 x 40 x 40 · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/insomnia/" alt="insomnia"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/04/IGU_3849-600x800.jpg" class=" wp-post-image" alt="insomnia" title="insomnia" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small  effect-3 " id="project-4270">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">Stranger Things</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
																	</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/stranger-things/" alt="Stranger Things"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/12/site-600x800.jpg" class=" wp-post-image" alt="Stranger Things" title="Stranger Things" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small sculptures effect-3 " id="project-4251">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">balustrade</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									Sculptures								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/balustrade/" alt="balustrade"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/11/balustrade-600x800.jpg" class=" wp-post-image" alt="balustrade" title="balustrade" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small  effect-3 " id="project-4243">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">wheel version two</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
																	</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/wheel-version-two/" alt="wheel version two"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/11/wheel-3-600x800.jpg" class=" wp-post-image" alt="wheel version two" title="wheel version two" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 45-x-110-x-80-cm-%c2%b7-steel effect-3 " id="project-3925">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">runner</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									45 x 110 x 80 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/runner/" alt="runner"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/04/runner-600x800.jpg" class=" wp-post-image" alt="runner" title="runner" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 40-x-32-x-10-cm-%c2%b7-steel effect-3 " id="project-4004">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">other half</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									40 x 32 x 10 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/other-half/" alt="other half"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/05/split2-600x800.jpg" class=" wp-post-image" alt="other half" title="other half" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 45-x-50-x-20-cm-%c2%b7-steel effect-3 " id="project-3998">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">degradation</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									45 x 50 x 20 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/degradation-2/" alt="degradation"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/05/degradation-600x800.jpg" class=" wp-post-image" alt="degradation" title="degradation" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 40-x-25-x-30-cm-%c2%b7-steel effect-3 " id="project-3957">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">adam</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									40 x 25 x 30 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/adam/" alt="adam"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/04/adam-600x800.jpg" class=" wp-post-image" alt="adam" title="adam" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 40-x-30-x-20-cm-%c2%b7-steel effect-3 " id="project-3955">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">figure 2.0</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									40 x 30 x 20 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/figure-2-0/" alt="figure 2.0"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/04/figure-2-600x800.jpg" class=" wp-post-image" alt="figure 2.0" title="figure 2.0" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 40-x-25-x-30-cm-%c2%b7-steel effect-3 " id="project-3953">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">homosapien</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									40 x 25 x 30 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/homosapien/" alt="homosapien"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/05/homosapiens-600x800.jpg" class=" wp-post-image" alt="homosapien" title="homosapien" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 28-x-28-x-28-cm-%c2%b7-steel effect-3 " id="project-3951">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">think outside the box</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									28 x 28 x 28 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/think-outside-the-box/" alt="think outside the box"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/05/think-outside-the-box-600x800.jpg" class=" wp-post-image" alt="think outside the box" title="think outside the box" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 70-x-50-x-35-cm-%c2%b7-steel effect-3 " id="project-3947">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">equilibrium</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									70 x 50 x 35 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/equilibrium/" alt="equilibrium"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/05/equilibrium-600x800.jpg" class=" wp-post-image" alt="equilibrium" title="equilibrium" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 80-x-70-x-55-cm-%c2%b7-steel effect-3 " id="project-3945">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">agony</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									80 x 70 x 55 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/agony/" alt="agony"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/05/agony-600x800.jpg" class=" wp-post-image" alt="agony" title="agony" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 110-x-25-x-25-cm-%c2%b7-steel effect-3 " id="project-3943">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">chain of weeknesses</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									110 x 25 x 25 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/chain-of-weeknesses/" alt="chain of weeknesses"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/05/chain-of-weeknesses-600x800.jpg" class=" wp-post-image" alt="chain of weeknesses" title="chain of weeknesses" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 40-x-32-x-10-cm-%c2%b7-steel effect-3 " id="project-3939">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">split</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									40 x 32 x 10 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/split/" alt="split"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/04/split-2-600x800.jpg" class=" wp-post-image" alt="split" title="split" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 105-x-50-x-25-cm-%c2%b7-steel effect-3 " id="project-3935">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">out of reality</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									105 x 50 x 25 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/out-of-reality/" alt="out of reality"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/04/getting-out-of-reality-600x800.jpg" class=" wp-post-image" alt="out of reality" title="out of reality" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 70-x-55-x-15-cm-%c2%b7-steel effect-3 " id="project-3933">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">influence</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									70 x 55 x 15 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/influence/" alt="influence"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/04/influence-600x800.jpg" class=" wp-post-image" alt="influence" title="influence" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 40-x-60-x-8-cm-%c2%b7-steel effect-3 " id="project-3929">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">wheel</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									40 x 60 x 8 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/wheel/" alt="wheel"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/0015/04/wheel-2-600x800.jpg" class=" wp-post-image" alt="wheel" title="wheel" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 40-x-30-x-30-cm-%c2%b7-steel effect-3 " id="project-3920">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">social media</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									40 x 30 x 30 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/social-media/" alt="social media"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/04/social-media-600x800.jpg" class=" wp-post-image" alt="social media" title="social media" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 30-x-30-x-55-cm-%c2%b7-steel effect-3 " id="project-3918">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">vortex</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									30 x 30 x 55 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/vortex/" alt="vortex"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/04/circles-of-life-600x800.jpg" class=" wp-post-image" alt="vortex" title="vortex" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 80-x-55-x-50-cm-%c2%b7-steel effect-3 " id="project-3931">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">defragmentation</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									80 x 55 x 50 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/defragmentation/" alt="defragmentation"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/04/defragmentation-600x800.jpg" class=" wp-post-image" alt="defragmentation" title="defragmentation" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 85-x-45-x-40-cm-%c2%b7-steel effect-3 " id="project-3937">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">fragmented</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									85 x 45 x 40 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/fragmented/" alt="fragmented"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/05/fragmented-2-1-600x800.jpg" class=" wp-post-image" alt="fragmented" title="fragmented" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 56-x-46-x-10-cm-%c2%b7-steel effect-3 " id="project-4001">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">diffuse</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									56 x 46 x 10 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/diffuse/" alt="diffuse"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/05/fear-2-600x800.jpg" class=" wp-post-image" alt="diffuse" title="diffuse" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 40-x-30-x-35-cm-%c2%b7-steel effect-3 " id="project-4008">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">welding flame</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									40 x 30 x 35 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/welding-flame/" alt="welding flame"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/05/welding-flame-600x800.jpg" class=" wp-post-image" alt="welding flame" title="welding flame" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small 30-x-25-x-20-cm-%c2%b7-steel effect-3 " id="project-4011">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">adam 2.0</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
									30 x 25 x 20 cm · steel								</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/adam-2-0/" alt="adam 2.0"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/05/adam-2--600x800.jpg" class=" wp-post-image" alt="adam 2.0" title="adam 2.0" />
						

						
						</div>
					</div><!-- #post->ID -->
				
					<div class="project small  effect-3 " id="project-4235">
						<div class="inside">
							
							<div class="details  has-skills" style="border-color: #ffffff;">
								<div class="text">
								
								<div class="title" >
									<h3 class="entry-title" style="color: #ffffff!important;">Look! No hands</h3>
								</div>
								
																<div class="skills" style="color: #ffffff;">
																	</div>
																
								</div>
							</div>

							<div class="overlay" style="background-color: #0a0a0a;"></div>
							
															<a href="http://danielradulescu.ro/project/look-no-hands/" alt="Look! No hands"></a>
													<img width="600" height="800" src="http://danielradulescu.ro/wp-content/uploads/2018/11/look-no-hands-600x800.jpg" class=" wp-post-image" alt="Look! No hands" title="Look! No hands" />
						

						
						</div>
					</div><!-- #post->ID -->
							</div><!-- .thumbs -->
					</div><!-- .projects -->
		[/vc_column][/vc_row][vc_row css=".vc_custom_1526215750220{padding-top: 3% !important;}"][vc_column][vc_text_separator title="about" color="custom" el_width="80" accent_color="#ffc823" css=".vc_custom_1526216703475{padding-bottom: 2% !important;}"][vc_column_text css=".vc_custom_1542545237201{margin-bottom: -6% !important;}"]<img class="aligncenter wp-image-4259 " src="http://danielradulescu.ro/wp-content/uploads/2018/11/45202445_2081074601924042_677343018621075456_o-300x200.jpg" alt="" width="696" height="464"></p>
<p>&nbsp;</p>
<p><span style="color: #333300; font-family: helvetica, arial, sans-serif; font-size: 12px;"> I have studied traditional graphic in the School of Fine Arts “Hans Mattis Teutsch” from Brasov At the age of 18 I left everything behind and moved to Bucharest. In this amazing and dynamic city I started a new life, on my own. After many years of hard work and struggling I started studying sculpture at the National University of Fine Arts from Bucharest. At the beginning i was carving in stone, wood, modelling in clay, wax, I used to work with resin, experimenting tridimensional and volumetric shapes. After a couple of years I find out how to work with steel and learn different ways to weld it. I became obsessed with this wonderful material and every day my task was to learn more and more about how to process it better, my sculptures are made from adding layers and layers and layers of melted steel, like a 3D steel printing machine. This is what I do today, on a daily basses. It's more than a job, is passion!</span></p>
<p>&nbsp;</p>
<p style="text-align: center;"><span style="color: #000000; font-family: helvetica, arial, sans-serif;">D</span>&nbsp;&nbsp;<span style="color: #ffcc00;">・<span style="color: #000000; font-family: helvetica, arial, sans-serif;">&nbsp;</span></span><span style="color: #000000; font-family: helvetica, arial, sans-serif;">R</span></p>
<p>[/vc_column_text][vc_single_image image="3689" img_size="medium" alignment="center" css=".vc_custom_1526216506427{border-top-width: -5% !important;}"][/vc_column][/vc_row][vc_row full_width="stretch_row_content"][vc_column css=".vc_custom_1526119049104{border-top-width: 20% !important;}"][vc_text_separator title="exhibitions ・ events" color="custom" el_width="50" accent_color="#ffc823" css=".vc_custom_1526216677091{padding-bottom: 2% !important;}"][vc_column_text]</p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #333333;"><span style="color: #c41515;"><em><span style="color: #ffc823;">2018</span>&nbsp;</em></span></span></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #000000;"><em>Solo exhibition</em> · CREART "Stranger Things" curated by Razvan Ion&nbsp; · Bucharest</span></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #000000;"><em>Group exhibition</em> · Braderie de l'Art at <em>La Condition Publique</em>&nbsp;in France</span></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #000000;"><em>Group exhibition</em> · PAVOT gallery&nbsp; · Bucharest</span></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #000000;"><em>Private Solo exhibition</em> · at World Trade Center with 3M Company</span></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #000000;"><em>Group exhibition</em> · at Qreator - Art Walk Street - won 1st prize.</span></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #000000;"><em>Private Solo exhibition</em> · Palatul Ghika with 3M Company</span></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>Solo exhibition</em> · "HELVETIA luxury watches" · m e и t a l</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #000000;"><em>Group exhibition</em> · Palatul Noblesse - Fusion art</span></span></p>
<p style="text-align: center;"><span style="color: #000000; font-family: helvetica, arial, sans-serif;"><span style="font-size: 12px;"><i>Curated all sculptors</i> for fusion art 2018 at Noblesse Palace</span></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #000000;"><em>Sculptures &amp; drawings exhibition</em>&nbsp;at LABORNA - contemporary art gallery</span></span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #ffc823;">2017</span>&nbsp;</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>Solo exhibition</em> · "Welding - Emotions " 5 steel sculptures · Kube Musette Gallery&nbsp;· Bucharest&nbsp;</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>Group exhibition</em> · Cluj-Napoca</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>Group exhibition</em> · &nbsp;Noblesse Palace - &nbsp;"MultiBrand Concept ShowRoom " in Bucharest&nbsp;</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>ART manager</em> at&nbsp;" Noblesse Palace "&nbsp;coordonate FUSION ART EVENT with over 50&nbsp;artists</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>Auction House GOLD ART</em> purchase one of my sculpture&nbsp;</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>Group exhibition</em> · Noblesse Palace "Fusion ART"</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>Group exhibition</em> · "National Library" UNARTE&nbsp;University License</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>Solo exhibition</em> " Metalul, Eu ! " · Kube Musette gallery · Bucharest</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #ffc823;"><em>2016</em></span>&nbsp;</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>group sculpture exhibition</em> · "University of Arts and Design" from Timisoara&nbsp;</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>coordinate 6 artists</em> in a project for "Bucovina History Museum" from Suceava<br>
</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>coordinate <span id="result_box" class="short_text" lang="en">and <span class="">achievement</span></span></em> the TERRAZZO floor design&nbsp;from "Park Lake mall" · Bucharest&nbsp;<span id="result_box" class="short_text" lang="en"> </span></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #333333;"><em>being in a jury</em> · "Scoala de Valori" from Bucharest · 3-th edition</span></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #333333;"><em>LIVE event</em> · sculpting in clay &nbsp;"the kiss" by Constantin Brancusi at Museum Nicolae Minovici&nbsp;</span></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><em><span style="color: #333333;">online&nbsp;</span></em><span style="color: #333333;"><em>LIVE drawing</em> · for BECK'S</span></span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #ffc823;"><em>2015</em></span>&nbsp;</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>being in a jury</em> · "Scoala de Valori" · Bucharest&nbsp;· 2-th edition</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>group sculpture exhibition</em> · "National Library of Romania"&nbsp;</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>group exhibition</em>&nbsp;· "UNAgaleria" and Rembrand Contest · 1st prize</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>group exhibition</em> · "ART WALK STRET" two sculptures and one painting<br>
</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>LIVE drawing</em> · "National Library of Bucharest" · 4 drawings in <span id="result_box" class="short_text" lang="en">pastel <span class="">technique</span></span></span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #ffc823;"><em>2014</em></span>&nbsp;</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em> Event</em> · "Regina Maria foundation" / Bucharest /&nbsp; with Virgil Iantu &gt; teaching children how to draw</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>Event</em> · "National Stadium" from Bucharest , coordinated all the employees from Ubisoft how to draw using only spices</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>LIVE drawing</em> · "Energiea" a project powered by Grolsch</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>1 July event</em> · Tucano Coffee · Bucharest · coordinate 20+ <span id="result_box" class="short_text" lang="en">children <span class="">from the orphanage to draw using only coffee beans</span></span></span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>&nbsp;Solo exhibition</em> · "Palatul Ghika" - charity event</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>&nbsp;LIVE sculpture</em>&nbsp;· made at Tucano Coffee</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>LIVE sculpture</em> · "Extravaganza Show" - Bucharest</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>LIVE event</em> at the opening of "Coftale" a drawing using coffee beans</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>coordinate over 20 employees</em> · "mega-image" on a graphic workshop</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>solo Exhibition</em> ·&nbsp; "Palace of the Parliament" - art for earth</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>being in a jury</em> · "Scoala de Valori"&nbsp;·&nbsp; Bucharest&nbsp;· first edition</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;">"<em>National University of Fine Arts</em>" · UNArte , from Bucharest - Sculpture <span id="result_box" class="short_text" lang="en"><span class="">department</span></span> / class of: Adrian Ilfoveanu</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>group exhibition</em> · "Palatul Stirbei" / Bucharest</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #ffc823;"><em>2013</em></span>&nbsp;</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>LIVE event </em>· "L8 by Stephan Pelger" · Bucharest - sand drawing</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>LIVE event </em>· Bucharest subway · sand / cereals drawing - with "Arta nu musca" ONG</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>LIVE event</em> · Swan Lake · Bucharest - a 15 minutes story made of different type of materials and textiles</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>LIVE event</em> · Romexpo · with "360 Revolution agency" 3 drawings made of metal, fruits and sand</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>LIVE show</em> · TVR2&nbsp;· <span id="result_box" class="short_text" lang="en">entertainment <span class="">show</span></span> &gt; a drawing made of fruits and Acrylics</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>LIVE show</em> · TVR1 &lt;Pretuieste Viata show&gt; a drawing made of coffee beans, fruits and acrylics</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>LIVE Event</em> with "PUMA" · 4 drawings made of sweets, cereals, metal objects and fruits</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>LIVE draw</em>&nbsp; · "Galeria Occidentului" / Bucharest</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #ffc823;"><em>2012</em></span>&nbsp;</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em> 3D graphic designer</em> · "Carioca Studio" · Bucharest &gt;high poly modelling, texturing, unwrap<br>
</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>Photographer</em> · "Lumiere Artists" · Bucharest - casting film</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>2D Artist and Photographer assistant</em> · SD studio · Bucharest - editing and post-production&nbsp;</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #ffc823;"><em>2011</em> </span></span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;">&nbsp;<em>3D / 2D graphic designer</em> at "Flexidea" · Bucharest &lt; high poly modelling,&nbsp; unwrap, texturing , lighting, rendering, setup , visual compositing<br>
</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>Compositing and Concept artist</em> · "Tandem Film" · Bucharest · software used: Nuke, Photoshop</span></p>
<h4 style="text-align: center;"><span style="font-family: helvetica, arial, sans-serif;"><span style="font-size: 12px; color: #ffc823;"><em>2009</em></span></span></h4>
<p style="text-align: center;"><span style="font-family: helvetica, arial, sans-serif;"><span style="color: #333333; font-size: 12px;"><em>finished <span id="result_box" class="short_text" lang="en"><span class="">School of Fine Arts</span></span></em> "Hans Mattis Teutsch" from Brasov · graphics <span id="result_box" class="short_text" lang="en"><span class="">department</span></span><br>
</span></span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>group exhibition</em>, graphic, "EUROPE" Gallery from Brasov</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;">&nbsp;<em>winning a UK contest</em> &lt;3D TOTAL&gt; with a 3D render interior + appearance in "3D Creative" magazine<br>
</span></p>
<p style="text-align: center;"><span style="color: #333333; font-size: 12px; font-family: helvetica, arial, sans-serif;"><em>3D graphic artist</em> at "FunLabs / Activision" &lt; video-games Industry from Bucharest &lt; high / low poly modelling, texturing, unwrap&nbsp;</span></p>
<p>[/vc_column_text][/vc_column][vc_column][vc_text_separator title="interviews" color="custom" el_width="50" accent_color="#ffc823" css=".vc_custom_1526119114332{padding-bottom: 2% !important;}"][vc_column_text]</p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em><span style="color: #ffcc00;">2018</span>&nbsp;</em></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>interview · Tarom Magazine</em> at category · ART people (&nbsp;<a href="https://www.tarom.ro/sites/default/files/insight-martie-mai.pdf"> CLICK&nbsp; page 69</a>&nbsp;)&nbsp;</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>interview</em>&nbsp;· wallstreet.ro</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>interview&nbsp;</em>· bzb.ro · May 2th 2018</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;">romanialibera.ro &lt; romanian-design-week-2018 &gt;</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em><span style="color: #ffcc00;">2017</span></em></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em> video interview</em>&nbsp; · "neatza cu Razvan si Dani " antena 1</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>video interview</em> · PROtv "Piata artei in crestere"</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>interview</em>&nbsp; · RedBull.com</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>live</em> at radio · "Romania Cultural"</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>interview</em>&nbsp; "Revista Cultura" magazine · &nbsp;No. 9 (565) March 2</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>video interview</em> · PROtv&nbsp;come to my second personal exhibition</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>video interview</em> · Ideas Chat "emotie prin metal"</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em><span style="color: #ffcc00;">2016</span></em>&nbsp;</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>interview</em>&nbsp;· IQads.ro</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>&nbsp;interview </em>· goingfashion.ro</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em><span style="color: #ffcc00;">2015</span>&nbsp;</em></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>interview </em>· artwe.ro</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>interview</em>&nbsp;· povestilecristinei.ro</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><span style="color: #ffcc00;"><em>2013</em></span>&nbsp;</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em> interview</em> · gastronomist.ro</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>interview </em>· artanumusca.ro</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>&nbsp;interview&nbsp;</em> · business.review.eu "Romanian artist offers new visualization of Parliament Palace"</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>video interview</em> · Casamia TV</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;">&nbsp;<em>interview </em>· Ixuleasca.ro</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>interview&nbsp;</em> · dindragostepentruarta.wordpress.com</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #ffc823;"><em>2012</em></span>&nbsp;</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif;"><span style="color: #000000;"><em>interview </em>· TeenPress</span></span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>interview</em>&nbsp;· Autentici.ro</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;">&nbsp;<em>interview</em>&nbsp;· artwe.ro</span></p>
<p style="text-align: center;"><span style="font-size: 12px; font-family: helvetica, arial, sans-serif; color: #000000;"><em>interview&nbsp;&nbsp;</em>· webcultura.ro</span></p>
<p>[/vc_column_text][/vc_column][/vc_row][vc_row][vc_column][vc_text_separator title="contact" color="custom" el_width="80" accent_color="#ffc823" css=".vc_custom_1526284522988{padding-bottom: 2% !important;}"][vc_column_text]</p>
<p style="text-align: center;"><span style="color: #000000;"><span style="color: #ffcc00;">+<span style="color: #000000;">40</span></span>&nbsp;729 156 196</span></p>
<p style="text-align: center;"><span style="color: #000000;">contact<span style="color: #ffcc00;">@</span>danielradulescu<span style="color: #ff9900;">.</span>ro</span></p>
<p style="text-align: center;"><span style="color: #000000;">Romania<span style="color: #ffcc00;"> |</span> Bucharest</span></p>
<p>[/vc_column_text][vc_icon icon_fontawesome="fa fa-facebook-square" align="center" link="url:https%3A%2F%2Fwww.facebook.com%2Fradulescu.daniel.5||target:%20_blank|"][vc_single_image image="4204" img_size="medium" alignment="center"][/vc_column][/vc_row]</p>
</div></div></div></div></div></div></div></div>