diff --git a/erpnext/public/js/pos/pos.html b/erpnext/public/js/pos/pos.html
index 1019647..8a08a8b 100644
--- a/erpnext/public/js/pos/pos.html
+++ b/erpnext/public/js/pos/pos.html
@@ -65,10 +65,10 @@
 
 			</div>
 			<div class="row">
-				<div class="col-xs-5 selected-item">
+				<div class="col-xs-6 selected-item">
 					
 		        </div>
-				<div class="col-xs-7 numeric_keypad" style="display:none">
+				<div class="col-xs-6 numeric_keypad" style="display:none">
 					{% var chartData = ["Qty", "Disc", "Price"] %}
 					{% for(var i=0; i<3; i++) { %}
 						<div class="row text-right">
@@ -100,10 +100,10 @@
 				<div class="app-listing item-list"></ul>
     		</div>
     	</div>
-		<!-- <div class="row">
+		<div class="row">
 			<div class="text-right list-paging-area">
 				<button class="btn btn-default btn-more btn-sm" style="margin:5px 20px">{{ __("More") }}</button>
 			</div>
-		</div> -->
+		</div>
     </div>
 </div>
diff --git a/erpnext/public/js/pos/pos_selected_item.html b/erpnext/public/js/pos/pos_selected_item.html
index 833cdd9..4260cf7 100644
--- a/erpnext/public/js/pos/pos_selected_item.html
+++ b/erpnext/public/js/pos/pos_selected_item.html
@@ -1,4 +1,3 @@
-<h5 style="margin-top:5px">Item <span class="text-primary no-margin font-montserrat">{%= item_name %}</h5>
 <div class="pos-bill-item" data-item-code="{%= item_code %}">
 	<div class="form-group edit-pos-item">
 		<label class=" text-left col-xs-4">Price:</label>
