var totalCats=11;
function makeSelected(theDiv){
    for ( i=0; i < totalCats + 1; i++){
	if ( ('cat' + i) != theDiv ){
	    document.getElementById('cat' + i).className = "categoryTab";
	    document.getElementById('item' + i).style.display='none';
	}else{
	    document.getElementById('cat' + i).className = "categoryTabSelected";
	    document.getElementById('item' + i).style.display='block';
	}
    }
}

var ErrorMSG="<div style='border-radius:50px;padding:20px;font-size:18px;box-shadow:0px 0px 10px #000;text-align:center;background:rgba(200,200,200,.2)'><img src='https://www.bestchoicerestaurants.com/menumaker/icons/alert-icon.png' width=40px><br><b style='font-size:32px;color:red'>Our Apologies!</b><br> Our Link Must Be Present For The Free Version Of Menu Maker To Work.<br> Please <a href='https://bestchoicerestaurants.com/login.php' style='font-weight:bold;color:red;text-decoration:none;'>Log In</a> And Regenerate Your Code Snippet,<br> Or Upgrade To A Paid Version</div>";

if ( document.getElementById('referalLink') == null) {
  document.getElementById('menuMaker').innerHTML= ErrorMSG;
}else{
  if ( document.getElementById('referalLink').href == 'https://bestchoicerestaurants.com/' ){
    document.getElementById('menuMaker').innerHTML=atob("
<style>

#bestchoicerestaurantsLB{
display:none;
position:fixed;
top:0px;
left:0px;
width:100%;
height:100%;
background:rgba(0,0,0,.8);

line-height:calc(100%);

    white-space: nowrap;
    
    text-align: center; 
 z-index:99999;
}


#bestchoicerestaurantsLB span {
    display: inline-block;
    height: calc(100%);
    vertical-align: middle;
    line-height:100%;
}
#bcrLBIMG{

border-radius:15px;

  height:50%;

    background-color: white;

    position: absolute;
    top:0;
    bottom: 0;
    left: 0;
    right: 0;

    margin: auto;
  }

.foodmenu{
position:relative;
font:normal 12px Verdana;
		width:100%;
	

}

.categoryTabs{
position:relative;

width:100%;


}

.categoryTab{

		display:inline-block;

		padding:10px;
		
		margin:0px;

		border-top-right-radius:3px;
		border-top-left-radius:3px;
		border:1px solid #e6e6e6;

	
	background-color:#f5f5f5;
}

.categoryTab:hover{
	cursor:pointer;
	background-color:#ffffff;
	box-shadow:0px 0px 20px #000;
	
}

.categoryTabSelected:hover{
		cursor:pointer;
	background-color:#ffffff;
		box-shadow:0px 0px 20px #000;
}



.categoryContent{
box-shadow:0px 0px 15px #e6e6e6;

min-height:400px;
width:100%;
border:1px solid #e6e6e6;
top:35px;


background-color:rgba(255,255,255,.8);



}

.categoryTabSelected{

border-botttom:white;



background-color:white;
		display:inline-block;

		padding:10px;
		height:15px;
		margin:0px;

		border-top-right-radius:3px;
		border-top-left-radius:3px;
		border-left:1px solid #e6e6e6;
		border-top:1px solid #e6e6e6;
		border-right:1px solid #e6e6e6;
		font-weight:bold;
		
	




}

.menuinfo{
margin-top:10px;
margin-bottom:10px;
padding:20px;


}


.showimageD{
margin-right:20px;

display:inline-block;
vertical-align:top;

border-radius:10px;
box-shadow:0px 0px 7px #000;
width:100px;

}


.showimageM{

display:none;


}

.aitemNamePrice{

display:inline-block;
vertical-align:middle;
width:calc( 100% - 130px);

}


.aitemTitle{


	font-weight:bold;
	font-size:18px;
display:inline-block;

}


.aitemPrice{

float:right;
display:inline-block;

font-size:18px;
}

.menuinfo hr{


 border: 0;
    height: 1px;
    background-image: -webkit-linear-gradient(left, rgba(0,0,0,0), rgba(0,0,0,0.75), rgba(0,0,0,0)); 
    background-image:    -moz-linear-gradient(left, rgba(0,0,0,0), rgba(0,0,0,0.75), rgba(0,0,0,0)); 
    background-image:     -ms-linear-gradient(left, rgba(0,0,0,0), rgba(0,0,0,0.75), rgba(0,0,0,0)); 
    background-image:      -o-linear-gradient(left, rgba(0,0,0,0), rgba(0,0,0,0.75), rgba(0,0,0,0)); 



}




.menuinfo h1{

font-family:'trebuchet MS', Palatino,  Baskerville, Baskerville Old Face, verdana, Helvetica, sans-serif !important;
text-align:center;
}



#jomommahr{

margin: 30px auto  !important;
background: url(https://bestchoicerestaurants.com/images/menu-divider.png) no-repeat top center  !important;
height: 36px  !important;
border: none !important;

}
/*  Mobile Devices   */







@media screen and (max-width: 600px) {
		
		.showimageD{ display:none;}
		.showimageM{

	    margin-left: auto;
    margin-right: auto;				
display:block;


border-radius:10px;
box-shadow:0px 0px 7px #000;


width:100%;
margin-bottom:20px;
margin-top:20px;
max-width:200px;


		}
		

		

		.aitem{
		text-align:center !important;
		}
		
		.aitemDescription{
		text-align:center !important;
		}
		
		.aitemNamePrice{
		font-size:18px;
		width:100%;
		float:none;
		font-weight:normal !important;
		
		}
		
	
		.aitemDescription{
		margin-top:10px;
		text-align: justify;
		font-size:16px;
		}
		
		.aitemTitle, .aitemPrice{
		float:none;
		display:block !important;
		text-align:center;
		margin-bottom:10px;
		}

}


</style>

<script>





var totalCats=11;

function makeSelected(theDiv){
    for ( i=0; i < totalCats + 1; i++){
	if ( ('cat' + i) != theDiv ){
	    document.getElementById('cat' + i).className = "categoryTab";
	    document.getElementById('item' + i).style.display='none';
	}else{
	    document.getElementById('cat' + i).className = "categoryTabSelected";
	    document.getElementById('item' + i).style.display='block';
	}
    }
}


