a:4:{s:14:"__file_content";s:19:"alb-saved-templates";s:5:"about";s:4094:"[av_layout_row border='' min_height='430px' color='main_color' mobile='av-flex-cells' id='']
[av_cell_one_half vertical_align='top' padding='30px' padding_sync='true' background_color='' src='http://test.kriesi.at/minimal-portfolio/wp-content/uploads/sites/6/2015/07/me-bw.jpg' attachment='164' attachment_size='full' background_attachment='scroll' background_position='center left' background_repeat='stretch']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px,100px,30px,100px' background_color='#f5f5f5' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat']

[av_heading tag='h3' padding='10' heading='About me' color='' style='blockquote modern-quote' custom_font='' size='' subheading_active='' subheading_size='15' custom_class=''][/av_heading]

[av_textblock size='' font_color='' color='']
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis <strong>parturient</strong> montes, nascetur ridiculus mus.

Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim.
[/av_textblock]

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_px='500px' padding='large' shadow='no-border-styling' bottom_border='no-border-styling' id='' color='main_color' custom_bg='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='']
[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat']

[av_heading tag='h3' padding='10' heading='What I can do for you' color='' style='blockquote modern-quote' custom_font='' size='' subheading_active='' subheading_size='15' custom_class=''][/av_heading]

[av_textblock size='' font_color='' color='']
Lorem ipsum dolor sit amet, consectetuer <strong>adipiscing</strong> elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.

Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim.
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat']

[av_heading tag='h3' padding='10' heading='Skills' color='' style='blockquote modern-quote' custom_font='' size='' subheading_active='' subheading_size='15' custom_class=''][/av_heading]

[av_textblock size='' font_color='' color='']
Aenean vulputate eleifend tellus. <strong>Aenean</strong> leo ligula, porttitor eu, <strong>consequat</strong> vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus.
<ul>
	<li>Nullam felis eu pede mollis pretium.</li>
	<li>Integer tincidunt. Cras dapibus.</li>
	<li>Vivamus elementum semper nisi.</li>
</ul>
[/av_textblock]

[/av_one_half][av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='30px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='#f5f5f5' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat']

[av_heading tag='h3' padding='20' heading='I am currently:' color='' style='blockquote modern-quote modern-centered' custom_font='' size='' subheading_active='' subheading_size='15' custom_class=''][/av_heading]

[av_button label='Available for work' link='page,156' link_target='' size='x-large' position='center' icon_select='no' icon='ue800' font='entypo-fontello' color='dark' custom_bg='#444444' custom_font='#ffffff']

[/av_one_full]
[/av_section]";s:21:"iconGrid_Localhostrol";s:3776:"[av_icongrid icongrid_styling='flipbox' icongrid_numrow='3' icongrid_borders='between' custom_title_size='18' custom_subtitle_size='15' custom_content_size='' custom_icon_size='' font_color='custom' custom_icon='#ffffff' custom_title='#ffffff' custom_subtitle='rgba(255,255,255,0.49)' custom_content='rgba(255,255,255,0.78)' bg_color='' custom_front_bg='' custom_back_bg='' grid_color='custom' custom_grid='rgba(255,255,255,0.64)' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='']
[av_icongrid_item title='Advertising' link='' linktarget='' subtitle='make your event visible' icon='ue826' font='entypo-fontello' item_font_color='' item_custom_icon='' item_custom_title='' item_custom_subtitle='' item_custom_content='' item_bg_color='' item_custom_front_bg='' item_custom_back_bg='' av_uid='']
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa.
[/av_icongrid_item]
[av_icongrid_item title='Brand Design' link='' linktarget='' subtitle='make your brand stand out' icon='ue827' font='entypo-fontello' item_font_color='' item_custom_icon='' item_custom_title='' item_custom_subtitle='' item_custom_content='' item_bg_color='' item_custom_front_bg='' item_custom_back_bg='' av_uid='']
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim.
[/av_icongrid_item]
[av_icongrid_item title='Event Planing' link='' linktarget='' subtitle='plan an awesome event' icon='ue84d' font='entypo-fontello' item_font_color='' item_custom_icon='' item_custom_title='' item_custom_subtitle='' item_custom_content='' item_bg_color='' item_custom_front_bg='' item_custom_back_bg='' av_uid='']
Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo. Nullam dictum felis eu pede mollis pretium. Integer tincidunt.
[/av_icongrid_item]
[av_icongrid_item title='Location Scouting' link='' linktarget='' subtitle='because finding the best spot is important' icon='ue821' font='entypo-fontello' item_font_color='' item_custom_icon='' item_custom_title='' item_custom_subtitle='' item_custom_content='' item_bg_color='' item_custom_front_bg='' item_custom_back_bg='' av_uid='']
Cras dapibus. Vivamus elementum semper nisi. Aenean vulputate eleifend tellus. Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus.
[/av_icongrid_item]
[av_icongrid_item title='Social Media' link='' linktarget='' subtitle='use the power of viral marketing' icon='ue8f5' font='entypo-fontello' item_font_color='' item_custom_icon='' item_custom_title='' item_custom_subtitle='' item_custom_content='' item_bg_color='' item_custom_front_bg='' item_custom_back_bg='' av_uid='']
Aenean vulputate eleifend tellus. Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus. Cras dapibus. Vivamus elementum semper nisi.
[/av_icongrid_item]
[av_icongrid_item title='Event Analysis' link='' linktarget='' subtitle='Post event data analysis ' icon='ue864' font='entypo-fontello' item_font_color='' item_custom_icon='' item_custom_title='' item_custom_subtitle='' item_custom_content='' item_bg_color='' item_custom_front_bg='' item_custom_back_bg='' av_uid='']
Cras dapibus. Vivamus elementum semper nisi. Aenean vulputate eleifend tellus. Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus.
[/av_icongrid_item]
[/av_icongrid]";s:5:"Title";s:294:"[av_heading tag='h1' padding='0' heading='<strong>Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, en in.</strong>' color='custom-color-heading' style='blockquote modern-quote' custom_font='#000000' size='40' subheading_active='' subheading_size='15' custom_class=''][/av_heading]";}