diff --git a/README.md b/README.md
index 3fb2c0d..3f45f85 100644
--- a/README.md
+++ b/README.md
@@ -16,11 +16,11 @@ Yet it is very easy to use. You need to learn only few things:
 
 1. You have to **always** pass whatever dynamical data into query via *placeholder*
 2. Each placeholder have to be marked with data type. At the moment there are 6 types:
- * ?s ("string")  - strings (also DATE, FLOAT and DECIMAL)
+ * ?s ("string")  - strings (also ```DATE```, ```FLOAT``` and ```DECIMAL```)
  * ?i ("integer") - the name says it all 
  * ?n ("name")    - identifiers (table and field names) 
- * ?a ("array")   - complex placeholder for IN() operator  (substituted with string of 'a','b','c' format, without parentesis)
- * ?u ("update")  - complex placeholder for SET operator (substituted with string of `field`='value',`field`='value' format)
+ * ?a ("array")   - complex placeholder for ```IN()``` operator  (substituted with string of 'a','b','c' format, without parentesis)
+ * ?u ("update")  - complex placeholder for ```SET``` operator (substituted with string of `field`='value',`field`='value' format)
  * ?p ("parsed")  - special type placeholder, for inserting already parsed statements without any processing, to avoid double parsing.
 3. To get data right out of the query there are helper methods for the most used :
  * query($query,$param1,$param2, ...) - returns mysqli resource.
@@ -41,20 +41,21 @@ The rest is as usual - just create a regular SQL (with placeholders) and get a r
 The main feature of this class is a <i>type-hinted placeholders</i>. 
 And it's really great step further from just ordinal placeholders used in prepared statements. 
 Simply because <b>dynamical parts of the query aren't limited to just scalar data!</b>
-In the real life we have to add identifiers, arrays for IN operator, arrays for INSERT and UPDATE queries.
+In the real life we have to add identifiers, arrays for ```IN``` operator, arrays for ```INSERT``` and ```UPDATE``` queries.
 So - we need <b>many</b> different types of data formatting. Thus, we need the way to tell the driver how to format this particular data. 
 Conventional prepared statements use toilsome and repeating bind_* functions. 
-But there is a way more sleek and useful way - to set the type along with placeholder itself. It is not something new - well-known printf() function uses exactly the same mechanism. So, I hesitated not to borrow such a brilliant idea.
+But there is a way more sleek and useful way - to set the type along with placeholder itself. It is not something new - well-known ```printf()``` function uses exactly the same mechanism. So, I hesitated not to borrow such a brilliant idea.
 
 To implement such a feature, no doubt one have to have their own query parser. No problem, it's not a big deal. But the benefits are innumerable. 
 Look at all the questions on Stackoverflow where developers trying in vain to bind a field name.
 Voila - with identifier placeholder it is as easy as adding a field value:
 
-<code>
-$field = $_POST['field'];<br>
-$value = $_POST['value'];<br>
-$sql   = "SELECT * FROM table WHERE ?n LIKE ?s";<br>
-$data  = $db->query($sql,$field,"%$value%");</code>
+```php
+$field = $_POST['field'];
+$value = $_POST['value'];
+$sql   = "SELECT * FROM table WHERE ?n LIKE ?s";
+$data  = $db->query($sql,$field,"%$value%");
+```
 
 Nothing could be easier!
 
@@ -63,11 +64,12 @@ But as we started inventing new placeholders - let's make some more!
 
 Another trouble in creating prepared queries - arrays going to IN operator. Everyone is trying to do it their own way but the type-hinted placeholder makes it as simple as adding a string:
 
-<code>
-$array = array(1,2,3);<br>
-$data  = $db->query("SELECT * FROM table WHERE id IN (?a)",$array);</code>
+```php
+$array = array(1,2,3);
+$data  = $db->query("SELECT * FROM table WHERE id IN (?a)",$array);
+```
 
-Same goes for such toilsome queries like INSERT and UPDATE.
+Same goes for such toilsome queries like ```INSERT``` and ```UPDATE```.
 
 And, of course, we have a set of helper functions to turn type-hinted placeholders into real brilliant, making almost every call to database as simple as 1 or 2 lines of code for all the regular real life tasks.