</script>

<div class=foodmenu >
  <div class=categoryTabs >
<div class=categoryTabSelected id=cat0 onclick="makeSelected(this.id);">
Menu
</div>
  
	<div class=categoryTab id=cat1 onclick="makeSelected(this.id);">Appetizers</div>	<div class=categoryTab id=cat2 onclick="makeSelected(this.id);">Soup</div>	<div class=categoryTab id=cat3 onclick="makeSelected(this.id);">Salads</div>	<div class=categoryTab id=cat4 onclick="makeSelected(this.id);">Sandwiches</div>	<div class=categoryTab id=cat5 onclick="makeSelected(this.id);">Calzones</div>	<div class=categoryTab id=cat6 onclick="makeSelected(this.id);">Bread</div>	<div class=categoryTab id=cat7 onclick="makeSelected(this.id);">Kid's Meals</div>	<div class=categoryTab id=cat8 onclick="makeSelected(this.id);">Pizza</div>	<div class=categoryTab id=cat9 onclick="makeSelected(this.id);">Pasta</div>	<div class=categoryTab id=cat10 onclick="makeSelected(this.id);">Beverages</div>	<div class=categoryTab id=cat11 onclick="makeSelected(this.id);">Desserts</div>
  </div>
<div class=categoryContent>

<div id=item0 class=menuinfo >
<h1>Menu</h1>
<hr id=jomommahr>
<div class=aitem onclick="makeSelected('cat1');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=127' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Appetizers

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=127'  class=showimageM></center>
						<p>Dipping sauce choices are the following: Ketchup, Meat, Marinara, Alfredo, BBQ, Ranch, Bleu Cheese, 1000 Island, Honey Mustard, Creamy Italian, Balsamic Vinaigrette, Popper Jelly, Ghost Pepper, Sriracha, Tabasco, Creamy Garlic, Tzatziki, Hot Sauce, Yellow Mustard, Cocktail , Tartar, Creamy Gorgonzola.</p>
<p>Extra Dipping Sauce - $0.50 (each)</p>						</div>
						
						
	<div style='clear:both'></div>					

</div>
<div style='clear:both'></div>
<br>
<center>
<img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'>
</center>
<br>

</div>
<div class=aitem onclick="makeSelected('cat2');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=128' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Soup

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=128'  class=showimageM></center>
						<p>Our soups&nbsp;</p>						</div>
						
						
	<div style='clear:both'></div>					

</div>
<div style='clear:both'></div>
<br>
<center>
<img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'>
</center>
<br>

</div>
<div class=aitem onclick="makeSelected('cat3');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=129' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Salads

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=129'  class=showimageM></center>
						<p>Your Choice of Dressing: Bleu Cheese, 1000 Island, Creamy Italian, French, Ranch, Oil &amp; Vinegar, Honey Mustard, Caesar, Fat-Free Italian, Balsamic Vinaigrette, Creamy Gorgonzola.</p>
<p>Extra Dressing - $0.50 (each)</p>						</div>
						
						
	<div style='clear:both'></div>					

</div>
<div style='clear:both'></div>
<br>
<center>
<img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'>
</center>
<br>

</div>
<div class=aitem onclick="makeSelected('cat4');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=130' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Sandwiches

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=130'  class=showimageM></center>
						<p>Tossed Green Salad or Caesar Salad or 1/2 order Beer Battered Fries or 1/2 order Tater Tots can be added for just $3.49.&nbsp;</p>
<p>Extra sauce on sandwiches will incur an additional charge.</p>						</div>
						
						
	<div style='clear:both'></div>					

</div>
<div style='clear:both'></div>
<br>
<center>
<img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'>
</center>
<br>

</div>
<div class=aitem onclick="makeSelected('cat5');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=131' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Calzones

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=131'  class=showimageM></center>
						<p>Tossed Green Salad or Caesar Salad can be added for just $3.49.&nbsp;</p>
<p><span style="text-decoration: underline;">The following items count as one item each</span>:&nbsp;</p>
<p>Pepperoni, Fresh Basil, Black Olive, Mushroom, Green Olive, Anchovy, Roma Tomato, Salami, Onion, Pineapple, Jalapeno, Capers, Beef, Garlic, Italian Sausage, Canadian-Style Bacon, Green Pepper, Hot Banana Peppers, Fresh Spinach, Roasted Red Pepper, Toasted Almonds.</p>
<p><span style="text-decoration: underline;"> The following items count as two items each</span>:</p>
<p>Cheddar, Meatball, Chicken, Sausage Link, Feta, Artichoke, Shrimp, Gyro Meat, Fresh Mozzarella, Gorgonzola, Smoked Salmon, Sun-dried Tomato, Crumbled Bacon, Fresh Mozzarella.</p>
<p><span style="text-decoration: underline;">Choice of sauce</span>: Pizza, Marinara, BBQ, Meat, Alfredo Creamy Pesto, Ghost Pepper, Sriracha, Creamy Garlic, Salsa</p>						</div>
						
						
	<div style='clear:both'></div>					

</div>
<div style='clear:both'></div>
<br>
<center>
<img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'>
</center>
<br>

</div>
<div class=aitem onclick="makeSelected('cat6');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=132' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Bread

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=132'  class=showimageM></center>
						<p><span style="text-decoration: underline;">Your choice of dipping sauce</span>:</p>
<p>Meat, Marinara, Alfredo, BBQ, Ranch, Bleu Cheese, 1000 Island, Honey Mustard, Creamy Italian, Popper Jelly, Creamy Garlic, Tzatziki, Hot Sauce, Ketchup, Yellow Mustard, Cocktail , Tartar , Creamy Gorgonzola, Ghost pepper, Sriracha</p>						</div>
						
						
	<div style='clear:both'></div>					

</div>
<div style='clear:both'></div>
<br>
<center>
<img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'>
</center>
<br>

