a:19:{s:14:"__file_content";s:19:"alb-saved-templates";s:12:"about people";s:5010:"[av_layout_row border='' min_height_percent='' min_height_pc='25' min_height='0' color='main_color' mobile='av-flex-cells' mobile_breaking='' id='' custom_class='homeaboutbg' aria_label='' av_element_hidden_in_editor='0' av_uid='av-1znsx']
[av_cell_one_half vertical_align='top' padding='30px,20px,0px,30px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' custom_class='' av_uid='av-554l']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='-40px,0px' mobile_breaking='' border='' border_color='#455054' radius='5px' radius_sync='true' padding='5px,10px,0px,40px' column_boxshadow_color='#0f0f0f' column_boxshadow_width='9' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='fade-in' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='backallx2' aria_label='' av_uid='av-2vmq9']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='textcontectx2' av_uid='av-1wkjd' admin_preview_bg='']
<h2 style="letter-spacing: 3px; padding-top: 20px;">About Taxician</h2>

<hr class="style-two" />

<img class="alignright wp-image-70" src="http://taxician.us/wp-content/uploads/2020/12/man-home-page-225x300.png" alt="" width="250" height="334" />Taxician is the nation’s leading community for anyone—from students and those beginning their tax professional journey to veterans with decades of experience. With an emphasis on education and community, NAEA is essential to success in any tax-based career. We have the tools and connections to help you succeed and the advocacy and clarity to support you every step of the way.
<a href="/product/taxician-membership/" class="avia-button avia-icon_select-yes-left-icon avia-size-large avia-position-left " style="background-color: #455054; border-color: #455054; color: #ffffff;"><span class="avia_iconbox_title">Become a Member</span></a>
[/av_textblock]

[/av_one_full][/av_cell_one_half][av_cell_one_half vertical_align='top' padding='30px,30px,0px,30px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' custom_class='' av_uid='av-p0hd']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='-40px,0px' mobile_breaking='' border='' border_color='#455054' radius='5px' radius_sync='true' padding='5px,10px,0px,60px' column_boxshadow_color='#0f0f0f' column_boxshadow_width='9' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='fade-in' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='backallx3' aria_label='' av_uid='av-2vmq9']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='textcontectx3' av_uid='av-1wkjd' admin_preview_bg='']
<h2 style="letter-spacing: 3px; padding-top: 20px;">Information</h2>

<hr class="style-three" />

<img class="alignright wp-image-114" src="http://taxician.us/wp-content/uploads/2020/12/girl-home-page-3-225x300.png" alt="" width="250" height="334" />Taxician Members receive frequent updates and weekly email newsletters to keep you informed on the latest in tax and accounting news Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It was popularised in the 1960s with the release.
<a href="/tax-topics/" class="avia-button avia-icon_select-yes-right-icon avia-size-large avia-position-left " style="background-color: #ffd600; border-color: #ffd600; color: #455054; text-decoration: none;"><span class="avia_iconbox_title">Read The Lastest News</span></a>
[/av_textblock]

[/av_one_full][/av_cell_one_half]
[/av_layout_row]";s:10:"about test";s:8928:"[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='small' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='fixed' position='center right' repeat='no-repeat' video='' video_ratio='16:9' overlay_enable='aviaTBoverlay_enable' overlay_opacity='0.8' overlay_color='' overlay_pattern='custom' overlay_custom_pattern='http://exs.788.myftpupload.com/wp-content/uploads/2021/01/white_leather_white_bg.jpg' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-3n5u']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-5dqm']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-kk8q20tz' admin_preview_bg='']
<p style="text-align: center; margin-top: 60px; font-size: 1.856rem; font-family: Lora; color: black; font-weight: bold; text-shadow: 1px 1px 1px #023ca8;">Recent Results</p>
[/av_textblock]

[av_font_icon icon='uf106' font='flaticon' style='' caption='' size='46px' position='center' color='' link='' linktarget='' animation='' id='' custom_class='' av_uid='av-kk8q45ct' admin_preview_bg=''][/av_font_icon]

[/av_one_fifth][av_four_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-2wb6']

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' alb_description='' id='' custom_class='' av_uid='av-kk8jbn5a']
<div class="section-container">
	<ul class="panel-wrap section-flex">
		<li class="panel-item">
			<div class="mask">
				<strong>
					<span class="num">$1.8   </span>
					<span class="million">Million</span>
				</strong>
				<p style="color:#023ca8;" class="ui-scroll">Car Accident</p>
			</div>
		</li>
		<li class="panel-item">
			<div class="mask">
				<strong>
					<span class="num">$935.000</span>
					<span class="million">Thousand</span>
				</strong>
				<p style="color:#023ca8;"  class="ui-scroll">Car Accident</p>
			</div>
		</li>
		<li class="panel-item">
			<div class="mask">
				<strong>
					<span class="num">$540,000</span>
					<span class="million">Thousand</span>
				</strong>
				<p style="color:#023ca8;"  class="ui-scroll">Workers Comp</p>
			</div>
		</li>
		<li class="panel-item">
			<div class="mask">
				<strong>
					<span class="num">$72,500</span>
					<span class="million">Thousand</span>
				</strong>
				<p style="color:#023ca8;"  class="ui-scroll">Car Accident</p>
			</div>
		</li>
		<li class="panel-item">
			<div class="mask">
				<strong>
					<span class="num">$60,000</span>
					<span class="million">Thousand</span>
				</strong>
				<p style="color:#023ca8;"  class="ui-scroll">Car Accident</p>
			</div>
		</li>
	</ul>
</div>
[/av_codeblock]

[/av_four_fifth][av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-kk8q7cna' admin_preview_bg='']
<p style="text-align: center; white: white; font-size: 14px; color: black;margin-top:-20px;">Past results do not guarantee similar results for any individual case.</p>
[/av_textblock]

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='40' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' id='' custom_class='' av_uid='av-kk8prk4h' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-54a2']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-kk8ocssl' admin_preview_bg='']
<h1 ><span style="color:#023ca8">Car Accident</span> Lawyer
Greenville | <span style="color:#023ca8">Laurens</span></h1>
<p style="text-align:justify;">We believe every injury is personal, regardless if it is a <a href="https://btsmith.wpengine.com/car-accident-lawyer-in-spartanburg-sc/">car accident</a>, <a href="https://btsmith.wpengine.com/your-bicycle-accident-lawyer-in-spartanburg-sc/">bicycle accident</a>, <a href="https://btsmith.wpengine.com/motorcycle-accident-lawyer-in-spartanburg-sc/">motorcycle accident</a> or <a href="https://btsmith.wpengine.com/truck-wreck-lawyer-in-spartanburg-sc/">truck accident</a>. Because of this we take a personal interest in each of our clients. We understand that injuries cause unique challenges—not just physical ones—but also emotional and financial ones. We take the time to learn the details of your situation and then work with you to get your life back on the best possible track. We want to make sure that you get the medical care you need as well as compensation for any property damage you may have incurred.</p>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='backallx2' aria_label='' av_uid='av-381o']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='textcontectx2' av_uid='av-kk8ocssl' admin_preview_bg='']
<h1 style="text-shadow: 1px 1px 1px black; font-size: 46px;"><span style="color: #4a9de6;">Every</span> Injury Is
<span style="color: #4a9de6;">Personal</span></h1>
<a href="/contact/" class="avia-button   avia-icon_select-yes-left-icon avia-size-large avia-position-left " style="background-color:#428aca; border-color:#428aca; color:#ffffff; "><span class="avia_button_icon avia_button_icon_left " aria-hidden="true" data-av_icon="" data-av_iconfont="entypo-fontello"></span><span class="avia_iconbox_title">Contact Us</span></a>
[/av_textblock]

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='150' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' id='' custom_class='' av_uid='av-kk8pjqix' admin_preview_bg='']

