var totalCats=5;
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=5;

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);">Lunch Entrees</div>	<div class=categoryTab id=cat2 onclick="makeSelected(this.id);">Lunch Combos</div>	<div class=categoryTab id=cat3 onclick="makeSelected(this.id);">Dinner Selections</div>	<div class=categoryTab id=cat4 onclick="makeSelected(this.id);">Dinner Combos</div>	<div class=categoryTab id=cat5 onclick="makeSelected(this.id);">Family Style Dinners</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=111' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Lunch Entrees

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=111'  class=showimageM></center>
						<p>Served with Soup and Steamed Rice; B.B.Q Pork Fried Rice is $1.40 extra.</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=112' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Lunch Combos

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=112'  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 class=aitem onclick="makeSelected('cat3');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=113' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Dinner Selections

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=113'  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 class=aitem onclick="makeSelected('cat4');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=114' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Dinner Combos

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=114'  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 class=aitem onclick="makeSelected('cat5');">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=115' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>

Family Style Dinners

</div>

<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
						<img align=center src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=cat&id=115'  class=showimageM></center>
						<p>Service for Two or More People. No Exceptions.</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>

<div id=item1 class=menuinfo style="display:none;"><h1>Lunch Entrees</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=142';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=142' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Vegetables: Mixed Fresh Vegetables			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=142'  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=143';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=143' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Vegetables: Green Beans with Black Bean Sauce			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=143'  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=144';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=144' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Vegetables: Mixed Fresh Vegetables With To Fu			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=144'  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=145';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=145' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Fresh Vegetables With Chicken			</div>
			
			<div class=aitemPrice>
			$9.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=145'  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=146';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=146' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Brococoli With Chicken			</div>
			
			<div class=aitemPrice>
			$9.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=146'  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=147';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=147' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Moo Goo Gai Pan			</div>
			
			<div class=aitemPrice>
			$9.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=147'  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=148';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=148' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Sweet and Sour Chicken			</div>
			
			<div class=aitemPrice>
			$9.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=148'  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=149';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=149' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Almond Fried Chicken			</div>
			
			<div class=aitemPrice>
			$9.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=149'  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=150';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=150' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Green Beans With Chicken			</div>
			
			<div class=aitemPrice>
			$9.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=150'  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=151';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=151' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Chicken With Black Bean Sauce			</div>
			
			<div class=aitemPrice>
			$9.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=151'  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=152';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=152' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Cashew Nuts Chicken			</div>
			
			<div class=aitemPrice>
			$9.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=152'  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=153';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=153' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Curry Chicken*			</div>
			
			<div class=aitemPrice>
			$9.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=153'  class=showimageM></center>
			<p>*Hot and Spicy</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=154';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=154' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Kung Pao Chicken*			</div>
			
			<div class=aitemPrice>
			$9.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=154'  class=showimageM></center>
			<p>*Hot and Spicy</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=155';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=155' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Sesame Chicken*			</div>
			
			<div class=aitemPrice>
			$9.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=155'  class=showimageM></center>
			<p>*Hot and Spicy</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=156';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=156' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Orange Chicken*			</div>
			
			<div class=aitemPrice>
			$9.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=156'  class=showimageM></center>
			<p>*Hot and Spicy</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=157';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=157' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Fresh Vegetables With Beef			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=157'  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=158';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=158' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Broccoli With Beef			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=158'  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=159';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=159' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Green Beans With Beef			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=159'  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=160';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=160' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Beef With Black Bean Sauce			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=160'  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=161';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=161' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Beef With Ginger and Onion			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=161'  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=162';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=162' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Tomato Beef Chop Suey			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=162'  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=163';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=163' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Curry Beef*			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=163'  class=showimageM></center>
			<p>*Hot and Spicy</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=164';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=164' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Mongolian Beef*			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=164'  class=showimageM></center>
			<p>*Hot and Spicy</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=165';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=165' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Fresh Vegetables With Shrimp			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=165'  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=166';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=166' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Broccoli With Shrimp			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=166'  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=167';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=167' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Green Beans With Shrimp			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=167'  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=168';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=168' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Cashew Nuts Shrimp			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=168'  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=169';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=169' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Crispy Shrimp With Cream Sauce			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=169'  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=170';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=170' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Kung Pao Shrimp*			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=170'  class=showimageM></center>
			<p>*Hot and Spicy</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=171';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=171' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Happy Meal: Shrimp, Chicken, and Beef With Mixed Vegetables			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=171'  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=172';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=172' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood Combo: Shrimp, Scallops, and Squid With Mixed Vegetables			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=172'  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=275';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=275' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fresh Garden Salad			</div>
			
			<div class=aitemPrice>
			$7.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=275'  class=showimageM></center>
			<ul>