</div>
<div class=aitem onclick="makeSelected('cat7');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=133' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Kid's Meals

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=133'  class=showimageM></center>
						<p>Each of our&nbsp;Kids Meals also includes a Mini Ice Cream Cone.</p>						</div>
						
						
	<div style='clear:both'></div>					

</div>
<div style='clear:both'></div>
<br>
<center>
<img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'>
</center>
<br>

</div>
<div class=aitem onclick="makeSelected('cat8');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=134' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Pizza

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=134'  class=showimageM></center>
						<ul>
<li>Gluten FREE Pizza's are Available in the Small Size Only. &nbsp;(Prices may be different from actual)</li>
<li>Take-n-Bake Pizza's receive a 25% Discount</li>
</ul>
<p><strong>Extra Items &amp; Extra Sauce</strong></p>
<p>Pepperoni, Salami, Italian Sausage, Beef, Black Olive, Green Pepper, Mushroom, Onion, Roasted Red Pepper, Fresh Basil, Green Olive, Roma Tomato, Fresh Spinach, Chopped Garlic, Jalapeno, Capers, Pineapple, Anchovy, Hot Banana Peppers, Canadian-Style Bacon, Toasted Almonds</p>
<ul>
<li>Mini 7" $1.00</li>
<li>Small 9" $1.25</li>
<li>Medium 12" $1.50</li>
<li>Large 15" $1.75</li>
</ul>
<p><strong>Double Items</strong></p>
<p>Chicken, Artichoke, Sun-dried Tomato, Shrimp, Gyro Meat, Crumbled Bacon &amp; All cheeses: Pizza cheese, Cheddar, Gorgonzola, Feta, Asiago, Fresh Mozzarella, Crumbled Bacon, Gyro Meat, Sun-dried Tomato, Chicken, Shrimp, Artichoke</p>
<ul>
<li>Mini 7" $2.00</li>
<li>Small 9" $2.50</li>
<li>Medium 12" $3.00</li>
<li>Large 15" $3.50</li>
</ul>
<p><strong>SPECIALTY PIZZA</strong></p>
<p>Half and Half pizzas are available &amp; are charged for the most expensive side.</p>						</div>
						
						
	<div style='clear:both'></div>					

</div>
<div style='clear:both'></div>
<br>
<center>
<img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'>
</center>
<br>

</div>
<div class=aitem onclick="makeSelected('cat9');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=135' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Pasta

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=135'  class=showimageM></center>
						<p>All Pasta is served with 1/2 order of Garlic Bread. Tossed Green Salad or Caesar Salad can be added for just $3.49. Extra sauce on pasta will incur an additional charge.</p>						</div>
						
						
	<div style='clear:both'></div>					

</div>
<div style='clear:both'></div>
<br>
<center>
<img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'>
</center>
<br>

</div>
<div class=aitem onclick="makeSelected('cat10');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=136' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Beverages

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=136'  class=showimageM></center>
						<p>Choose from a selection of beers on tap, specialty bottled beers and domestic bottle beers, wines, Italian sodas, Beford's Gourmet Sodas, assorted soft drinks and juice drinks.</p>						</div>
						
						
	<div style='clear:both'></div>					

</div>
<div style='clear:both'></div>
<br>
<center>
<img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'>
</center>
<br>

</div>
<div class=aitem onclick="makeSelected('cat11');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=137' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Desserts

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=137'  class=showimageM></center>
												</div>
						
						
	<div style='clear:both'></div>					

</div>
<div style='clear:both'></div>
<br>
<center>
<img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'>
</center>
<br>

</div>


</div>

<div id=item1 class=menuinfo style="display:none;"><h1>Appetizers</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=432';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=432' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Phantom Hot Chicken Wings			</div>
			
			<div class=aitemPrice>
			$Half (6) 7.99 or Full (12) 14.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=432'  class=showimageM></center>
			<ul>
<li>Defcom 5 - Buffalo Hot Sauce</li>
<li>Defcom 4 - Buffalo Hot &amp; Ghost Pepper Chili Sauce</li>
<li>Defcom 3 - Buffalo Hot, Ghost Pepper Chili &amp; Tabasco Sauce</li>
<li>Defcom 2 - Buffalo Hot, Ghost Pepper Chili, Tabasco &amp; Sriracha Sauce</li>
<li>Defcom 1 - Buffalo Hot, Ghost Pepper Chili, Tabasco, Sriracha &amp; Crushed Red Hot Pepper Flakes.</li>
</ul>
<p>Served with Celery Sticks &amp; a Side of Dipping Sauce</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=433';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=433' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken Wings Traditional			</div>
			
			<div class=aitemPrice>
			$Half (6) 7.99 or Full (12) 14.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=433'  class=showimageM></center>
			<ul>