[/av_one_half]
[/av_section]";s:15:"background girl";s:2529:"[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' margin='aviaTBmargin' custom_margin='-30px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/slider-5.jpg' attachment='866' attachment_size='full' attach='parallax' position='bottom center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kkpysj0e']
[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='60' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' id='' custom_class='' av_uid='av-kkpzduk2' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' av_uid='av-kkpyuudp' admin_preview_bg='']
<h3 style="text-align: center; font-size: 38px; font-weight: 900; color: white; text-shadow: 1px 1px 1px black;">Vehicle Accident Lawyer</h3>

<hr class="hrwhite" />
<p style="text-align: center; font-size: 18px;">Personal injuries often involve insurance claims…and we are accustomed to dealing with insurance companies on behalf of our clients. Insurance companies often lead with settlement offers that are below what a case is worth. We’ll help you to understand the factors in play and evaluate any settlement offers. Most importantly, we know your rights and will negotiate hard on your behalf to get you the best settlement based on your situation. If we decide together that an offer is insufficient, we will file suit and represent you at trial.</p>
[/av_textblock]

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='60' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' id='' custom_class='' av_uid='av-kkpzduk2' admin_preview_bg='']
[/av_section]";s:18:"car accident model";s:3534:"[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' margin='' custom_margin='0px' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' video_mobile_disabled='' overlay_enable='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='scroll' bottom_border_style='scroll' scroll_down='' custom_arrow_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-2tc6g']
[av_one_half first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-1zhvg']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-kkr4h0c0' admin_preview_bg='']
<h2 style="color: #023ca8; text-align: center; font-size: 30px; font-weight: 900; letter-spacing: 2px;">Car Accident Lawyer</h2>

<hr class="style-seven" />

When Medical Bills, Lost Wages, Frustration, And Pain And Suffering Pile Up After A Car Accident, You Need To Hear Some Good New From a Car Accident Lawyer.

Injured, out of work, medical bills piling up, and not enough money to afford surgery, Tom didn’t know where to turn. Another driver ran a stop sign, causing a horrific accident that sent Tom to the emergency room. The car accident put Tom out of work, so he is not able to properly provide for his family. To top things off, he cannot afford the necessary medical treatment that he needs to be able to return to his work. He feels hopeless and lost.
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-1cud4']

[av_video src='/wp-content/uploads/2021/02/biran-smith-video.mp4' mobile_image='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/video-ocver.jpg' attachment='850' attachment_size='full' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' av_uid='av-kkr4f66w']

[/av_one_half]
[/av_section]";s:11:"default web";s:27308:"[av_slideshow_full size='featured' min_height='0px' stretch='' control_layout='av-control-default' src='' attachment='' attachment_size='' position='top left' repeat='no-repeat' attach='scroll' conditional_play='' animation='slide' transition_speed='' autoplay='false' interval='5' lazy_loading='disabled' id='' custom_class='' av_uid='av-kkcztql2']
[av_slide_full slide_type='image' id='386' video='https://' mobile_image='' fallback_link='https://' title='<span class="titleslider">Laurens Car Accident Lawyer In Laurens, SC</span>' video_format='' video_ratio='16:9' caption_pos='caption_center' custom_title_size='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' heading_tag='' heading_class='' link_apply='button' link='lightbox' link_target='' button_label='Contact Us' button_color='theme-color' link1='page,125' link_target1='' button_label2='Click me' button_color2='light' link2='manually,http://' link_target2='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_uid='av-ofkl'][/av_slide_full]
[/av_slideshow_full]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='#ffffff' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' 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='' shadow='no-border-styling' bottom_border='border-extra-diagonal' bottom_border_diagonal_color='#cbe1ff' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-2yv35']
[av_two_third first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='-20px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-20sjl']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-kkd03ji5' admin_preview_bg='']
<h2 class="pagetittle">Laurens Car Accident Lawyer In Laurens, SC</h2>
<div class="linehr"></div>
<p class="textpage">Lauren's lawyers for car accidents at the Law Office of Brian T. Smith are ready to serve you. If you want to know when to get an attorney for a car accident in Laurens, the simple answer is, as soon as possible after medical attention has been sought. If you were involved in a car accident that was not your fault, contact us today and to speak to our best attorney for your car accident today. A car accident injury attorney will be able to answer any questions about your automobile accident. The case evaluation is FREE so call us today at (864) 662-6821.</p>
<p class="textpage">We receive new inquiries all the time. Tourists and locals alike turn to us for help with their car accident claim. Many call us looking for an auto wreck lawyer right from the scene of the accident. Others turn to us when their case reaches court, or they receive a settlement offer. We gladly help everyone, from answering questions to handling the compensation claim.</p>
<p class="textpage">In our experience, the main obstacle car accident victims encounter is poor knowledge of South Carolina laws. To help eliminate this obstacle, we will review the most important car accident laws here. In fact, every auto wreck attorney should do this when taking over a new client. If you or someone dear was involved in a car accident, the following information should help.</p>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='10px' radius_sync='true' padding='10px,12px,10px,15px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/01/circle-blues-300x300.png' attachment='388' attachment_size='medium' background_position='top left' background_repeat='repeat' highlight_size='1.1' animation='pop-up' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='av-hide-on-mobile' id='' custom_class='sectionshadown' aria_label='' av_uid='av-kkczw7f5']

[av_sidebar widget_area='Menu Home Car Accident' av_uid='av-1rwk5']

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_gradient' custom_bg='' background_gradient_color1='#cbe1ff' background_gradient_color2='#93c0ff' background_gradient_direction='vertical' 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='' shadow='no-border-styling' bottom_border='border-extra-diagonal' bottom_border_diagonal_color='#ffffff' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kkd0hlhv']
[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='-60px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkd3ow4m']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-ycd1' admin_preview_bg='']
<h3>The 5 Most Important Laws Every Laurens, SC, All Car Accidents Lawyers Should Explain To Their Clients</h3>
<div class="linehr"></div>
<h3>1.The Hit-And-Run Law</h3>
<img class="imgpages wp-image-89 alignleft" src="http://exs.788.myftpupload.com/wp-content/uploads/2020/12/bt-rear-end-collision-300x182.jpg" alt="" width="400" height="243" />SC Code § 56-5-1210 makes it mandatory for drivers involved in accidents to stop at the scene. If possible, they should take their car off the roadway to avoid obstructing traffic. Finally, they should check if anyone was injured and request medical assistance.

If you were involved in a car accident and you are thinking of leaving the accident scene, do not. You will only expose yourself to additional penalties. If the other driver fled the scene, do not despair. With the help of an experienced auto wreck attorney, you can identify the driver at fault. You can recover your losses.

Even if the driver remains unidentified, you can seek compensation from your insurer or a third-party. Therefore, remain at the scene and report the accident to the authorities. Call an automobile accident lawyer and gather as much information and evidence as possible. It will come in handy later on.
<h3>2. Duty To Report Car Accidents – What Laurens Top Car Accident Lawyers Recommend</h3>
All serious accidents require reporting. “Serious” refers to accidents involving property damage of a minimum of $1,000, injuries, or death. Although the deadline for reporting such events is 15 days, it is better to do it immediately. This way, the police can come to the scene to investigate. Their report will be valuable evidence for the right auto wreck attorney. Drivers also have the obligation to report any accidents they are involved in to their insurer.

As a driver involved in an accident, you should report the event to both the police and your insurer. Hopefully, they will send their representatives to the scene to investigate. When they do, it helps to have your auto wreck lawyer present. If you do not, be careful with your statements.

It is best to answer questions briefly and to the point. Avoid expressing regrets or making assumptions. Aside from your lawyer, you can assume everyone else will protect their own interests. It is up to you to protect your own.

While at the scene, focus on gathering as much evidence and information as possible. Get contact information from everyone present and take photos of the vehicles involved. Try to document any damage. Look for surveillance cameras that may have recorded the accident. Every piece of evidence could be worth gold in the hands of the right auto wreck attorney.
<h3>3. Minimum Insurance Requirements – Consensus Of Car Accident Injury Lawyers</h3>
As the Department of Insurance explains, all SC drivers need liability insurance coverage. Any car accident lawyer knows that liability insurance covers:
<ul>
 	<li>Bodily injuries</li>
 	<li>Property damage</li>
 	<li>Uninsured/underinsured motorist coverage (optional)</li>
</ul>
The first type of coverage applies to injuries the insured causes to other people. The second type of coverage refers to property damages the insured causes. The third coverage type protects the insured against losses caused by an uninsured/underinsured third-party.

South Carolina laws impose that drivers acquire the following minimum coverage:
<ul>
 	<li>$25,000 / person for bodily injury</li>
 	<li>$50,000 / event for bodily injury</li>
 	<li>$25,000 / event for property damage</li>
</ul>
The acquiring of uninsured/underinsured motorist coverage is not mandatory in SC. The law requires insurance companies to include it in their offer. However, drivers are free to reject it. Most of them do not. Insurance coverage is the first thing a Laurens car accident lawyer will ask their clients to check.

If you get into an accident, check if the driver responsible carries liability insurance. If they do, their insurance will cover any injuries and property damage you incurred. If they are uninsured or underinsured, check your own insurance coverage. An auto wreck lawyer can help with all this and more.

Unless you asked your insurer to eliminate it, you should have uninsured/underinsured coverage. It will cover any damage and injuries an uninsured motorist may cause. If the motorist at fault is underinsured, your insurance will cover the difference. If you are not sure where you stand, a discussion with an automobile accident lawyer will surely help.

At the Law Office of Brian T. Smith, we have handled numerous cases involving uninsured/underinsured motorists. The first thing our auto wreck lawyers do when accepting new cases is to check the available insurance coverage. This way, we determine against whom to file the compensation claim to secure a favorable outcome.
<div class="fl-module fl-module-rich-text fl-node-5b7d84dcb8b44" data-node="5b7d84dcb8b44">
<div class="fl-module-content fl-node-content">
<div class="fl-rich-text">
<div id="cta_sub_txt" class="fl-module fl-module-rich-text fl-node-5b75938782757" data-node="5b75938782757">
<div class="fl-module-content fl-node-content">
<div class="fl-rich-text">
<div id="cta_sub_txt"></div>
</div>
</div>
</div>
</div>
</div>
</div>
<div id="review" class="review-wrapper wp-review-7684 wp-review-star-type wp-review-default-template wp-review-box-full-width">
<div class="review-heading"></div>
</div>
[/av_textblock]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='#ffffff' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' 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='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-o52t']
[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='-50px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkd3rmaq']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-ycd1' admin_preview_bg='']
<h3>4. Accident Fault In South Carolina And Why You Need A Car Accident Attorney</h3>
In South Carolina, there is a “fault” system in place. It means that the party responsible for the accident or their insurer covers the losses they caused. In “no-fault” states, each party covers their own losses. Through insurance, the insurance companies take over the responsibilities of the insured.

Thus, as an accident victim, you turn to the insurer of the driver at fault for compensation. If the driver is uninsured, it is important to work with an automobile accident lawyer. Generally, your two options to recover your losses are to:

Seek compensation from the driver at fault through a civil lawsuit. You should consider enlisting the help of a Laurens auto wreck lawyer for that. The procedures are quite lengthy and complicated so you will need all the help you can get.

Seek compensation from your own insurer based on your uninsured motorist coverage. Again, the experience of an auto wreck attorney will come in handy. You will need to assess your available coverage and file the claim with your insurer. You will also have to prove how the accident occurred and all the losses you incurred.

If they are underinsured, it is possible to seek the available compensation from their insurer. You can try to recover the rest of your losses from them in civil court or from your insurer. Again, to identify the best option available, it helps to consult an auto wreck attorney.

If you are at fault for your accident, you may lose the right to compensation. Your fault share should not exceed that of the other driver. The party you file the compensation claim with will obviously try to prove the opposite. To protect your rights, consider asking for legal help.
<h3>5. The Statute Of Limitations Or How Long You Have To Consult A Lawyer For Car Accident</h3>
Just like all states, South Carolina has its own statute of limitations. These are legal rules defining the period for filing a lawsuit. The periods differ according to the type of action. You will find them explained under Title 15, Chapter 3 of the South Carolina Code. To make sure you file your claim or lawsuit in time, consult an auto wreck attorney.

Car accident victims have three years to recover losses related to both personal injury and property damage. The countdown begins on the day of the accident. In some cases, it may be possible to invoke the “discovery” rule.

It would mean showing that you discovered your injuries and property damages much later. If you succeed, the countdown will begin on the day when you discovered the injuries. However, this is very difficult to accomplish without the assistance of an automobile accident lawyer.

Another option would be to ask for an extension on the statute of limitations. The term would be “tolling”. It is possible when the accident victim is a minor or develops certain forms of disability.

For minors, the clock will start running when they turn 18. For disabled persons, it starts running when the person recovers from their disability. The auto wreck lawyer will have to show that their client was unable to take legal action sooner.
<h3>Types Of Damages Laurens Car Accident Attorneys May Claim</h3>
<div class="linehr"></div>
<img class="imgpages wp-image-415 alignright" src="http://exs.788.myftpupload.com/wp-content/uploads/2021/01/car_accident_12-300x206.jpg" alt="" width="400" height="275" />South Carolina law only limits the value of claims on medical malpractice and against the government. For medical malpractice claims, the cap is $350,000 (SC Code § 15-32-220). For claims against the government, the cap is $300,000 (SC Code § 15-78-120).

There are no limits to compensation claims against drivers or third-parties. Of course, the claim can only cover certain types of damages. In order to obtain their compensation, the claimant or their auto wreck attorney will have to prove:
<ul>
 	<li>That the respective damages are the direct result of the accident</li>
 	<li>That the defendant to their claim was directly responsible for the accident</li>
 	<li>That the value of the damages matches the claimed compensation</li>
</ul>
An auto accident compensation claim may cover two main types of damages: economic and non-economic. The former category refers to accident-related expenses. It covers car repairs, treatment, necessary medical equipment, lost wages and earning capacity. You should be able to prove those even without an automobile accident lawyer.

The latter category refers to losses without a clear value. Examples are pain and suffering, loss of consortium, or loss of life enjoyment. These types of damages have the potential to reach the highest value. They are also the most difficult to prove. Seeking compensation for them is a job for an experienced Laurens car accident lawyer.
<h3>When To Get An Attorney For A Car Accident</h3>
<div class="linehr"></div>
<h4>When Car Accident Compensation Is Needed</h4>
As explained above, you can seek compensation from an insurance company or from an individual. In both situations, you could use the advice and assistance of an attorney. Reviewing the procedures involved in both situations will help you understand why.

To seek compensation from an insurance company, you have to send a notice of claim. It is a letter explaining your intentions and briefly describing how the accident occurred. After that, you will have to substantiate your claim.

This means supporting it with evidence. You will need to show how the accident occurred, what damage it caused, and the corresponding value. Examples of evidence include photos, recordings, testimonies, medical reports, bills and price estimates. The same type of evidence will be necessary for those filing a civil lawsuit.

Both processes take time and involve following strict procedures. Their result depends on the evidence available and the skills of the automobile accident lawyer. The claim defendant may offer a settlement. If that is the case, it is best to have an auto wreck lawyer negotiate it. The latter can easily determine if the settlement is worth accepting. If it is not, there are several appeal options to pursue.
<div class="fl-module fl-module-heading fl-node-5b7d867a0d0c5" data-node="5b7d867a0d0c5">
<div class="fl-module-content fl-node-content">
<h3 class="fl-heading"><span class="fl-heading-text">Schedule A Consultation With A Laurens Car Accident Injury Attorney From Brian T. Smith</span></h3>
<div class="linehr"></div>
</div>
</div>
<div class="fl-module fl-module-rich-text fl-node-5b7d84dcb8b44" data-node="5b7d84dcb8b44">
<div class="fl-module-content fl-node-content">
<div class="fl-rich-text">
<p class="size">As an car wreck victim, you deserve fair compensation. At Brian T. Smith, we have <strong>car accidents lawyers</strong> that can help you obtain it. You have nothing to lose by discussing your case with an attorney for car accidents at our Laurens firm. The preliminary consultation is free, and we accept contingency agreements. This means that if you work with us, you only pay if and when we win. Our fee will represent a percentage of the amount we obtain for you. This means your car accident personal injury attorney is motivated to work hard and not settle for less than you deserve. Call our office now at (864) 662-6821 and schedule your free case review with one of our <strong>lawyers that deal with car accidents</strong>. Call today.</p>

<div class="fl-module fl-module-heading fl-node-5b7591e7eb4fe" data-node="5b7591e7eb4fe">
<div class="fl-module-content fl-node-content"></div>
</div>
<div id="cta_sub_txt" class="fl-module fl-module-rich-text fl-node-5b75938782757" data-node="5b75938782757">
<div class="fl-module-content fl-node-content">
<div class="fl-rich-text">
<div id="cta_sub_txt"></div>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="fl-module fl-module-rich-text fl-node-5b7d84dcb8b44" data-node="5b7d84dcb8b44">
<div class="fl-module-content fl-node-content">
<div class="fl-rich-text">
<div id="cta_sub_txt" class="fl-module fl-module-rich-text fl-node-5b75938782757" data-node="5b75938782757">
<div class="fl-module-content fl-node-content">
<div class="fl-rich-text"></div>
</div>
</div>
</div>
</div>
</div>
<div id="review" class="review-wrapper wp-review-7684 wp-review-star-type wp-review-default-template wp-review-box-full-width">
<div class="review-heading"></div>
</div>
[/av_textblock]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' 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='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' av-desktop-hide='aviaTBav-desktop-hide' av-medium-hide='aviaTBav-medium-hide' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kkd3so55']
[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='10px' radius_sync='true' padding='10px,12px,10px,15px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/01/circle-blues-300x300.png' attachment='388' attachment_size='medium' background_position='top left' background_repeat='repeat' highlight_size='1.1' animation='pop-up' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='sectionshadown' aria_label='' av_uid='av-kkczw7f5']

[av_sidebar widget_area='Menu Home Car Accident' av_uid='av-1rwk5']

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/01/car_accident_5-bg.jpg' attachment='417' attachment_size='full' attach='parallax' position='center center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kkd4dg0n']
[av_one_full first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-qkyp']

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='75' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' id='' custom_class='' av_uid='av-kkd4g5ub' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' av_uid='av-kkd4fqgr' admin_preview_bg='']
<h3 style="text-align: center; font-size: 46px;">Free Case Evaluation</h3>
<p style="text-align: center; font-size: 24;">Call us 24/7 at (864) 239-2007 or fill out the form below to receive a free and confidential consultation.</p>
[/av_textblock]

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='75' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' id='' custom_class='' av_uid='av-kkd4g5ub' admin_preview_bg='']

[/av_one_full]
[/av_section]";s:14:"footer espanol";s:4866:"[av_layout_row border='' min_height_percent='' min_height_pc='25' min_height='0' color='main_color' mobile='av-flex-cells' mobile_breaking='' id='footerlist' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-cypug']
[av_cell_one_half vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/personal_injury_practice_area.jpg' attachment='1014' attachment_size='full' background_attachment='scroll' background_position='center center' background_repeat='stretch' link='manually,/personal-injury/' linktarget='' link_hover='opacity80' mobile_display='' custom_class='' av_uid='av-kkbsrk8c']

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='80' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' id='' custom_class='' av_uid='av-kkbsy272' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' av_uid='av-kkbsxqxm' admin_preview_bg='']
<h3 style="font-size: 40px; font-weight: 900; letter-spacing: 2px; text-shadow: 1px 1px 1px black;">Personal Injury</h3>
<p style="font-size:19px;text-shadow:1px 1px 1px black;">The Law Office of Brian T. Smith can represent clients who
have suffered serious personal injury as a result of the negligence of others.
[/av_textblock]

[av_button label='Learn More' icon_select='yes' icon='ue879' font='entypo-fontello' link='manually,/personal-injury/' link_target='' size='medium' position='left' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='' av_uid='av-kkrarlfd' admin_preview_bg='']

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='30' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' id='' custom_class='' av_uid='av-kkbsy272' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/car_accident-practice_area.jpg' attachment='1016' attachment_size='full' background_attachment='scroll' background_position='center center' background_repeat='stretch' link='manually,/car-accidents/' linktarget='' link_hover='opacity80' mobile_display='' custom_class='' av_uid='av-9wqqo']

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='80' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' id='' custom_class='' av_uid='av-kkbsy272' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' av_uid='av-kkbsxqxm' admin_preview_bg='']
<h3 style="font-size: 40px; font-weight: 900; letter-spacing: 2px; text-shadow: 2px 2px 2px black;">Car Accident</h3>
<p style="font-size: 19px; text-shadow: 1px 1px 1px black;">When Medical Bills and Suffering Pile Up After A Car Accident,
You Need To Hear Some Good New From a Car Accident Lawyer.
[/av_textblock]