<li>With chicken or BBQ Pork: $8.95</li>
<li>With shrimp or scallops: $11.95</li>
</ul>			</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=278';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=278' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			French Pepper Steak			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=278'  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=281';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=281' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Shanghai Pork Meat Balls with Vegetables			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=281'  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=283';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=283' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Singapore Curry Chicken			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=283'  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=286';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=286' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Blue Flame Lemon Grass Pork Chops			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=286'  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=288';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=288' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fragrant Spicy Chicken			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=288'  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=290';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=290' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Teriyaki Chicken			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=290'  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=291';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=291' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fresh Grilled Halibut			</div>
			
			<div class=aitemPrice>
			$Market			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=291'  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=293';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=293' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Four Seasons Hot Pot			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=293'  class=showimageM></center>
			<ul>
<li>Vegetables</li>
<li>Beef</li>
<li>Chicken</li>
<li>Shrimp</li>
<li>Scallops</li>
</ul>			</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>Lunch Combos</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=173';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=173' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Lunch Combo Plate #1			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=173'  class=showimageM></center>
			<ul>
<li>B.B.Q Pork Fried Rice,</li>
<li>Chicken Chow Mein,</li>
<li>B.B.Q Pork Egg Foo Young</li>
</ul>
<p>Served with Egg Flower Soup</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=174';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=174' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Lunch Combo Plate #2			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=174'  class=showimageM></center>
			<ul>
<li>B.B.Q Pork Fried Rice,</li>
<li>Chicken Chow Mein,</li>
<li>Sweet and Sour Pork</li>
</ul>
<p>Served with Egg Flower Soup</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=175';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=175' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Lunch Combo Plate #3			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=175'  class=showimageM></center>
			<ul>
<li>B.B.Q Pork Fried Rice,</li>
<li>Chicken Chow Mein,</li>
<li>Sweet and Sour Chicken</li>
</ul>
<p>Served with Egg Flower Soup</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=176';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=176' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Lunch Combo Plate #4			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=176'  class=showimageM></center>
			<ul>
<li>B.B.Q Pork Fried Rice,</li>
<li>Chicken Chow Mein,</li>
<li>Almond Fried Chicken</li>
</ul>
<p>Served with Egg Flower Soup</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=177';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=177' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Lunch Combo Plate #5			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=177'  class=showimageM></center>
			<ul>
<li>B.B.Q. Pork Fried Rice,</li>
<li>Chicken Chow Mein,</li>
<li>Deep Fried Prawns</li>
</ul>
<p>Served with Egg Flower Soup</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=178';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=178' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Lunch Combo Plate #6			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=178'  class=showimageM></center>
			<p>B.B.Q Pork Fried Rice OR Chicken Chow Mein</p>