<li>Original</li>
<li>BBQ</li>
<li>Teriyaki</li>
<li>Sweet &amp; Tangy</li>
</ul>
<p>Served with Celery Sticks &amp; a Side of Dipping Sauce</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=434';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=434' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Tater Tots			</div>
			
			<div class=aitemPrice>
			$Half  3.99 or Full  6.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=434'  class=showimageM></center>
			<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=435';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=435' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beer Battered Fries			</div>
			
			<div class=aitemPrice>
			$ Half 3.99 or Full 6.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=435'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=436';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=436' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Brew City Mozza Sticks  			</div>
			
			<div class=aitemPrice>
			$Half 4.49 or Full 8.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=436'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=437';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=437' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Brew City Zucchini Slices			</div>
			
			<div class=aitemPrice>
			$Half 4.49 or Full 8.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=437'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=438';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=438' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Brew City Onion Rings			</div>
			
			<div class=aitemPrice>
			$Half 4.49 or Full 8.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=438'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=439';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=439' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Mini Corn Dogs			</div>
			
			<div class=aitemPrice>
			$Half 4.49 or Full 8.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=439'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=440';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=440' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Jalapeno Poppers			</div>
			
			<div class=aitemPrice>
			$Half (5) 4.99 or Full (10) 9.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=440'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=441';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=441' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken Tenders			</div>
			
			<div class=aitemPrice>
			$Half (3) 5.25 or Full (6) 10.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=441'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=442';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=442' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Calamari Strips			</div>
			
			<div class=aitemPrice>
			$Half 5.49 or Full 10.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=442'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=443';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=443' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Butterflied Shrimps			</div>
			
			<div class=aitemPrice>
			$Half 5.99 or Full 11.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=443'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=444';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=444' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Clam Strips			</div>
			
			<div class=aitemPrice>
			$Half 3.99 or Full 7.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=444'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=445';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=445' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fish & Chips			</div>
			
			<div class=aitemPrice>
			$Half (2) 6.99 or Full (4) 9.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=445'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=446';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=446' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fried Dill Pickles			</div>
			
			<div class=aitemPrice>
			$Half 4.99 or Full 9.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=446'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=447';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=447' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fried Green Beans			</div>
			
			<div class=aitemPrice>
			$Half 4.99 or Full 9.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=447'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br></div><div id=item2 class=menuinfo style="display:none;"><h1>Soup</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=449';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=449' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Soup Of The Day  			</div>
			
			<div class=aitemPrice>
			$Cup 2.99 or Bowl 5.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=449'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=450';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=450' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Minestrone			</div>
			
			<div class=aitemPrice>
			$Cup 2.99 or Bowl 5.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=450'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br></div><div id=item3 class=menuinfo style="display:none;"><h1>Salads</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=451';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=451' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Tossed Green Salad			</div>
			
			<div class=aitemPrice>
			$3.99 or With Shrimp Or Chicken 7.24 or With Smoked Salmon 7.74			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=451'  class=showimageM></center>
			<p>Crisp Iceberg Lettuce, Mozzarella Cheese, Roma Tomato, Cucumber &amp; Homestyle Croutons. When Served with Shrimp or Chicken or Smoked Salmon a 1/2 order of Garlic Bread is added.</p>