[av_button label='Learn More' icon_select='yes' icon='ue879' font='entypo-fontello' link='manually,/car-accidents/' link_target='' size='medium' position='left' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='' av_uid='av-kkrarlfd' admin_preview_bg='']

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='30' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' id='' custom_class='' av_uid='av-kkbsy272' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]";s:12:"fotter final";s:24736:"[av_layout_row border='' min_height_percent='' min_height_pc='25' min_height='0' color='main_color' mobile='av-flex-cells' mobile_breaking='' id='' custom_class='footergrid' aria_label='' av_element_hidden_in_editor='0' av_uid='av-k8x5mgvb']
[av_cell_three_fifth vertical_align='top' padding='40px,80px,30px,80px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' custom_class='' av_uid='av-cu6ar']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' av_uid='av-k8w9zidr' admin_preview_bg='']
<h3 style="font-size: 40px; color: white; line-height: 28px; text-align: center; font-weight: 900;">WHY <span style="color: #ffae00;">CHOOSE </span> US?</h3>

<hr class="style-one" />
<p style="text-align: justify;">If you would like additional information about our services or if you would like to schedule a consultation, please fill out the form below and we will get back to you as quickly as possible.</p>
[/av_textblock]

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='-5px,-5px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='bottom-to-top' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-n8faj']