<p>Choose Two of the Following Items:</p>
<ul>
<li>Egg Roll</li>
<li>B.B.Q Pork</li>
<li>Deep Fried Prawns</li>
<li>Sweet and Sour Pork</li>
<li>Almond Fried Chicken</li>
<li>Sweet and Sour Chicken</li>
<li>Deep Fried Chicken Wings</li>
<li>B.B.Q Pork Egg Foo Young</li>
<li>Deep Fried Won Tons</li>
</ul>
<p>Served with Egg Flower Soup</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=item3 class=menuinfo style="display:none;"><h1>Dinner Selections</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=179';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=179' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Appetizers: Egg Roll			</div>
			
			<div class=aitemPrice>
			$1.75			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=179'  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=180';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=180' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Appetizers: Pot Stickers (6)			</div>
			
			<div class=aitemPrice>
			$5.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=180'  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=181';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=181' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Appetizers: Deep Fried Won Tons With Cream Cheese (8)			</div>
			
			<div class=aitemPrice>
			$6.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=181'  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=182';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=182' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Appetizers: Barbecued Pork			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=182'  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=183';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=183' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Appetizers: Deep Fried Chicken Wings			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=183'  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=184';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=184' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Appetizers: Golden Gate Appetizer Plate			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=184'  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=185';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=185' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Soups: Small Won Ton With B.B.Q Pork			</div>
			
			<div class=aitemPrice>
			$2.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=185'  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=186';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=186' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Soups: Large Won Ton With B.B.Q Pork			</div>
			
			<div class=aitemPrice>
			$7.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=186'  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=187';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=187' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Soups: Small Egg Flower			</div>
			
			<div class=aitemPrice>
			$2.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=187'  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=188';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=188' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Soups: Large Egg Flower			</div>
			
			<div class=aitemPrice>
			$6.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=188'  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=189';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=189' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Soups: Hot and Sour Soup*			</div>
			
			<div class=aitemPrice>
			$6.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=189'  class=showimageM></center>
			<p>*Hot and Spicy</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=191';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=191' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Soups: Seafood Soup			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=191'  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=192';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=192' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Soups: Wor Won Ton			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=192'  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=193';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=193' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Noodles: Barbecued Pork Noodles			</div>
			
			<div class=aitemPrice>
			$7.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=193'  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=194';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=194' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Noodles: Chicken Noodles			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=194'  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=195';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=195' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Noodles: Beef Noodles			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=195'  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=196';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=196' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Noodles: Beef Tomato Noodles			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=196'  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=197';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=197' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Noodles: Curry Beef Noodles*			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=197'  class=showimageM></center>
			<p>*Hot and Spicy</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=198';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=198' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Noodles: Shrimp Noodles			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=198'  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=199';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=199' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Noodles: Golden Gate Noodles			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=199'  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=200';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=200' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Noodles: Seafood Noodles			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=200'  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=201';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=201' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fried Rice: Barbecued Pork Fried Rice			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=201'  class=showimageM></center>
			<p>Served With Soup</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=202';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=202' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fried Rice: Fresh Mushroom Fried Rice			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=202'  class=showimageM></center>
			<p>Served With Soup</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=203';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=203' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fried Rice: Fresh Vegetables Fried Rice			</div>
			
			<div class=aitemPrice>
			$8.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=203'  class=showimageM></center>
			<p>Served With Soup</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=204';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=204' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fried Rice: Chicken Fried Rice			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=204'  class=showimageM></center>
			<p>Served With Soup</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=205';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=205' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fried Rice: Beef Fried Rice			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=205'  class=showimageM></center>
			<p>Served With Soup</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=206';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=206' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fried Rice: Shrimp Fried Rice			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=206'  class=showimageM></center>
			<p>Served With Soup</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=207';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=207' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fried Rice: Golden Gate Special Fried Rice			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=207'  class=showimageM></center>
			<p>Served With Soup</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=208';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=208' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chow Mein: Fresh Vegetable Chow Mein			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=208'  class=showimageM></center>
			<p>Served With Soup</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=209';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=209' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chow Mein: Chicken Chow Mein			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=209'  class=showimageM></center>
			<p>Served With Soup</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=210';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=210' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chow Mein: B.B.Q Pork Chow Mein			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=210'  class=showimageM></center>
			<p>Served With Soup</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=211';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=211' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chow Mein: Beef Chow Mein			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=211'  class=showimageM></center>
			<p>Served With Soup</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=212';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=212' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chow Mein: Beef Tomato Chow Mein			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=212'  class=showimageM></center>
			<p>Served With Soup</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=213';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=213' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chow Mein: Shrimp Chow Mein			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=213'  class=showimageM></center>
			<p>Served With Soup</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=214';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=214' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chow Mein: Golden Gate Special Chow Mein			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=214'  class=showimageM></center>
			<p>Served With Soup</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=215';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=215' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chow Mein: Hong Kong Chow Mein Fun			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=215'  class=showimageM></center>
			<p>Rice Noodles, Vegetables and Choice of: Shrimp, Chicken, B.B.Q. Pork, or Beef</p>