<p>&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=452';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=452' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Jumbo Salad			</div>
			
			<div class=aitemPrice>
			$7.99 or  With Shrimp Or Chicken 10.99 or With Smoked Salmon  11.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=452'  class=showimageM></center>
			<p>Twice as Big as our Tossed Green Salad &amp; a 1/2 order Garlic Bread.</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=453';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=453' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Caesar Salad			</div>
			
			<div class=aitemPrice>
			$Half  5.74  Full  9.49 or With Shrimp Or Chicken (half)  7.24  With Shrimp Or Chicken (full) or 12.49  With Smoked Salmon (half)  7.74  With Smoked Salmon (full)  13.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=453'  class=showimageM></center>
			<p>Crisp Romaine Lettuce, Asiago Cheese, Crumbled Bacon, Egg, Served with Caesar Dressing &amp; Homestyle Croutons with a 1/2 order of Garlic Bread.</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=454';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=454' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Signature Salad			</div>
			
			<div class=aitemPrice>
			$Half 7.24 or Full 12.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=454'  class=showimageM></center>
			<p>Canadian-Style Bacon, Shrimp, Mozzarella Cheese, Roma Tomato, Egg &amp; Homestyle Croutons Served with a 1/2 order of Garlic Bread</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=455';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=455' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chefs Salad			</div>
			
			<div class=aitemPrice>
			$Half 7.24 or Full 12.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=455'  class=showimageM></center>
			<p>Chicken, Canadian-Style Bacon, Cheddar &amp; Mozzarella Cheese, Roma Tomato, Cucumber, Egg &amp; Homestyle Croutons Served with a 1/2 order of Garlic Bread</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=456';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=456' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Super Salad			</div>
			
			<div class=aitemPrice>
			$Half 7.24 or Full 12.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=456'  class=showimageM></center>
			<p>Pepperoni, Canadian-Style Bacon, Shrimp, Mozzarella Cheese, Roma Tomato, Cucumber, Egg &amp; Homestyle Croutons Served with a 1/2 order of Garlic Bread</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br></div><div id=item4 class=menuinfo style="display:none;"><h1>Sandwiches</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=457';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=457' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Stromboli			</div>
			
			<div class=aitemPrice>
			$Half 5.49 or Full 8.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=457'  class=showimageM></center>
			<p>Ground Angus Steak, choice of Pizza or BBQ sauce, Onion, Mozzarella Cheese &amp; Shredded Lettuce brushed of Garlic Butter</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=458';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=458' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Piggyback			</div>
			
			<div class=aitemPrice>
			$Half 5.99 or Full 9.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=458'  class=showimageM></center>
			<p>Ground Angus Steak, BBQ sauce, Honey Ham, Onion, Crumbled Bacon, Mozzarella Cheese, Shredded Lettuce, Roma Tomato &amp; brushed of Garlic Butter</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=459';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=459' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken Ranchero  			</div>
			
			<div class=aitemPrice>
			$Half 4.99 or Full 8.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=459'  class=showimageM></center>
			<p>Breaded Chicken Fillet with Ranch Dressing sauce, Mozzarella Cheese, Shredded Lettuce &amp; Roma Tomato brushed of Garlic Butter&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=460';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=460' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Italian Dip			</div>
			
			<div class=aitemPrice>
			$Half 5.49 or Full 8.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=460'  class=showimageM></center>
			<p>Roast Beef &amp; Mozzarella Cheese brushed with Garlic Butter served with Aujus</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=461';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=461' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Sinker 			</div>
			
			<div class=aitemPrice>
			$Half 5.49 or Full 8.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=461'  class=showimageM></center>
			<p>Housemade Meatballs with Meat sauce &amp; Mozzarella Cheese brushed of Garlic Butter</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=462';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=462' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Italian Club			</div>
			
			<div class=aitemPrice>
			$Half 5.49 or Full 8.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=462'  class=showimageM></center>
			<p>Honey Ham, Roasted Turkey, Cheddar &amp; Mozzarella Cheese, Shredded Lettuce, Roma Tomato &amp; Oil &amp; Vinegar Dressing brushed with Garlic Butter</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=463';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=463' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Man Sub			</div>
			
			<div class=aitemPrice>
			$Half 5.49 or Full 8.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=463'  class=showimageM></center>
			<p>Honey Ham, Canadian-Style Bacon, Pepperoni, Salami, Pizza sauce &amp; Mozzarella Cheese brushed with Garlic Butter</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=464';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=464' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Honey Bacon Sub  			</div>
			
			<div class=aitemPrice>
			$Half 5.49 or Full 8.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=464'  class=showimageM></center>
			<p>Honey Ham, Roasted Turkey, Crumbled Bacon, Mozzarella Cheese, Shredded Lettuce &amp; French Dressing brushed with Garlic Butter&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br></div><div id=item5 class=menuinfo style="display:none;"><h1>Calzones</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=465';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=465' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			One Item			</div>
			
			<div class=aitemPrice>
			$Half 5.99 or Full 8.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=465'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=466';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=466' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Two Items			</div>
			
			<div class=aitemPrice>
			$Half 6.74 or Full 10.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=466'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=467';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=467' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Three Items			</div>
			
			<div class=aitemPrice>
			$Half 7.49 or Full 11.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=467'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=468';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=468' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Four Items			</div>
			
			<div class=aitemPrice>
			$Half 8.24 or Full 13.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=468'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br></div><div id=item6 class=menuinfo style="display:none;"><h1>Bread</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=469';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=469' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Garlic Bread Sticks			</div>
			
			<div class=aitemPrice>
			$3 Pcs 2.99 or 6 Pcs 5.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=469'  class=showimageM></center>
			<p>Served with your Choice of Dipping Sauce.</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=470';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=470' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Cheesey Bread Sticks			</div>
			
			<div class=aitemPrice>
			$ 3 Pcs 3.99 or 6 Pcs 7.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=470'  class=showimageM></center>
			<p>Served with your Choice of Dipping Sauce.</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=471';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=471' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Garlic Bread			</div>
			
			<div class=aitemPrice>
			$1 Pc 1.75 or 2 Pcs 3.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=471'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=472';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=472' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Mozza Bread			</div>
			
			<div class=aitemPrice>
			$1 Pc 2.49 or 2 Pcs 4.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=472'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=473';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=473' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Marinara Bread			</div>
			
			<div class=aitemPrice>
			$1 Pc 2.99 or 2 Pcs 5.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=473'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=474';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=474' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Feta Bread			</div>
			
			<div class=aitemPrice>
			$1 Pc 2.49 or 2 Pcs 4.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=474'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=475';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=475' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Parm-Herb Bread			</div>
			
			<div class=aitemPrice>
			$1 Pc 2.49 o 2 Pcs 4.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=475'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=476';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=476' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Gorgonzola Bread			</div>
			
			<div class=aitemPrice>
			$1 Pc 2.49 or 2 Pcs 4.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=476'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br></div><div id=item7 class=menuinfo style="display:none;"><h1>Kid's Meals</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=523';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=523' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Mini Pepperoni Pizza			</div>
			
			<div class=aitemPrice>
			$5.49 			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=523'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=524';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=524' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			1/2 Fettuccini			</div>
			
			<div class=aitemPrice>
			$5.49 			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=524'  class=showimageM></center>
			<p>With a Bread Stick</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=525';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=525' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Mini Hawaiian Pizza			</div>
			
			<div class=aitemPrice>
			$6.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=525'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=526';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=526' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			1/2 Spaghetti			</div>
			
			<div class=aitemPrice>
			$5.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=526'  class=showimageM></center>
			<p>With a Bread Stick</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=527';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=527' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Macaroni & Cheese			</div>
			
			<div class=aitemPrice>
			$6.25			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=527'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=528';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=528' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Clam Strips			</div>
			
			<div class=aitemPrice>
			$4.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=528'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=529';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=529' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Mini Corn Dogs			</div>
			
			<div class=aitemPrice>
			$5.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=529'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=530';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=530' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			3 Pieces Chicken with Dipping Sauce			</div>
			
			<div class=aitemPrice>
			$4.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=530'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br></div><div id=item8 class=menuinfo style="display:none;"><h1>Pizza</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=495';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=495' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Cheese Only			</div>
			
			<div class=aitemPrice>
			$Mini 7" 3.49 Small 9" 6.49 Medium 12" 9.99 Large 15" 12.99 Mini 7" 3.49, Small 9" 6.49, Medium 12" 9.99, Large 15" 12.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=495'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=496';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=496' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Extra Items & Extra Sauce			</div>
			
			<div class=aitemPrice>
			$Mini 7" 1.00, Small 9" 1.25, Medium 12" 1.50, Large 15" 1.75			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=496'  class=showimageM></center>
			<p>Pepperoni, Salami, Italian Sausage, Beef, Black Olive, Green Pepper, Mushroom, Onion, Roasted Red Pepper, Fresh Basil, Green Olive, Roma Tomato, Fresh Spinach, Chopped Garlic, Jalapeno, Capers, Pineapple, Anchovy, Hot Banana Peppers, Canadian-Style Bacon, Toasted Almonds</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=497';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=497' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Double Items			</div>
			
			<div class=aitemPrice>
			$Mini 7" 2.00, Small 9" 2.50, Medium 12" 3.00, Large 15" 3.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=497'  class=showimageM></center>
			<p>Chicken, Artichoke, Sun-dried Tomato, Shrimp, Gyro Meat, Crumbled Bacon &amp; All cheeses: Pizza cheese, Cheddar, Gorgonzola, Feta, Asiago, Fresh Mozzarella, Crumbled Bacon, Gyro Meat, Sun-dried Tomato, Chicken, Shrimp, Artichoke</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=498';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=498' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Works			</div>
			
			<div class=aitemPrice>
			$Mini 7" 9.49, Small 9" 13.99, Medium 12" 18.99, Large 15" 23.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=498'  class=showimageM></center>
			<p>Pepperoni, Salami, Mushroom,Onion, Sausage &amp; Beef</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=499';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=499' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Great Greek			</div>
			
			<div class=aitemPrice>
			$Mini 7" 10.49, Small 9" 15.24, Medium 12" 20.49, Large 15" 25.24			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=499'  class=showimageM></center>
			<p>Black Olive, Artichoke, Fresh Spinach, Chopped Garlic, Toasted Almonds, Fresh Asiago cheese, Pesto sauce &amp; Fresh Roma Tomato &nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=500';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=500' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Taco Border			</div>
			
			<div class=aitemPrice>
			$Mini 7" 9.49, Small 9" 13.99, Medium 12" 18.99, Large 15" 23.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=500'  class=showimageM></center>
			<p>Seasoned Taco Beef, Border sauce, Onion, Shredded Lettuce, Tri-color Corn Strips, Green Pepper &amp; Fresh RomaTomato &nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=501';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=501' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Bella Luna			</div>
			
			<div class=aitemPrice>
			$Mini 7" 8.49, Small 9" 12.74, Medium 12" 17.49, Large 15" 21.74			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=501'  class=showimageM></center>
			<p>Fresh Mozzarella, Fresh Basil leaves, Black Olive &amp; Fresh Roma Tomato &nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=502';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=502' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Deluxe			</div>
			
			<div class=aitemPrice>
			$Mini 7" 9.49, Small 9" 13.99, Medium 12" 18.99, Large 15" 23.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=502'  class=showimageM></center>
			<p>Pepperoni, Mushroom, Onion, Green Pepper, Black Olive &amp; Sausage</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=503';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=503' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Garlic Chicken			</div>
			
			<div class=aitemPrice>
			$ Mini 7" 8.49, Small 9" 12.74, Medium 12" 17.49, Large 15" 21.74			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=503'  class=showimageM></center>
			<p>Chicken, Onion, Chopped Garlic, Alfredo sauce &amp; Fresh Roma Tomato&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=504';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=504' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Hobgoblin			</div>
			
			<div class=aitemPrice>
			$Mini 7" 6.49, Small 9" 10.24, Medium 12" 14.49, Large 15" 18.24			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=504'  class=showimageM></center>
			<p>Pepperoni, Black Olive &amp; Sausage &nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=505';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=505' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Tuscan			</div>
			
			<div class=aitemPrice>
			$Mini 7" 6.49, Small 9" 12.74, Medium 12" 17.49, Large 15" 21.74			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=505'  class=showimageM></center>
			<p>Feta cheese, Black Olive, Mushroom &amp; Fresh Roma Tomato &nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=506';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=506' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Porky Pig			</div>
			
			<div class=aitemPrice>
			$Mini 7" 5.49, Small 9" 8.99, Medium 12" 12.99, Large 15" 16.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=506'  class=showimageM></center>
			<p>Canadian-Style Bacon, Sausage, Pizza &amp; BBQ sauce</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=507';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=507' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Hawaiian			</div>
			
			<div class=aitemPrice>
			$Mini 7" 5.49, Small 9" 8.9,9 Medium 12" 12.99, Large 15" 16.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=507'  class=showimageM></center>
			<p>Canadian-Style Bacon &amp; Pineapple</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=508';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=508' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Tropical Pig			</div>
			
			<div class=aitemPrice>
			$Mini 7" 6.49, Small 9" 10.24, Medium 12" 14.49, Large 15" 18.24			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=508'  class=showimageM></center>
			<p>Canadian-Style Bacon, Pineapple, Sausage, Pizza &amp; BBQ sauce</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=509';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=509' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			He-man			</div>
			
			<div class=aitemPrice>
			$Mini 7" 7.49, Small 9" 11.49, Medium 12" 15.99, Large 15" 19.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=509'  class=showimageM></center>
			<p>Pepperoni, Salami, Sausage &amp; Beef</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=510';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=510' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Vegetarian			</div>
			
			<div class=aitemPrice>
			$Mini 7" 7.49, Small 9" 11.49, Medium 12" 15.99, Large 15" 19.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=510'  class=showimageM></center>
			<p>Mushroom, Onion, Black Olive &amp; Green Pepper</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=511';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=511' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Killer Combo			</div>
			
			<div class=aitemPrice>
			$Mini 7" 10.49, Small 9" 16.49, Medium 12" 21.99, Large 15" 26.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=511'  class=showimageM></center>
			<p>Pepperoni, Salami, Canadian-Style Bacon, Sausage, Beef, Fresh Asiago cheese &amp; Fresh Roma Tomato</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=512';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=512' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Extravaganza			</div>
			
			<div class=aitemPrice>
			$Small 9" 21.99, Medium 12" 27.99, Large 15" 32.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=512'  class=showimageM></center>
			<p>Pepperoni, Salami, Canadian-Style Bacon, Mushroom, Onion, Black Olive, Green Pepper, Pineapple, Shrimp, Sausage, Beef, Fresh Asiago cheese &amp; Fresh Roma Tomato</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=513';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=513' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chefs Choice			</div>
			
			<div class=aitemPrice>
			$Mini 7" 9.49, Small 9" 13.99, Medium 12" 18.99, Large 15" 23.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=513'  class=showimageM></center>
			<p>Canadian-Style Bacon, Mushroom, Onion, Black Olive, Sausage &amp; Beef</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=514';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=514' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken Denver			</div>
			
			<div class=aitemPrice>
			$Mini 7" 10.49, Small 9" 15.24, Medium 12" 20.49, Large 15" 25.24			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=514'  class=showimageM></center>
			<p>Chicken,Onion, Canadian-Style Bacon, Green Pepper, Mushroom, BBQ sauce &amp; Fresh Roma Tomato</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=515';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=515' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Spud Lovers			</div>
			
			<div class=aitemPrice>
			$ Mini 7" 7.49, Small 9" 11.49, Medium 12" 15.99, Large 15" 19.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=515'  class=showimageM></center>
			<p>Roasted Yukon Gold &amp; Baby Red Potatoes, Crumbled Bacon, Onions, Cheddar cheese, Alfredo sauce &amp; Topped with Ranch Dressing&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=516';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=516' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Saucy Sausage			</div>
			
			<div class=aitemPrice>
			$ Mini 7" 9.49, Small 9" 13.99, Medium 12" 18.99, Large 15" 23.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=516'  class=showimageM></center>
			<p>Sliced Link Sausage, Onion, Green Peppers, Black Olive, Garlic, Pizza &amp; BBQ Sauce, drizzled with Ranch Dressing&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=517';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=517' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Sicilian			</div>
			
			<div class=aitemPrice>
			$Mini 7" 11.49, Small 9" 16.49, Medium 12" 21.99, Large 15" 26.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=517'  class=showimageM></center>
			<p>Black Olive, Green Olive, Sun-dried Tomato, Chopped Garlic, Sausage &amp; Feta cheese</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=518';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=518' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Greek Isle			</div>
			
			<div class=aitemPrice>
			$Mini 7" 10.49, Small 9" 15.24, Medium 12" 20.49, Large 15" 25.24			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=518'  class=showimageM></center>
			<p>Gyro Meat, Black Olive, Onion, Feta cheese, Tzatziki sauce &amp; Fresh Roma Tomato</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br></div><div id=item9 class=menuinfo style="display:none;"><h1>Pasta</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=477';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=477' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Spaghetti			</div>
			
			<div class=aitemPrice>
			$Half 6.25 or Full 7.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=477'  class=showimageM></center>
			<p>With Gordy's Own Signature Meat Sauce</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=478';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=478' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Spaghetti W/ Mushroom			</div>
			
			<div class=aitemPrice>
			$Half 7.00 or Full 9.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=478'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=479';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=479' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Spaghetti W/ Meatball			</div>
			
			<div class=aitemPrice>
			$Each 1.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=479'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=480';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=480' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Spaghetti W/ Sausage Link			</div>
			
			<div class=aitemPrice>
			$Each 1.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=480'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=481';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=481' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Penne Rigata			</div>
			
			<div class=aitemPrice>
			$Half 6.25 or Full 7.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=481'  class=showimageM></center>
			<p>Served with your Choice of sauce: Meat, Marinara, Alfredo, Creamy Pesto&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=482';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=482' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fettuccini			</div>
			
			<div class=aitemPrice>
			$Half 6.25 or Full 7.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=482'  class=showimageM></center>
			<p>With Gordy's Own Signature Alfredo Sauce</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=483';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=483' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fettuccini W/ Mushroom			</div>
			
			<div class=aitemPrice>
			$Half 7.00 or Full 9.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=483'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=484';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=484' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fettuccini W/ Canadian-Style Bacon			</div>
			
			<div class=aitemPrice>
			$Half 7.00 or Full 9.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=484'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=485';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=485' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fettuccini W/ Artichoke			</div>
			
			<div class=aitemPrice>
			$Half 7.75 or Full 10.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=485'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=486';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=486' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fettuccini W/ Shrimp			</div>
			
			<div class=aitemPrice>
			$Half 7.75 or Full 10.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=486'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=487';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=487' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fettuccini W/ Smoked Salmon			</div>
			
			<div class=aitemPrice>
			$Half 8.25 or Full 11.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=487'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=488';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=488' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fettuccini W/ Chicken Fillet			</div>
			
			<div class=aitemPrice>
			$Half 7.75 or Full 10.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=488'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=489';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=489' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Combination Fettuccini			</div>
			
			<div class=aitemPrice>
			$			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=489'  class=showimageM></center>
			<p>Choice of any two additions from the list above. Price determined based on selection.</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=490';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=490' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Lasagna			</div>
			
			<div class=aitemPrice>
			$Half 9.25 or Full 13.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=490'  class=showimageM></center>
			<p>Beef &amp; Sausage Lasagna served with Marinara Sauce&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=491';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=491' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken Carbona			</div>
			
			<div class=aitemPrice>
			$Half 9.25 or Full 13.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=491'  class=showimageM></center>
			<p>Chicken Fillet, Canadian-Style Bacon &amp; Mushroom served over Spaghetti noodles with Alfredo sauce&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=492';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=492' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken Asiago			</div>
			
			<div class=aitemPrice>
			$Half 9.25 or Full 13.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=492'  class=showimageM></center>
			<p>Breaded Chicken Fillet served over Spaghetti noodles with Marinara sauce covered in Fresh Asiago cheese&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=493';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=493' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Six Cheese Tortelloni			</div>
			
			<div class=aitemPrice>
			$Half 9.25 or Full 13.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=493'  class=showimageM></center>
			<p>Roasted Garlic, Spinach, Grana Padano, Mozzarella, Fontina, Romano, Swiss, Ricotta cheese Filled pasta served with your choice of sauce: Meat, Marinara, Alfredo, Creamy Pesto &nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=494';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=494' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Jumbo Ravioli			</div>
			
			<div class=aitemPrice>
			$Half 9.25 or Full 13.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=494'  class=showimageM></center>
			<p>(Braised Beef or Gourmet Cheese or Chicken Rosemary)</p>