[av_iconlist position='left' iconlist_styling='av-iconlist-small' custom_title_size='20' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' custom_title='#ffffff' custom_content='#ffffff' color='custom' custom_bg='' custom_font='#ffffff' custom_border='' animation='' alb_description='' id='' custom_class='' av_uid='av-k8x6h6er' admin_preview_bg='']
[av_iconlist_item title=' Office' icon='ue842' font='entypo-fontello' heading_tag='' heading_class='footerarea' link='' linktarget='' linkelement='' av_uid='av-11d0ny']
25 Maple Avenue
Hastings-on-Hudson NY 10706
Suite 3B
[/av_iconlist_item]
[av_iconlist_item title='NYC Office - By Appt. Only' icon='ue842' font='entypo-fontello' heading_tag='' heading_class='footerarea' link='' linktarget='' linkelement='' av_uid='av-8b346']
8 West 126th Street
New York, NY 10027
[/av_iconlist_item]
[av_iconlist_item title='Phone' icon='ue854' font='entypo-fontello' heading_tag='' heading_class='footerarea' link='' linktarget='' linkelement='' av_uid='av-se0ku']
Office: 914.588.9229
[/av_iconlist_item]
[av_iconlist_item title='Email' icon='ue805' font='entypo-fontello' heading_tag='' heading_class='footerarea' link='' linktarget='' linkelement='' av_uid='av-jwft2']
<a href="mailto:Lloyd@specialedlegalinfo.com?subject=Request%20for%20more%20info" target="_self">Lloyd@specialedlegalinfo.com</a>
[/av_iconlist_item]
[av_iconlist_item title='Facebook' icon='ue8f5' font='entypo-fontello' heading_tag='' heading_class='footerarea' link='' linktarget='' linkelement='' av_uid='av-ciq7y']
<a href="https://www.facebook.com/SpecialEdLegalInfo">Click Here</a>
[/av_iconlist_item]
[av_iconlist_item title='Business Hours' icon='ue862' font='entypo-fontello' heading_tag='' heading_class='footerarea' link='' linktarget='' linkelement='' av_uid='av-7p3g6']
Mon-Fri: 8:30 am – 5 pm
[/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='15px,-10px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='bottom-to-top' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-n8faj']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' av_uid='av-k8w9zidr' admin_preview_bg='']
<h3>Main Office</h3>
<a href="https://www.google.com/maps?ll=40.996028,-73.883289&z=16&t=m&hl=en&gl=US&mapclient=embed&q=25+Maple+Ave+Hastings-On-Hudson,+NY+10706" target="_blank" rel="noopener"><img class="alignnone wp-image-33829 size-medium" style="border: 2px solid #ffae00; padding: 2px;" src="/wp-content/uploads/2020/11/map.jpg" alt="" width="300" height="183" /></a>
[/av_textblock]

[/av_one_half][/av_cell_three_fifth][av_cell_two_fifth av_uid='av-b6ycr']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='bottom-to-top' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-k8xboqtr']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-k8w9zidr' admin_preview_bg='']
<h3 style="font-size: 40px;color: white; line-height: 28px; text-align: center; font-weight: 900;">Contact <span style="color: #ffae00;"> Us</span></h3>

<hr class="style-one" />
[/av_textblock]

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' alb_description='' id='formcolor2' custom_class='' av_uid='av-k8x5v3wv']
[contact-form-7 id="188" title="Contact form 1"]
[/av_codeblock]

