diff --git a/erpnext/docs/assets/img/regional/india/address-template-gstin.png b/erpnext/docs/assets/img/regional/india/address-template-gstin.png
new file mode 100644
index 0000000..8740609
--- /dev/null
+++ b/erpnext/docs/assets/img/regional/india/address-template-gstin.png
Binary files differ
diff --git a/erpnext/docs/assets/img/regional/india/sample-gst-tax-invoice.png b/erpnext/docs/assets/img/regional/india/sample-gst-tax-invoice.png
new file mode 100644
index 0000000..4f4a9b1
--- /dev/null
+++ b/erpnext/docs/assets/img/regional/india/sample-gst-tax-invoice.png
Binary files differ
diff --git a/erpnext/docs/license.html b/erpnext/docs/license.html
index 4740c5c..1d50b78 100644
--- a/erpnext/docs/license.html
+++ b/erpnext/docs/license.html
@@ -640,8 +640,8 @@
 the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.</p>
 
-<pre><code>    &lt;one line to give the program's name and a brief idea of what it does.&gt;
-    Copyright (C) &lt;year&gt;  &lt;name of author&gt;
+<pre><code>    &lt;one line="" to="" give="" the="" program's="" name="" and="" a="" brief="" idea="" of="" what="" it="" does.=""&gt;
+    Copyright (C) &lt;year&gt;  &lt;name of="" author=""&gt;
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/erpnext/docs/user/manual/en/regional/india/gst-setup.md b/erpnext/docs/user/manual/en/regional/india/gst-setup.md
index 48e5066..0ba8284 100644
--- a/erpnext/docs/user/manual/en/regional/india/gst-setup.md
+++ b/erpnext/docs/user/manual/en/regional/india/gst-setup.md
@@ -14,6 +14,13 @@
 
 <img class="screenshot" alt="GST in Company" src="{{docs_base_url}}/assets/img/regional/india/gstin-company.gif">
 
+**Include GSTIN number in the Address Template**
+
+Open Address Template record for India, and add GSTIN number there if not exists.
+
+<img class="screenshot" alt="GST in Company" src="{{docs_base_url}}/assets/img/regional/india/address-template-gstin.png">
+
+
 ### 2. Setting up HSN Codes
 
 According to the GST Law, your itemised invoices must contain the HSN Code related to that Item. ERPNext comes pre-installed with all 12,000+ HSN Codes so that you can easily select the relevant HSN Code in your Item
@@ -54,6 +61,12 @@
 
 <img class="screenshot" alt="GST Invoice" src="{{docs_base_url}}/assets/img/regional/india/gst-invoice.gif">
 
+### 6. Print GST Tax Invoice
+
+To print Tax Invoice as per GSTN guidelines, please select **GST Tax Invoice** print format. This print format includes company address, GSTIN numbers, HSN/SAC Code and item-wise tax breakup.
+
+<img class="screenshot" alt="Sample GST Tax Invoice" src="{{docs_base_url}}/assets/img/regional/india/sample-gst-tax-invoice.png">
+
 ### Reports
 
 ERPNext comes with most of your reports you need to prepare your GST Returns. Go to Accounts > GST India head for the list.