<p>Served with your Choice of sauce: Meat, Marinara, Alfredo, Creamy Pesto &nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br></div><div id=item10 class=menuinfo style="display:none;"><h1>Beverages</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=531';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=531' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			SOFT DRINKS			</div>
			
			<div class=aitemPrice>
			$2.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=531'  class=showimageM></center>
			<p>Pepsi, Diet Pepsi, Sierra Mist, Dr. Pepper, Mug Root Beer, Crush Orange, Mountain Dew, Diet Dr. Pepper, Wild Cherry Pepsi, Brisk, Raspberry Iced Tea, Tropicana Lemonade, Brisk Unsweetened Ice Tea, Gatorade Fruit Punch, Diet Moutain Dew</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=532';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=532' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Soft Drinks To Go			</div>
			
			<div class=aitemPrice>
			$12 oz. Cans 1.25 or 2 Liter Bottles 2.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=532'  class=showimageM></center>
			<p>Pepsi, Diet Pepsi, Mountain Dew, Dr. Pepper, Orange Crush, Mug Rootbeer, Sierra Mist, Diet Sierra Mist &amp; Diet Dr.Pepper</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=533';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=533' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			 BEVERAGES 			</div>
			
			<div class=aitemPrice>
			$2.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=533'  class=showimageM></center>
			<p>San Pellegrino ( Italian Sparkling Water ), San Pellegrino ( Lemon or Orange or Grapefruit or Blood Orange ,) Sparkling Apple Juice, Original Apple Juice</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=534';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=534' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Bottled Water			</div>
			
			<div class=aitemPrice>
			$1.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=534'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=535';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=535' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			BEDFORD'S GOURMET SODA			</div>
			
			<div class=aitemPrice>
			$2.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=535'  class=showimageM></center>
			<p>Rootbeer, Vanilla Creme Soda, Ginger Ale, Orange Creme Soda</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=536';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=536' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			ITALIAN SODA			</div>
			
			<div class=aitemPrice>
			$12 Oz. 2.99, 16 Oz. 3.49, 20 Oz. 3.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=536'  class=showimageM></center>
			<p>Blackberry,&nbsp;Blueberry,&nbsp;Cherry, Orange,&nbsp;Raspberry,&nbsp;Strawberry</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=537';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=537' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			BEERS ON TAP			</div>
			
			<div class=aitemPrice>
			$Glass (16 Oz.) 4.49, 1/2 Pitcher 7.99, Full Pitcher 15.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=537'  class=showimageM></center>
			<p>Manny's Pale Ale, Mack &amp; Jack's African Amber Ale, Stella Artois, Hales Troll Porter, Pike Kilt Lifter Scotch Ruby Ale, Shock Top Belgian White, Snoqualmie Wild Cat IPA</p>