<p>Served With Soup</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=216';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=216' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chow Mein: Shrimp With Scallop Chow Mein			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=216'  class=showimageM></center>
			<p>Served With Soup</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=217';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=217' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chow Mein: Sinapore Curry Chow Mein Fun			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=217'  class=showimageM></center>
			<p>Served With Soup</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=218';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=218' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Egg Foo Young: Barbecued Pork Foo Young			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=218'  class=showimageM></center>
			<p>All Egg Food Young Items are Served With Soup and Steam Rice, Fried Rice is $1.50 Extra.</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=219';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=219' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Egg Foo Young: Fresh Vegetables Foo Young			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=219'  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=220';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=220' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Egg Foo Young: Chicken Foo Young			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=220'  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=221';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=221' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Egg Foo Young: Beef Foo Young			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=221'  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=222';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=222' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Egg Foo Young: Shrimp Foo Young			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=222'  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=223';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=223' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fresh Vegetables: Mixed Fresh Vegetables			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=223'  class=showimageM></center>
			<p>All Fresh Vegetable Items are Served With Soup and Steam Rice, Fried Rice is $1.50 Extra.</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=224';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=224' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fresh Vegetables: Fresh Vegetables With To Fu			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=224'  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=225';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=225' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fresh Vegetables: Green Bean With Black Bean Sauce			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=225'  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=226';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=226' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fresh Vegetables: Ma Pou To Fu*			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=226'  class=showimageM></center>
			<p>*Hot and Spicy</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=227';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=227' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fresh Vegetables: Sauteed Broccoli With Garlic Pork			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=227'  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=228';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=228' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Pork: Sweet and Sour Pork			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=228'  class=showimageM></center>
			<p>All Pork Items are Served With Soup and Steam Rice; Fried Rice is $1.50 Extra.</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=229';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=229' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Pork: Fresh Vegetables With B.B.Q Pork			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=229'  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=230';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=230' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Pork: Green Beans With B.B.Q. Pork			</div>
			
			<div class=aitemPrice>
			$10.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=230'  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=231';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=231' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Pork: Snow Peas With B.B.Q. Pork			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=231'  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=232';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=232' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Pork: Mu Shu Pork			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=232'  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=233';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=233' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Fresh Vegetables With Beef			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=233'  class=showimageM></center>
			<p>All Beef Items are Served With Soup and Steamed Rice; Fried Rice is $1.50</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=234';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=234' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Green Beans With Beef			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=234'  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=235';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=235' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Moo Goo Beef			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=235'  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=236';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=236' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Snow Peas With Beef			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=236'  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=237';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=237' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Green Pepper Beef*			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=237'  class=showimageM></center>
			<p>*Hot and Spicy</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=238';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=238' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Kung Pao Beef			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=238'  class=showimageM></center>
			<p>*Hot and Spicy</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=239';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=239' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Mongolian Beef*			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=239'  class=showimageM></center>
			<p>*Hot and Spicy</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=240';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=240' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Szechuan Beef			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=240'  class=showimageM></center>
			<p>*Hot and Spicy</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=241';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=241' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Curry Beef*			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=241'  class=showimageM></center>
			<p>*Hot and Spicy</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=242';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=242' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Orange Beef*			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=242'  class=showimageM></center>
			<p>*Hot and Spicy</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=243';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=243' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Hunan Beef*			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=243'  class=showimageM></center>
			<p>*Hot and Spicy</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=244';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=244' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Double Mushroom Flank Steak			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=244'  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=245';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=245' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Beef: Flank Steak in Sacha Sauce			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=245'  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=246';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=246' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Almond Fried Chicken			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=246'  class=showimageM></center>
			<p>All Chicken Items are Served With Soup and Steamed Rice; Fried Rice is $1.50 Extra.</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=247';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=247' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Sweet and Sour Chicken			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=247'  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=248';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=248' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Lemon Chicken			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=248'  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=249';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=249' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Fresh Vegetables With Chicken			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=249'  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=250';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=250' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Brococoli With Chicken			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=250'  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=251';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=251' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Moo Goo Gai Pan			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=251'  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=252';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=252' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Green Beans With Chicken			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=252'  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=253';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=253' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Chicken With Black Bean Sauce			</div>
			
			<div class=aitemPrice>
			$11.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=253'  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=254';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=254' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Cashew Nuts Chicken			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=254'  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=255';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=255' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Mu Shu Chicken			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=255'  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=256';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=256' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Snow Peas With Chicken			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=256'  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=257';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=257' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Szechuan Chicken*			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=257'  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=258';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=258' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Curry Chicken*			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=258'  class=showimageM></center>
			<p>*Hot and Spicy</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=260';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=260' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Kung Pao Chicken*			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=260'  class=showimageM></center>
			<p>*Hot and Spicy</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=261';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=261' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Sesame Chicken*			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=261'  class=showimageM></center>
			<p>*Hot and Spicy</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=262';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=262' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: General Tso Chicken*			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=262'  class=showimageM></center>
			<p>*Hot and Spicy</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=263';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=263' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Orange Chicken*			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=263'  class=showimageM></center>
			<p>*Hot and Spicy</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=264';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=264' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Mongolian Chicken*			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=264'  class=showimageM></center>
			<p>*Hot and Spicy</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=265';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=265' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Hunan Chicken*			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=265'  class=showimageM></center>
			<p>*Hot and Spicy</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=266';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=266' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Chicken: Chicken With Garlic Sauce*			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=266'  class=showimageM></center>
			<p>*Hot and Spicy</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=267';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=267' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Deep Fried Prawns			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=267'  class=showimageM></center>
			<p>All Seafood Items are Served With Soup and Steamed Rice; Fried Rice is $1.50</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=268';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=268' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Shrimp With Black Beans Sauce			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=268'  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=269';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=269' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Fresh Vegetables With Shrimp			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=269'  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=270';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=270' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Broccoli With Shrimp			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=270'  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=272';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=272' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Cashew Nuts Shrimp			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=272'  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=273';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=273' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Crispy Shrimp With Cream Sauce			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=273'  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=274';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=274' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Shrimp With Lobster Sauce			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=274'  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=276';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=276' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Kung Pao Shrimp*			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=276'  class=showimageM></center>
			<p>*Hot and Spicy</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=277';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=277' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Curry Shrimp*			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=277'  class=showimageM></center>
			<p>*Hot and Spicy</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=279';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=279' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Szechuan Shrimp			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=279'  class=showimageM></center>
			<p>*Hot and Spicy</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=280';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=280' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Green Beans With Shrimp			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=280'  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=282';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=282' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Snow Peas With Shrimp			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=282'  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=284';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=284' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Fresh Vegetables With Scallops			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=284'  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=285';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=285' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Shrimp With Scallops			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=285'  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=287';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=287' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Double Mushroom With Shrimp			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=287'  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=289';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=289' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood: Jade Scallop			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=289'  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=292';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=292' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Happy Family			</div>
			
			<div class=aitemPrice>
			$15.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=292'  class=showimageM></center>
			<p>Shrimp, Scallop, Beef, and Chicken Stir Fried with Mixed Fresh Vegetables Served on a Bed of Fried Rice.</p>