[/av_one_full][/av_cell_two_fifth]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_gradient' custom_bg='' background_gradient_color1='#777777' background_gradient_color2='#191919' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_enable='aviaTBoverlay_enable' overlay_opacity='0.5' overlay_color='' overlay_pattern='{{AVIA_BASE_URL}}images/background-images/linen-for-dark-background.png' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-63ts']
[av_one_fourth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-8bzw']

[/av_one_fourth][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='right-to-left' mobile_breaking='' mobile_display='' av_uid='av-51u0' id='' custom_class='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-k18mlsv0' admin_preview_bg='']
<h3 style="text-align: center;font-size: 28px; color: white;">WE CAN HELP YOU WITH</h3>

<hr class="style-seven" />
[/av_textblock]

[/av_one_half][av_one_fourth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-8bzw']

[/av_one_fourth][av_one_fourth first min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='top-to-bottom' link='manually,https://www.specialedlegalinfo.com/new-york-special-education-law/' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-3eu4']

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' alb_description='' id='' custom_class='' av_uid='av-k1gibwb7']
<div class="fancy-box" id="one1">
    <div class="overlay hidden2"></div>
    <div class="slideup">
        <div class="visible">
            <span>
     
            </span>
            <h3> <span style="font-size: 24px;color:white";>Special Education Law</span></h3>
        </div> 
        <div class="hidden2">
            <p style="font-size:15px;">Are you concerned that your school’s evaluations did not identify all of your child’s weaknesses?</p>
        </div>
    </div>
</div>
[/av_codeblock]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='top-to-bottom' link='manually,https://www.specialedlegalinfo.com/new-york-tuition-reimbursement-and-prospective-funding/' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-3eu4']

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' alb_description='' id='' custom_class='' av_uid='av-k1gibwb7']
<div class="fancy-box" id="two">
    <div class="overlay hidden2"></div>
    <div class="slideup">
        <div class="visible">
            <span>
         
            </span>
            <h3> <span style="font-size: 24px;color:white";>Tuition Reimbursement and Prospective Funding</span></h3>
        </div> 
        <div class="hidden2">
            <p style="font-size:15px;">Is your child’s district unable to meet her needs within the district? .</p>
        </div>
    </div>
</div>
[/av_codeblock]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='top-to-bottom' link='manually,/compensatory-or-makeup-services/' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-3eu4']

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' alb_description='' id='' custom_class='' av_uid='av-k1gibwb7']
<div class="fancy-box" id="three">
    <div class="overlay hidden2"></div>
    <div class="slideup">
        <div class="visible">
            <span>
         
            </span>
            <h3 style="font-size: 24px;color:white";>Compensatory or Makeup Services</span></h3>
        </div> 
        <div class="hidden2">
            <p style="font-size:15px;">Has your child missed too many services in his school?</p>
        </div>
    </div>
</div>
[/av_codeblock]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='top-to-bottom' link='manually,/bullying-and-violence-in-the-schools/' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-3eu4']

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' alb_description='' id='' custom_class='' av_uid='av-k1gibwb7']
<div class="fancy-box" id="four">
    <div class="overlay hidden2"></div>
    <div class="slideup">
        <div class="visible">
            <span>
   
            </span>
            <h3 style="font-size: 24px;color:white";>Bullying and Violence in the schools</h3>
        </div> 
        <div class="hidden2">
            <p style="font-size:15px;">Is your child being bullied in school?</p>
        </div>
    </div>
</div>
[/av_codeblock]

[/av_one_fourth][av_one_fourth first min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='-15px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='top-to-bottom' link='manually,https://www.specialedlegalinfo.com/new-york-school-district-due-process-hearings/' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-3eu4']

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' alb_description='' id='' custom_class='' av_uid='av-k1gibwb7']
<div class="fancy-box" id="five">
    <div class="overlay hidden2"></div>
    <div class="slideup">
        <div class="visible">
            <span>
   
            </span>
            <h3 style="font-size: 24px;color:white";>Due Process Hearings</h3>
        </div> 
        <div class="hidden2">
            <p style="font-size:15px;">Have you hit an impasse with your school?</p>
        </div>
    </div>
</div>
[/av_codeblock]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='top-to-bottom' link='manually,https://www.specialedlegalinfo.com/new-york-504-education-plan/' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-3eu4']

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' alb_description='' id='' custom_class='' av_uid='av-k1gibwb7']
<div class="fancy-box" id="six">
    <div class="overlay hidden2"></div>
    <div class="slideup">
        <div class="visible">
            <span>
   
            </span>
            <h3 style="font-size: 24px;color:white";>504 Plans</h3>
        </div> 
        <div class="hidden2">
            <p style="font-size:15px;">Does your child have a disability (physical, mental, or emotional impairment)?</p>
        </div>
    </div>
</div>
[/av_codeblock]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='top-to-bottom' link='manually,https://www.specialedlegalinfo.com/new-york-individualized-education-program/' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-3eu4']

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' alb_description='' id='' custom_class='' av_uid='av-k1gibwb7']
<div class="fancy-box" id="seven">
    <div class="overlay hidden2"></div>
    <div class="slideup">
        <div class="visible">
            <span>
   
            </span>
            <h3 style="font-size: 24px;color:white";>IEP (CSE) Meetings</h3>
        </div> 
        <div class="hidden2">
            <p style="font-size:15px;">Do you feel overwhelmed at IEP meetings? </p>
        </div>
    </div>
</div>
[/av_codeblock]

[/av_one_fourth][av_one_fourth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='top-to-bottom' link='manually,/consultations/' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-3eu4']

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' alb_description='' id='' custom_class='' av_uid='av-k1gibwb7']
<div class="fancy-box" id="eight">
    <div class="overlay hidden2"></div>
    <div class="slideup">
        <div class="visible">
            <span>
   
            </span>
            <h3 style="font-size: 24px;color:white";>Consultations</h3>
        </div> 
        <div class="hidden2">
            <p style="font-size:15px;">Do you want to consult with someone knowledgeable to ensure your child... </p>
        </div>
    </div>
</div>
[/av_codeblock]

[/av_one_fourth][av_one_half first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-h7u6m']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-ki2oqhrh' admin_preview_bg='']
<img class="alignnone wp-image-140" src="https://www.specialedlegalinfo.com/wp-content/uploads/2020/11/logo-Lloyd-300x62.png" alt="" width="250" height="51" />
<p style="text-align: justify; color: white;margin-bottom:-20px;">The law office of Lloyd Donders, Esq. is uniquely positioned to offer our clients the knowledge and tools to aggressively advocate for their children to get the educational support they need.</p>

<form action="https://www.paypal.com/cgi-bin/webscr" method="post" target="_top">
     <input name="cmd" type="hidden" value="_s-xclick" />
         <input name="hosted_button_id" type="hidden" value="NC8LUKVXQKCU6" />
              <input alt="PayPal - The safer, easier way to pay online!" name="submit" src="https://www.specialedlegalinfo.com/wp-content/uploads/2021/01/paypal-smart-checkout-buttons-2.jpg" type="image" />
<img src="https://www.paypalobjects.com/en_US/i/scr/pixel.gif" alt="" width="1" height="1" border="0" />
</form>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='postcolor' custom_class='' aria_label='' av_uid='av-87j12']

[av_postslider link='category,5,6,7,8,10,4,3,9,12,11,1' wc_prod_visible='' prod_order_by='' prod_order='' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' items='6' offset='0' contents='title' columns='3' preview_mode='custom' image_size='square' autoplay='no' interval='5' lazy_loading='disabled' alb_description='' id='' custom_class='' av_uid='av-ki2oun1r']

[/av_one_half]
[/av_section]";s:17:"free consultation";s:1951:"[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' margin='aviaTBmargin' custom_margin='-30px,-10px' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/01/white_leather_white_bg.jpg' attachment='289' attachment_size='full' attach='scroll' position='center center' repeat='repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kkpysj0e']
[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-kkpyuudp' admin_preview_bg='']
<h3 style="text-align: center; font-size: 42px; font-weight: 900; color: #023ca8;">Free Case Evaluation</h3>

<hr class="style-seven" />
<p style="text-align: center; font-size: 28px;"><span style=" color: #023ca8;font-weight:900;line-height:32px;">Every Injury is Personal </span>.Call us 24/7 at (864) 239-2007 or fill out the form below to receive a free and confidential consultation.</p>
[/av_textblock]

[av_button label='Contact Us' icon_select='yes' icon='ue805' font='entypo-fontello' link='page,125' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='custom' custom_bg='#ffffff' custom_font='#000000' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='' av_uid='av-kkpzaid1' admin_preview_bg='']
[/av_section]";s:11:"images menu";s:14473:"[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' margin='' custom_margin='0px' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' video_mobile_disabled='' overlay_enable='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='scroll' bottom_border_style='scroll' scroll_down='' custom_arrow_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-1fxjw']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='5px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkn55o10']

[av_image src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/car-accident-miniatura-300x300.jpg' attachment='786' attachment_size='medium' copyright='' caption='yes' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='top-to-bottom' hover='av-hover-grow' appearance='' link='page,25' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='av-kkn55bcr' admin_preview_bg='']
<p style="font-weight:900;text-align:center">Car Accident</p>
[/av_image]

[/av_one_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='5px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkn55o10']

[av_image src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/bus-accident-miniatura-300x300.jpg' attachment='788' attachment_size='medium' copyright='' caption='yes' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='top-to-bottom' hover='av-hover-grow' appearance='' link='page,15' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='av-kkn55bcr' admin_preview_bg='']
<p style="font-weight:900;text-align:center">Bus Accident</p>
[/av_image]

[/av_one_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='5px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkn55o10']

[av_image src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/drunk-driving-miniatura-300x300.jpg' attachment='792' attachment_size='medium' copyright='' caption='yes' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='top-to-bottom' hover='av-hover-grow' appearance='' link='page,17' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='av-kkn55bcr' admin_preview_bg='']
<p style="font-weight:900;text-align:center">Drunk Driving</p>
[/av_image]

[/av_one_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='5px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkn55o10']

[av_image src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/motorcycle-accident-miniatura-300x300.jpg' attachment='793' attachment_size='medium' copyright='' caption='yes' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='top-to-bottom' hover='av-hover-grow' appearance='' link='page,19' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='av-kkn55bcr' admin_preview_bg='']
<p style="font-weight:900;text-align:center">Motorcycle Accidents</p>
[/av_image]

[/av_one_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='5px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkn55o10']

[av_image src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/pedestrian-accidents-miniatura-300x300.jpg' attachment='794' attachment_size='medium' copyright='' caption='yes' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='top-to-bottom' hover='av-hover-grow' appearance='' link='page,44' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='av-kkn55bcr' admin_preview_bg='']
<p style="font-weight:900;text-align:center">Pedestrian Accidents</p>
[/av_image]

[/av_one_fifth][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='2px,5px,5px,5px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkn55o10']

[av_image src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/rear-end-collision-miniatura-300x298.jpg' attachment='797' attachment_size='medium' copyright='' caption='yes' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='top-to-bottom' hover='av-hover-grow' appearance='' link='page,21' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='av-kkn55bcr' admin_preview_bg='']
<p style="font-weight:900;text-align:center">Rear End collision</p>
[/av_image]

[/av_one_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='2px,5px,5px,5px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkn55o10']

[av_image src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/side-collision-miniatura-300x300.jpg' attachment='799' attachment_size='medium' copyright='' caption='yes' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='top-to-bottom' hover='av-hover-grow' appearance='' link='page,23' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='av-kkn55bcr' admin_preview_bg='']
<p style="font-weight:900;text-align:center">Side Impact Collision</p>
[/av_image]

[/av_one_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='2px,5px,5px,5px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkn55o10']

[av_image src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/tractor-accident-miniatura-300x300.jpg' attachment='800' attachment_size='medium' copyright='' caption='yes' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='top-to-bottom' hover='av-hover-grow' appearance='' link='page,38' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='av-kkn55bcr' admin_preview_bg='']
<p style="font-weight:900;text-align:center">Tractor Accidents</p>
[/av_image]

[/av_one_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='2px,5px,5px,5px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkn55o10']

[av_image src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/train-accidents-miniatura-300x300.jpg' attachment='803' attachment_size='medium' copyright='' caption='yes' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='top-to-bottom' hover='av-hover-grow' appearance='' link='' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='av-kkn55bcr' admin_preview_bg='']
<p style="font-weight:900;text-align:center">Train Accidents</p>
[/av_image]

[/av_one_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='2px,5px,5px,5px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkn55o10']

[av_image src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/uber-accidents-miniatura-300x300.jpg' attachment='801' attachment_size='medium' copyright='' caption='yes' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='top-to-bottom' hover='av-hover-grow' appearance='' link='page,46' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='av-kkn55bcr' admin_preview_bg='']
<p style="font-weight:900;text-align:center">Uber Accidents</p>
[/av_image]

[/av_one_fifth]
[/av_section]";s:9:"old about";s:3203:"[av_layout_row border='' min_height_percent='' min_height_pc='25' min_height='0' color='main_color' mobile='av-flex-cells' mobile_breaking='' id='' custom_class='aboutgrid' aria_label='' av_element_hidden_in_editor='0' av_uid='av-4r0a']
[av_cell_one_half vertical_align='top' padding='30px,60px,30px,80px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' custom_class='' av_uid='av-2svk']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-kk8ocssl' admin_preview_bg='']
<h1 ><span style="color:#023ca8">Car Accident</span> Lawyer
Greenville | <span style="color:#023ca8">Laurens</span></h1>
<p style="text-align:justify;">We believe every injury is personal, regardless if it is a <a href="https://btsmith.wpengine.com/car-accident-lawyer-in-spartanburg-sc/">car accident</a>, <a href="https://btsmith.wpengine.com/your-bicycle-accident-lawyer-in-spartanburg-sc/">bicycle accident</a>, <a href="https://btsmith.wpengine.com/motorcycle-accident-lawyer-in-spartanburg-sc/">motorcycle accident</a> or <a href="https://btsmith.wpengine.com/truck-wreck-lawyer-in-spartanburg-sc/">truck accident</a>. Because of this we take a personal interest in each of our clients. We understand that injuries cause unique challenges—not just physical ones—but also emotional and financial ones. We take the time to learn the details of your situation and then work with you to get your life back on the best possible track. We want to make sure that you get the medical care you need as well as compensation for any property damage you may have incurred.</p>
[/av_textblock]

[/av_cell_one_half][av_cell_one_half vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' custom_class='backallx2' av_uid='av-kk8sl6kr']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='textcontectx2' av_uid='av-kk8ocssl' admin_preview_bg='']
<h1 style="text-shadow: 1px 1px 1px black; font-size: 46px;"><span style="color: #4a9de6;">Every</span> Injury Is
<span style="color: #4a9de6;">Personal</span></h1>
<a href="/contact/" class="avia-button   avia-icon_select-yes-left-icon avia-size-large avia-position-left " style="background-color:#428aca; border-color:#428aca; color:#ffffff; "><span class="avia_button_icon avia_button_icon_left " aria-hidden="true" data-av_icon="" data-av_iconfont="entypo-fontello"></span><span class="avia_iconbox_title">Contact Us</span></a>
[/av_textblock]

[/av_cell_one_half]
[/av_layout_row]";s:11:"old numbers";s:3321:"[av_layout_row border='' min_height_percent='' min_height_pc='25' min_height='0' color='main_color' mobile='av-flex-cells' mobile_breaking='' id='' custom_class='aboutgrid' aria_label='' av_element_hidden_in_editor='0' av_uid='av-cb08']
[av_cell_one_fifth av_uid='av-anmq']

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' av-small-hide='aviaTBav-small-hide' av-mini-hide='aviaTBav-mini-hide' id='' custom_class='' av_uid='av-kkcqv1s0' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-kk8q20tz' admin_preview_bg='']
<div style="transform: skewX(-30deg); display: -ms-flexbox; background-color: #023ca8; padding: 2px;">
<p style="transform: skewX(30deg); text-align: center; font-size: 1.856rem; font-family: Lora; color: white; font-weight: bold; text-shadow: 1px 1px 1px #023ca8;">Recent Results</p>

</div>
<p style="text-align:center;"><span class="av-icon-char" style="font-size:46px;line-height:46px;" aria-hidden="true" data-av_icon="" data-av_iconfont="flaticon"></span></p>
[/av_textblock]

[/av_cell_one_fifth][av_cell_four_fifth av_uid='av-6v5e']

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='-100' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' av-desktop-hide='aviaTBav-desktop-hide' av-medium-hide='aviaTBav-medium-hide' id='' custom_class='' av_uid='av-kkbn3jq9' admin_preview_bg='']

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' alb_description='' id='' custom_class='' av_uid='av-kk8jbn5a']
<div class="section-container">
	<ul class="panel-wrap section-flex">
		<li class="panel-item">
			<div class="mask">
				<strong>
					<span class="num"> $1.8      </span>
					<span class="million">Million</span>
				</strong>
				<p style="color:#023ca8;" class="ui-scroll">Car Accident</p>
			</div>
		</li>
		<li class="panel-item">
			<div class="mask">
				<strong>
					<span class="num">$935.000</span>
					<span class="million">Thousand</span>
				</strong>
				<p style="color:#023ca8;"  class="ui-scroll">Car Accident</p>
			</div>
		</li>
		<li class="panel-item">
			<div class="mask">
				<strong>
					<span class="num">$540,000</span>
					<span class="million">Thousand</span>
				</strong>
				<p style="color:#023ca8;"  class="ui-scroll">Workers Comp</p>
			</div>
		</li>
		<li class="panel-item">
			<div class="mask">
				<strong>
					<span class="num">$72,500</span>
					<span class="million">Thousand</span>
				</strong>
				<p style="color:#023ca8;"  class="ui-scroll">Car Accident</p>
			</div>
		</li>
		<li class="panel-item">
			<div class="mask">
				<strong>
					<span class="num">$60,000</span>
					<span class="million">Thousand</span>
				</strong>
				<p style="color:#023ca8;"  class="ui-scroll">Car Accident</p>
			</div>
		</li>
	</ul>
</div>
[/av_codeblock]

[/av_cell_four_fifth]
[/av_layout_row]";s:16:"parte 2 personal";s:2697:"[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/slider-5.jpg' attachment='866' attachment_size='full' attach='fixed' position='center center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kkr4icyl']
[av_one_full first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-10y1o']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' av_uid='av-kkr4h0c0' admin_preview_bg='']
<h2 style="color: white; text-align: center; font-size: 30px; font-weight: 900; letter-spacing: 2px;">The Insurance Companies Know How To Fight</h2>

<hr class="hrwhite" />

The insurance company for the person who caused the crash isn’t helping Tom. Either the adjuster won’t answer his calls, won’t give him straight answers, or is rude and pushy. The insurance company only cares about one thing: their bottom line. Tom knows they have near unlimited resources to fight his case, and without a knowledgeable attorney on his team, he sees he doesn’t stand much of a chance taking on the insurance company.

Tom’s story is fictional, but it is one that our law firm sees all too often in real life. Experiencing a car accident can turn your life upside down. Most people, have never gone through an experience like this before and don’t know how to respond. That’s where the Law Office of Brian T Smith can help.
[/av_textblock]

[/av_one_full]
[/av_section]";s:14:"parte no gusta";s:4511:"[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' margin='aviaTBmargin' custom_margin='0px,-60px' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/01/white_leather_white_bg.jpg' attachment='289' attachment_size='full' attach='scroll' position='top center' repeat='repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='abouthr' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kkpysj0e']
[av_three_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='-30px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/02/pw_maze_black.png' attachment='939' attachment_size='full' background_position='top left' background_repeat='repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='backallx2' aria_label='' av_uid='av-kkqzqvhr']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='textcontectx2' av_uid='av-kkpyuudp' admin_preview_bg='']
<h3 style="text-align: center; font-size: 38px; font-weight: 900; color: white; text-shadow: 1px 1px 1px black;">We'll Be Your Personal Advocate</h3>

<hr class="hrwhite" />
<p style="font-size: 17px; text-align: justify;">We separate ourselves by taking a personal interest in each of our clients. We understand that injuries cause unique challenges not just physical but also emotional and financial ones. We take the time to learn the details of your situation and then work with you to get your life back on the best possible track. We want to make sure that you get the medical care you need as well as compensation for any property damage you may have incurred.</p>
[/av_textblock]

[/av_three_fifth][av_two_fifth min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='av-hide-on-mobile' id='' custom_class='' aria_label='' av_uid='av-4rjg']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-kkr0t4bj' admin_preview_bg='']
<img class="wp-image-941 aligncenter" style="margin-top: -50px; -webkit-box-shadow: 11px 11px 34px -3px rgba(0,0,0,0.45); -moz-box-shadow: 11px 11px 34px -3px rgba(0,0,0,0.45); box-shadow: 11px 11px 34px -3px rgba(0,0,0,0.45); border: 2px solid #023ca8; border-radius: 6%;" src="http://exs.788.myftpupload.com/wp-content/uploads/2021/02/brian-smith-prifile-13-206x300.jpg" alt="" width="246" height="359" />
[/av_textblock]

[av_button label='About Us' icon_select='yes' icon='ue80b' font='entypo-fontello' link='page,8' link_target='' size='medium' position='center' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='imagebutton' av_uid='av-kkr1a24q' admin_preview_bg='']

[/av_two_fifth]
[/av_section]";s:8:"practice";s:1328:"[av_layout_row border='' min_height_percent='' min_height_pc='25' min_height='0' color='main_color' mobile='av-flex-cells' mobile_breaking='' id='slider' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kk7bbsox']
[av_cell_one_full av_uid='av-13ifm']

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' alb_description='' id='' custom_class='' av_uid='av-kk7bbe8x']
<div class="banners" id="lucholj-banner">
<div class="banner active-banner"><div class="bottom-box welcometext"><span style="font-size: 2.199rem;font-family: Lora; color: black; text-shadow: 1px 1px 1px black;font-weight: 500;line-height:20px;text-shadow: 1px 1px 1px #023ca8;"> Attorneys </span> <br> <div class="linehrcontent"> </div> <br>Schneider & Onofry attorneys include six AV-Preeminent ratings, four Super Lawyers selections, four Best Lawyers®selections, four members of the American Board of Trial Advocates, and a former Best Lawyers' Phoenix "Lawyer of the Year" (Insurance Litigation).
</div></div>
        <div class="banners-menu">
<span class="bannertittle">Practice Areas</span>
<div class="linehr"> </div>
            <ul>
            </ul>
        </div>
        <div class='overlay'></div>
    </div>
<div style="clear:both"></div>
[/av_codeblock]

[/av_cell_one_full]
[/av_layout_row]";s:12:"seccion azul";s:3645:"[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='#cbe1ff' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' 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='' shadow='no-shadow' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kkr83zf6']
[av_two_third first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-1ru6g']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#000000' id='' custom_class='' av_uid='av-kkr4h0c0' admin_preview_bg='']
<h2 style="color: black; font-size: 30px; font-weight: 900; letter-spacing: 2px; text-align: left;">Reckless Driving And Road Rage</h2>
<div class="linehr"></div>
Reckless driving is when an individual drives unsafely with a deliberate disregard for the safety of others and with the full knowledge that their driving could result in an accident. For example, a driver could be found to be reckless if he drives in a threatening or harassing manner out of “road rage,” and causes a car accident. Road rage is defined as an assault with a motor vehicle against the operator or passenger(s) of another motor vehicle. Criminal charges can stem from this and related behavior.
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-13fs8']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-kkr88kgc' admin_preview_bg='']
<img class="alignnone wp-image-982 size-medium" style="border: 2px solid #023ca8; -webkit-box-shadow: 10px 10px 29px 1px rgba(0,0,0,0.41); -moz-box-shadow: 10px 10px 29px 1px rgba(0,0,0,0.41); box-shadow: 10px 10px 29px 1px rgba(0,0,0,0.41);" src="http://exs.788.myftpupload.com/wp-content/uploads/2021/02/bt-car-accident-reckless-300x200.jpg" alt="" width="300" height="200" />
[/av_textblock]

[/av_one_third]
[/av_section]";s:14:"seccion blanca";s:3693:"[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' margin='' custom_margin='0px' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' video_mobile_disabled='' overlay_enable='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='scroll' bottom_border_style='scroll' scroll_down='' custom_arrow_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-37lj0']
[av_one_third first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='#023ca8' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='#4f4f4f' column_boxshadow_width='17' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-91vo']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-kkr88kgc' admin_preview_bg='']
<img style="border: 2px solid #023ca8; -webkit-box-shadow: 10px 10px 29px 1px rgba(0,0,0,0.41);
-moz-box-shadow: 10px 10px 29px 1px rgba(0,0,0,0.41);
box-shadow: 10px 10px 29px 1px rgba(0,0,0,0.41);" class="aligncenter wp-image-981 size-full" src="http://exs.788.myftpupload.com/wp-content/uploads/2021/02/bt-car-accident-front-ended.jpg" alt="" width="300" height="199" />
[/av_textblock]

[/av_one_third][av_two_third min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-2apcg']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#000000' id='' custom_class='' av_uid='av-kkr4h0c0' admin_preview_bg='']
<h2 style="color: black; font-size: 30px; font-weight: 900; letter-spacing: 2px; text-align: left;">Head-On Collisions</h2>
<div class="linehr"></div>
The Law Office of Brian T. Smith has seen the devastating effects of head-on collisions. The results of these most tragic accidents are numerous and cause a lot of pain and suffering for those involved.

According to the U.S Census Bureau, head-on collisions are among the most dangerous and deadly of all car accidents. The injuries that result from these crashes can often result in lifelong disabilities or even death for the victims.
[/av_textblock]

[/av_two_third]
[/av_section]";s:14:"slider espanol";s:1261:"[av_slideshow_full size='featured' min_height='0px' stretch='' control_layout='av-control-default' src='' attachment='' attachment_size='' position='top left' repeat='no-repeat' attach='scroll' conditional_play='' animation='slide' transition_speed='' autoplay='false' interval='5' lazy_loading='disabled' id='' custom_class='' av_uid='av-kkrbhgs2']
[av_slide_full slide_type='image' id='1039' video='https://' mobile_image='' fallback_link='https://' title='<span class="titleslider">Abogados en Español</span>' video_format='' video_ratio='16:9' caption_pos='caption_center' custom_title_size='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' heading_tag='' heading_class='' link_apply='' link='lightbox' link_target='' button_label='Click me' button_color='light' link1='manually,http://' link_target1='' button_label2='Click me' button_color2='light' link2='manually,http://' link_target2='' overlay_enable='aviaTBaviaTBoverlay_enable' overlay_opacity='0.3' overlay_color='#023ca8' overlay_pattern='' overlay_custom_pattern='' av_uid='av-8ckyf'][/av_slide_full]
[/av_slideshow_full]";s:11:"smaller web";s:15037:"[av_slideshow_full size='featured' min_height='0px' stretch='' control_layout='av-control-default' src='' attachment='' attachment_size='' position='top left' repeat='no-repeat' attach='scroll' conditional_play='' animation='slide' transition_speed='' autoplay='false' interval='5' lazy_loading='disabled' id='' custom_class='' av_uid='av-kkcztql2']
[av_slide_full slide_type='image' id='428' video='https://' mobile_image='' fallback_link='https://' title='<span class="titleslider">Bus Accident Greenville, SC</span>' video_format='' video_ratio='16:9' caption_pos='caption_center' custom_title_size='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' heading_tag='' heading_class='' link_apply='button' link='lightbox' link_target='' button_label='Contact Us' button_color='theme-color' link1='page,125' link_target1='' button_label2='Click me' button_color2='light' link2='manually,http://' link_target2='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_uid='av-3f8j'][/av_slide_full]
[/av_slideshow_full]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='#ffffff' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' 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='' shadow='no-border-styling' bottom_border='border-extra-diagonal' bottom_border_diagonal_color='#cbe1ff' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-2yv35']
[av_two_third first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='-20px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-20sjl']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-kkd03ji5' admin_preview_bg='']
<h2 class="pagetittle">Bus Accident Lawyer</h2>
<div class="linehr"></div>
<p class="textpage">Whether it is children taking a school bus, or passengers on an interstate electrical bus, thousands of people rely on bus transportation every single day. When someone gets onto a bus they trust that the driver is properly licensed, well-rested, and ready to operate the bus in a safe manner to protect all passengers. A passenger also hopes that the vehicle has been properly inspected, and that all parts of the bus are entirely operational. However, bus accidents do occur, and oftentimes it is the result of negligence on the part of the bus driver or manufacturer. Bus accidents can result in vehicle damage, property damage, and injuries.</p>
When passengers are seriously injured in a bus accident, one of the first steps is contacting a personal injury attorney. Brian Smith and his team can handle all types of bus accident cases for injured accident victims.

Call the Law Office of Brian T Smith if you have been in any of the following accidents:
<ul>
 	<li>Accidents on local mass transit carriers</li>
 	<li>School bus accidents</li>
 	<li>Accidents on charter bus tours</li>
 	<li>Bus accidents involving sight-seeing</li>
 	<li>Greyhound transportation malfunction</li>
</ul>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='10px' radius_sync='true' padding='10px,12px,10px,15px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/01/circle-blues-300x300.png' attachment='388' attachment_size='medium' background_position='top left' background_repeat='repeat' highlight_size='1.1' animation='pop-up' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='av-hide-on-mobile' id='' custom_class='sectionshadown' aria_label='' av_uid='av-kkczw7f5']

[av_sidebar widget_area='Menu Home Car Accident' av_uid='av-1rwk5']

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_gradient' custom_bg='' background_gradient_color1='#cbe1ff' background_gradient_color2='#93c0ff' background_gradient_direction='vertical' 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='' shadow='no-border-styling' bottom_border='border-extra-diagonal' bottom_border_diagonal_color='#ffffff' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kkd0hlhv']
[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='-75px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkd3ow4m']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-ycd1' admin_preview_bg='']
<img class="imgpages alignright wp-image-89" src="http://exs.788.myftpupload.com/wp-content/uploads/2021/01/bus-accident-text.jpg" alt="" width="330" height="201" />

Our team can handle all types of bus accident cases in South Carolina including accidents caused by other motorists and motor vehicles on the road. Bus accidents are more common than many think, and due to the size of buses, the injuries involved can be serious and life-threatening. Passengers in complex accidents can suffer serious physical injuries, such as brain injuries, that can require hospitalizations and professional medical attention. Injured victims may also lose the ability to work or earn income and may feel like their life has been put on hold. The long-term consequences of an accident of this nature can be devastating, so it is crucial to take legal action and hire a bus accident lawyer early to ensure your rights are protected.
[/av_textblock]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='#ffffff' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' 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='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-o52t']
[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='-75px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-kkd3rmaq']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='av-ycd1' admin_preview_bg='']
<img class="imgpages wp-image-415 alignleft" src="http://exs.788.myftpupload.com/wp-content/uploads/2021/01/passengers.jpg" alt="" width="320" height="220" />
<p class="textpage">If you have been injured or lost a loved one due to wrongful death in a bus accident that occured in other cities in South Carolina such as Mauldin, Simpsonville, Greer, Travelers Rest and Spartanburg, you may be entitled to compensation if it is found that the accident was the result of someone else’s negligent actions. You need a compassionate law firm that understands your problem and has the drive to help you. Law Office of Brian T. Smith can help you get the justice you deserve.</p>
<p class="textpage">Our firm can fight against large bus companies and the lawyers that represent those companies. Come visit or call the Law Office of Brian T. Smith. During your meeting we will advise you on the steps moving forward.</p>
[/av_textblock]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' 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='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' av-desktop-hide='aviaTBav-desktop-hide' av-medium-hide='aviaTBav-medium-hide' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kkd3so55']
[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='10px' radius_sync='true' padding='10px,12px,10px,15px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/01/circle-blues-300x300.png' attachment='388' attachment_size='medium' background_position='top left' background_repeat='repeat' highlight_size='1.1' animation='pop-up' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='sectionshadown' aria_label='' av_uid='av-kkczw7f5']

[av_sidebar widget_area='Menu Home Car Accident' av_uid='av-1rwk5']

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://exs.788.myftpupload.com/wp-content/uploads/2021/01/car_accident_5-bg.jpg' attachment='417' attachment_size='full' attach='parallax' position='center center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='av-kkd4dg0n']
[av_one_full first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='av-qkyp']

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='75' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' id='' custom_class='' av_uid='av-kkd4g5ub' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' av_uid='av-kkd4fqgr' admin_preview_bg='']
<h3 style="text-align: center; font-size: 46px;">Free Case Evaluation</h3>
<p style="text-align: center; font-size: 24;">Call us 24/7 at (864) 239-2007 or fill out the form below to receive a free and confidential consultation.</p>
[/av_textblock]

[av_hr class='invisible' icon_select='yes' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='75' custom_border='av-border-thin' custom_width='50px' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='' custom_icon_color='' id='' custom_class='' av_uid='av-kkd4g5ub' admin_preview_bg='']

[/av_one_full]
[/av_section]";}