<p>&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=538';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=538' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			BEERS ON TAP (Cont.)			</div>
			
			<div class=aitemPrice>
			$Glass (16 Oz.)  3.99,  1/2 Pitcher  6.99,  Full Pitcher  13.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=538'  class=showimageM></center>
			<p>Bud Light or Coors Light</p>
<p>&nbsp;</p>
<p>&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=539';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=539' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Silver City Bottled Beers			</div>
			
			<div class=aitemPrice>
			$7.99 (22 Oz.)			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=539'  class=showimageM></center>
			<p>Red or Porter</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=540';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=540' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			SPECIALTY BOTTLED BEERS			</div>
			
			<div class=aitemPrice>
			$4.29 (12 Oz.)			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=540'  class=showimageM></center>
			<p>Peroni Italian Lager, Angry Orchard Crisp Apple Hard Cider, Alaskan Amber Ale, Corona, Heineken Lager, Mike's Hard Lemonade, Widmer Hefeweizen</p>
<p>&nbsp;</p>
<p>&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=541';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=541' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			DOMESTIC BOTTLED BEERS			</div>
			
			<div class=aitemPrice>
			$3.49 (12 Oz.)			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=541'  class=showimageM></center>
			<p>Budweiser, St. Pauli Girl NA</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=542';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=542' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			WINES			</div>
			
			<div class=aitemPrice>
			$			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=542'  class=showimageM></center>
			<p>Approx. 4 glasses per Bottle</p>