<p>Served with Soup and Steamed Rice; Fried Rice is $1.50 Extra.</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=294';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=294' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Seafood Combo			</div>
			
			<div class=aitemPrice>
			$15.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=294'  class=showimageM></center>
			<p>Shrimp, and Squid with Shrimp, Scallop, Beef, and Chicken Stir Fried with Mix Fresh Vegetables Served on a Bed of Fried Rice on a Sizzling Hot Plate.</p>
<p>Served with Soup and Steam Rice; Fried Rice is $1.50 Extra.</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=295';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=295' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fresh Garden Salad			</div>
			
			<div class=aitemPrice>
			$7.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=295'  class=showimageM></center>
			<ul style="font-family: Verdana; font-size: 12px; background-color: rgba(255, 255, 255, 0.8);">
<li>With chicken or BBQ Pork: $8.95</li>
<li>With shrimp or scallops: $11.95</li>
</ul>			</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=296';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=296' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			French Pepper Steak			</div>
			
			<div class=aitemPrice>
			$9.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=296'  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=298';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=298' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Shanghai Pork Meat Balls with Vegetables			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=298'  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=299';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=299' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Singapore Curry Chicken			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=299'  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=300';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=300' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Blue Flame Lemon Grass Pork Chops			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=300'  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=302';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=302' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fragrant Spicy Chicken			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=302'  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=303';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=303' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Teriyaki Chicken			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=303'  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=304';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=304' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Fresh Grilled Halibut			</div>
			
			<div class=aitemPrice>
			$Market			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=304'  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=305';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=305' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Four Seasons Hot Pot			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=305'  class=showimageM></center>
			<ul style="font-family: Verdana; font-size: 12px; background-color: rgba(255, 255, 255, 0.8);">
<li>Vegetables</li>
<li>Beef</li>
<li>Chicken</li>
<li>Shrimp</li>
<li>Scallops</li>
</ul>			</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>Dinner Combos</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=297';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=297' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Dinner Combinations #1			</div>
			
			<div class=aitemPrice>
			$12.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=297'  class=showimageM></center>
			<ul>
<li>Chicken Chow Mein,</li>
<li>B.B.Q. Pork Fried Rice,</li>
<li>Sweet and Sour Pork,</li>
<li>Deep Fried Chicken Wings</li>
</ul>
<p>Served With Choice of Egg Flower, Hot &amp; Sour, or Won Ton Soup</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=301';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=301' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Dinner Combinations #2			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=301'  class=showimageM></center>
			<ul>
<li>Chicken Chow Mein</li>
<li>B.B.Q. Pork Fried Rice</li>
<li>Sweet and Sour Pork</li>
<li>Deep Fried Prawns</li>
</ul>
<p>Served With Choice of Egg Flower, Hot &amp; Sour, or Won Ton Soup</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=306';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=306' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Dinner Combinations #3			</div>
			
			<div class=aitemPrice>
			$13.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=306'  class=showimageM></center>
			<ul>
<li>Chicken Chow Mein</li>
<li>B.B.Q. Pork Fried Rice</li>
<li>Deep Fried Prawns</li>
<li>Almond Fried Chicken</li>
</ul>
<p>Served With Choice of Egg Flower, Hot &amp; Sour, or Won Ton Soup</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=307';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=307' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Dinner Combinations #4			</div>
			
			<div class=aitemPrice>
			$14.50			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=307'  class=showimageM></center>
			<ul>
<li>B.B.Q. Pork</li>
<li>1 Egg Roll or 2 Pot Stickers</li>
<li>B.B.Q. Pork Fried Rice or Chicken Chow Mein</li>
<li>Choice of Two:</li>
<ul>
<li>Sweet and Sour Pork</li>
<li>Almond Fried Chicken</li>
<li>Sweet and Sour Chicken</li>
<li>Lemon Chicken</li>
<li>Deep Fried Chicken Wings</li>
<li>Deep Fried Prawns</li>
<li>B.B.Q. Pork Egg Foo Young</li>
</ul>
</ul>
<p>Served With Choice of Egg Flower, Hot &amp; Sour, or Won Ton Soup</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=308';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=308' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Dinner Combinations #5			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=308'  class=showimageM></center>
			<ul>
<li>B.B.Q. Pork</li>
<li>1 Egg Roll or 2 Pot Stickers</li>
<li>B.B.Q. Pork Fried Rice or Chicken Chow Mein</li>
<li>Choice of One:</li>
<ul>
<li>Broccoli with Chicken/Beef</li>
<li>Mushroom with Chicken/Beef</li>
<li>Green Beans with Chicken/Beef</li>
<li>Vegetables with Chicken/Beef</li>
<li>Cashew Nut Chicken/Beef</li>
<li>Mixed Vegetables with Chicken/Beef</li>
<li>Ginger Onion Beef</li>
<li>Orange Chicken/Beef</li>
<li>Kung Pao Chicken Chicken/Beef*</li>
<li>Mongolian Chicken/Beef*</li>
<li>General Tso's Chicken*</li>
</ul>
</ul>
<p>Served With Choice of Egg Flower, Hot &amp; Sour, or Won Ton Soup</p>
<p>*Hot and Spicy</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=309';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=309' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Dinner Combinations #6			</div>
			
			<div class=aitemPrice>
			$14.95			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=309'  class=showimageM></center>
			<ul>