<p>Villa Luisa Chianti, Italian</p>
<p>Glass $5.99</p>
<p>Bottle $17.99</p>
<p>&nbsp;</p>
<p>Ste. Michelle Reisling, Wa</p>
<p>Glass $5.99</p>
<p>Bottle $17.99</p>
<p>&nbsp;</p>
<p>WA - Camaraderie Cabernet Sauvignon</p>
<p>Glass $8.00</p>
<p>Bottle $25.00</p>
<p>&nbsp;</p>
<p>WA - Zero One Sauce Merlot Blend</p>
<p>Glass $8.00</p>
<p>Bottle $25.00</p>
<p>&nbsp;</p>
<p>WA - Olympic Cellars Dungeness White Riesling</p>
<p>Glass $7.00</p>
<p>Bottle $20.00</p>
<p>&nbsp;</p>
<p>WA - Claar Cellars Pinot Grigio</p>
<p>Glass $7.00</p>
<p>Bottle $20.00</p>
<p>&nbsp;</p>
<p>WA - Ryan Patrick Naked Chardonnay</p>
<p>Glass $7.00</p>
<p>Bottle $20.00</p>
<p>&nbsp;</p>
<p>WA - La Chateau Chardonnay - Walla Walla</p>
<p>Bottle Only $30.00</p>
<p>&nbsp;</p>
<p>WA - Camaraderie Cabernet Franc- Port Angeles</p>
<p>Bottle Only $35.00</p>
<p>&nbsp;</p>
<p>CA - Oak Ridge OZV "Old Vine Zinfandel"</p>
<p>Bottle Only $30.00</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br></div><div id=item11 class=menuinfo style="display:none;"><h1>Desserts</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=519';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=519' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Gordy's Goodies			</div>
			
			<div class=aitemPrice>
			$ 6 Pcs 2.75 or 12 Pcs 5.49			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=519'  class=showimageM></center>
			<p>Deep Fried Doughnut Holes. Served with your Choice of Vanilla or Chocolate or Maple icing</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=520';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=520' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Cinna Sticks			</div>
			
			<div class=aitemPrice>
			$3 Pcs 2.99 or 6 Pcs 5.99			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=520'  class=showimageM></center>
			<p>Buttery Flavored Bread Sticks tossed in Cinnamon &amp; Sugar. Served with your Choice of Vanilla or Chocolate or Maple icing&nbsp;</p>			</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=521';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=521' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Cookies In A Cup			</div>
			
			<div class=aitemPrice>
			$Each 2.25			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=521'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=522';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=522' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Specialty Desserts			</div>
			
			<div class=aitemPrice>
			$4.49 per Slice			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=522'  class=showimageM></center>
						</div>

<div style='clear:both'></div>
			
	</div>		
		
		
		
	
		
</div><br><center><img src='https://bestchoicerestaurants.com/menumaker/i/divider.png' style='width:50%;'></center><br></div></div>

  
  
  
  
</div>
<div style='clear:both'></div>
<div style='padding:10px;'>
<a id=referalLink href="https://bestchoicerestaurants.com/" target="about:blank">Restaurant Menu Program</a>
</div>
<div id=bestchoicerestaurantsLB onclick="document.getElementById('bestchoicerestaurantsLB').style.display='none';"><span><img src='' id=bcrLBIMG></span></div>
");
  } else{
    document.getElementById('menuMaker').innerHTML= ErrorMSG;
  }
}