<li>B.B.Q. Pork</li>
<li>1 Egg Roll or 2 Pot Stickers</li>
<li>B.B.Q. Pork Fried Rice or Chicken Chow Mein</li>
<li>Choice of One:</li>
<ul>
<li>Broccoli Shrimp</li>
<li>Cashew Nut Shrimp</li>
<li>Vegetables with Shrimp</li>
<li>Shrimp with Lobster Sauce</li>
<li>Crispy Shrimp with Cream Sauce</li>
<li>Kung Pao Shrimp*</li>
<li>Szechuan Shrimp*</li>
<li>Hunan Shrimp*</li>
<li>Shrimp with Curry Sauce*</li>
</ul>
</ul>
<p>Served With Choice of Egg Flower, Hot &amp; Sour, or Won Ton Soup</p>
<p>*Hot and Spicy</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>Family Style Dinners</h1><hr id=jomommahr><div class=aitem onclick="document.getElementById('bcrLBIMG').src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=310';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=310' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Family Style Dinner - A			</div>
			
			<div class=aitemPrice>
			$15.95 per Person			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=310'  class=showimageM></center>
			<ul>
<li>Chicken Chow Mein</li>
<li>B.B.Q. Pork Fried Rice</li>
<li>Sweet &amp; Sour Pork</li>
<li>Deep Fried Prawns</li>
</ul>
<p>Served with Egg Flower Soup, Egg Roll, and B.B.Q. Pork</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=311';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=311' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Family Style Dinner - B			</div>
			
			<div class=aitemPrice>
			$16.95 per Person			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=311'  class=showimageM></center>
			<ul>
<li>Chicken Chow Mein</li>
<li>B.B.Q. Pork Fried Rice</li>
<li>Sweet &amp; Sour Pork</li>
<li>Almond Fried Chicken</li>
</ul>
<p style="padding-left: 30px;">And Choice of One:</p>
<ul>
<li>Brocolli Chicken</li>
<li>Brocolli Beef</li>
<li>Moo Goo Gai Pan</li>
<li>Moo Goo Beef</li>
<li>Cashew Chicken</li>
</ul>
<p>Served With Egg Flower Soup, Egg Roll, B.B.Q. Pork</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=312';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=312' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Family Style Dinner - C			</div>
			
			<div class=aitemPrice>
			$16.95 per Person			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=312'  class=showimageM></center>
			<ul>
<li>Chicken Chow Mein</li>
<li>B.B.Q. Pork Fried Rice</li>
<li>Sweet &amp; Sour Pork</li>
<li>Almond Chicken</li>
</ul>
<p style="padding-left: 30px;">And Choice of One</p>
<ul>
<li>Deep Fried Prawns</li>
<li>Crispy Shrimp in Cream Sauce</li>
</ul>
<p>Served with Egg Flower Soup, Egg Roll, B.B.Q. Pork</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=313';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=313' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Family Style Dinner - D			</div>
			
			<div class=aitemPrice>
			$16.95 per Person			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=313'  class=showimageM></center>
			<ul>
<li>B.B.Q. Pork Fried Rice</li>
<li>Sweet &amp; Sour Pork</li>
<li>Almond Chicken</li>
<li>Happy Family</li>
<li>Crispy Shrimp in Cream Sauce</li>
</ul>
<p>Served with Won Ton Soup, Egg Roll, B.B.Q. Pork</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=314';document.getElementById('bestchoicerestaurantsLB').style.display='block';">
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=314' class=showimageD>
<div class=aitemNamePrice>
<div class=aitemTitle>
			Family Style Dinner - E			</div>
			
			<div class=aitemPrice>
			$16.95 per Person			</div>
			<div style='clear:both'></div>
			
						<div class=aitemDescription>
						<center>
<img src='https://bestchoicerestaurants.com/menumaker/getimage.php?type=item&id=314'  class=showimageM></center>
			<ul>
<li>Chicken Chow Mein</li>
<li>B.B.Q. Pork Fried Rice</li>
<li>Sweet &amp; Sour Pork</li>
</ul>
<p style="padding-left: 30px;">And Choice of Two:</p>
<ul>
<li>Kung Pao Shrimp*</li>
<li>Sesame Chicken*</li>
<li>Kung Pao Chicken*</li>
<li>Mongolian Beef*</li>
<li>General Tso's Chicken*</li>
<li>Szechuan Shrimp or Chicken*</li>
<li>Orange Beef or Chicken*</li>
</ul>
<p>Served with Won Ton Soup, Egg Roll, and B.B.Q. Pork</p>
<p>*Hot and Spicy</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>

  
  
  
  
</div>
<div style='clear:both'></div>
<div style='padding:10px;'>
<a id=referalLink href="https://bestchoicerestaurants.com/" target="about:blank">Electronic Restaurant Menus</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;
  }
}