improve documentation

1 files changed, 437 insertions, 173 deletions

diff --git a/HelpMe.md b/HelpMe.md
index 0cf9719..a6ec9f0 100644
--- a/HelpMe.md
+++ b/HelpMe.md
@@ -65,25 +65,35 @@ The prefix allows the system to identify your command.
 ## How to roll a die
 
 It is real simple. you have to call:
-> 1d6
+```
+1d6
+```
 
 The first number is the count of dice you want to roll. The second number should be die's faces count.
 
 ### Examples
 
-> 1d6
+```
+1d6
+```
 
 Roll one six sided die.
 
-> 1d10
+```
+1d10
+```
 
 Roll one ten sided die.
 
-> 5d10
+```
+5d10
+```
 
 Roll five ten sided die.
 
-> 777d6
+```
+777d6
+```
 
 Roll 777 six sided die.
 
@@ -91,16 +101,20 @@ Thanks of several operations and options, you can tune a bit your rolling comman
 
 ### Roll dice in Range
 
-> 4d[-1..1]
+```
+4d[-1..1]
+```
 
 Rolling 4 dice with value between -1 to 1. (Fudge/Fate system)
 
-> 3d[0..9]
-
+```
+3d[0..9]
+```
 Rolling 3 dice with 10 faces starting at 0.
 
-> 3d[-20..-9]
-
+```
+3d[-20..-9]
+```
 Rolling 3 dice, values are between -20 and -9.
 
 
@@ -108,15 +122,21 @@ Rolling 3 dice, values are between -20 and -9.
 
 Adding (or any arithmetic operations) results from two (or more) kinds of dice is easy:
 
->  1d10+1d8
+```
+1d10+1d8
+ ```
 
 To display all results without making any operations with those results. Use `;` to mark several instructions.
 
-> 1d10;1d6 # 2 instructions
+```
+1d10;1d6 # 2 instructions
+```
 
 or
 
-> 5d6;1d10;4d100;3d20  # 4 instructions
+```
+5d6;1d10;4d100;3d20  # 4 instructions
+```
 
 
 ### Merge
@@ -127,7 +147,9 @@ It is useful when you need to manage all diceresult as the same result.
 
 For example, if you need to keep the higher dice between a d6 and d8.
 
-> d6;d8mk1
+```
+d6;d8mk1
+```
 
 More details about k operator in [List of operator](#list-of-operator) .
 
@@ -140,12 +162,14 @@ Thanks to variable system, it is possible to reference the result of a specific
 etc…
 the number of instruction is not limited.
 
-> 8d10;$1c[>6];$1c1;$2-$3
+```
+8d10;$1c[>6];$1c1;$2-$3
+```
 
 * The first instruction rolls 8 (10 sided) dice
 * The second instruction counts how many dice are higher than 6.
 * The third instruction counts how many dice are equal to 1.
-* The fourth instruction substracts the result of the third instruction to the result of seconde one.
+* The fourth instruction subtracts the result of the third instruction to the result of seconde one.
 
 
 ## List of operator
@@ -170,95 +194,130 @@ the number of instruction is not limited.
 
 ### Keep
 
-> kX
+```
+kX
+```
 
 The option sorts the resulting die list and select the X higher dice.
 
 ### Explode and Keep
 
-> KX
+```
+KX
+```
 
 Dice explode if their value are at the die **maximum**, the option sorts the resulting die list, the it selects the X higher dice.
 
 #### Examples
 
-> 6d10K4
+```
+6d10K4
+```
+
 Roll 6 10-sided dices, each 10 explodes. So the value of exploded dices are greater than 10.
 Result: 40 details: 23 [10,10,3],9,5,3,1,1
 
 Another way to write this command is:
-> 6d10e10k4
+```
+6d10e10k4
+```
 This way allows you to change the explode threshold.
 
 ### Keep Lower dice
 
-> klX
+```
+klX
+```
 
 The option sorts the resulting die list, the it selects the X lowest dice.
 
 ### Sort
 
-> 3D10s
+```
+3D10s
+```
 
 The dice list is sorted in descending order.
 
-> 10d6sl
+```
+10d6sl
+```
 
-Roll 6 dice at 6 faces and then sort them ascendingly
+It rolls 6 dice at 6 faces and then they are sorted in ascending order
 
 ### Count
 
-> 3D10c[Validator]
+```
+3D10c[Validator]
+```
 
 Count how many dice respect the condition and display the number (See Validator for more details about syntax)
 
 ### Reroll
 
-> 3D10r[Validator]
+```
+3D10r[Validator]
+```
 
 Reroll the die if the previous value fits the validator (See Validator for more details about syntax).
 
 ### Reroll until
 
-> 3D10R[Validator]
+```
+3D10R[Validator]
+```
 
 Works like "Reroll", but continue to roll the dice until the condition is false.
 
 ### Explode
 
-> 3D10e[Validator]
+```
+3D10e[Validator]
+```
 
 Explode while the value fits the Validator (See Validator for more details about syntax).
 
 ### Examples
 
-> 3D10e10
+```
+3D10e10
+```
 While dice value is equal to 10, the dice is rolled again and its result is added to the previous dice value.
-Result: 49 details: 8, 12 [10,2], 29 [10,10,9]
+> Result: **49 details: 8, 12 [10,2], 29 [10,10,9]**
 
-> 3D10e[>8]
+```
+3D10e[>8]
+```
 While the dice value is greater than 8, the dice is rolled again and its result is added to the previous dice value.
-Result: 35 details: 3, 27 [9,10,8], 5
+> Result: **35 details: 3, 27 [9,10,8], 5**
 
 ### Add
 
-> 3D10a[Validator]
+```
+3D10a[Validator]
+```
 
 Reroll the die if its value fits the Validator and add the new value to the previous one. It does that only once.
 
 ### Occurence
 
-> 10d10o
+```
+10d10o
+```
 
 Count and sort occurences of each value.
 Result: `3x1,1x2,3x4,2x9,1x10 - [1,1,1,2,4,4,4,9,9,10]`
 
-> 10d10o2,7
+```
+10d10o2,7
+```
 
 Count and sort occurence when they occur at least 2 times, the value is 7 or more.
 Result: `2x8 - [1,2,3,5,6,7,8,8,9,10]`
 
-> 10d10o2[<6]
+```
+10d10o2[<6]
+```
 
 Count and sort occurence when they occur at least 2 times, the value should respect the validator (here less than 6).
 Result: `2x3,2x5 - [3,3,5,5,6,6,6,7,7,8]`
@@ -266,7 +325,9 @@ Result: `2x3,2x5 - [3,3,5,5,6,6,6,7,7,8]`
 
 #### Errors
 
-> 10d10o[<6]
+```
+10d10o[<6]
+```
 
 This command is triggering a warning. As occurence operator can have 0 or 2 parameters. But only one validator is unsupported yet.
 
@@ -277,17 +338,23 @@ This command is triggering a warning. As occurence operator can have 0 or 2 para
 This operator is dedicated to apply its next operator to the second to last result.
 For example:
 
-> 8D10c[>=7]+@c[=10]
+```
+8D10c[>=7]+@c[=10]
+```
 
 c[=10] in this command is counting the number of 10 in the result of 8D10, if you remove the @, it will try to count the number of 10 in the result of c[>=7]. The result of c[>=7] is a scalar number (1 or 2 ... (max value 8)); it is not dice list.
 
 ### Paint
 
-> 8D10p[1:blue]
+```
+8D10p[1:blue]
+```
 
 Paint the first die in the list in blue
 
-> 8d10p[2:blue]
+```
+8d10p[2:blue]
+```
 
 Paint the two first dice in the list in blue.
 
@@ -303,20 +370,22 @@ The amount of color is depending of client application of DiceParser.
 
 Filter operator allows you to ignore some dice result given a validator.
 
-> 4d6f[!=6]
+```
+4d6f[!=6]
+```
 
 Result:
-```
+> total: 11 - details[5 2 6 4]
 
-total: 11 - details[5 2 6 4]
-```
 the 6 is ignored.
 
 ### Merge
 
 Merge operator is used for gathering several dice rolls from different die type into one dice result and then you may apply any kind of operator.
 
-> 1d6;1d8mk1
+```
+1d6;1d8mk1
+```
 
 This command merges together the result from the d6 and the d8. Then, it applied the k operator on both result to keep the best.
 Be careful, this operator merges the instruction list. Instruction reference (such as $1 etc..) won't work after merge operator.
@@ -326,7 +395,9 @@ Be careful, this operator merges the instruction list. Instruction reference (su
 It makes exploded dice as new dice.
 The operator is trigged by *y*.
 
-> 4d6e6y6k3
+```
+4d6e6y6k3
+```
 
 First Result: `10 [6, 4], 3, 3, 2`  
 Result after spead: `6, 4, 3, 2`  
@@ -337,22 +408,24 @@ Final result: `6+4+3 = 13`
 This operator is temporary. It is dedicated to answer issue about Tunnels and Trolls system. It is why the marker operator is `t`.
 Dice explode when all dice has the same value.
 
-> 2d6t
-
 ```
-# Explode twice because 2,1
+2d6t
+```
+
+> # Explode twice because 2,1
 Result: 12 - details:[2d6t (5 [2,1,2] 7 [2,1,4])]
 
-# Nothing happened
+> # Nothing happened
 Result: 10 - details:[2d6t (4 6)]
-```
+
 
 ### Unique
 
 It makes exploded dice as new dice.
 
-> 4d6e6u
-
+```
+4d6e6u
+```
 Result: 6 4 3 3 2
 Final result: 6+4+3 = 13
 
@@ -360,11 +433,15 @@ Final result: 6+4+3 = 13
 
 Build your own value list and apply any dice operator.
 
-> [10,25,43,8]k1
+```
+[10,25,43,8]k1
+```
 
 Get the higher score from several instruction:
 
-> 1d10;2d6+9;1d20;[$1,$2,$3,$4]k1
+```
+1d10;2d6+9;1d20;[$1,$2,$3,$4]k1
+```
 
 Each value is transformed into a die.
 
@@ -372,7 +449,9 @@ Each value is transformed into a die.
 
 Bind works exactly as merge but it keeps instruction array untouched.
 
-> !2d8;2d12b;$2k2;$2k2kl1;"your total is $3 with lowest: $4"
+```
+!2d8;2d12b;$2k2;$2k2kl1;"your total is $3 with lowest: $4"
+```
 
 Roll two 8-sided dice and two 12-sided dice then bind their results. using this final result, we keep the 2 higher dice and then we isolate the lowest of the two highest.
 At the end, we display the result inside a sentence.
@@ -406,31 +485,45 @@ There are 4 different methods.
 
 #### Examples:
 
->  1d6i[<4]{3}
+```
+1d6i[<4]{3}
+```
 
 If the value of the die is less than 4, the die value is 3. (So 1, 2 , 3 become 3).
 
->  4d6e6i[=4]{-4}
+```
+4d6e6i[=4]{-4}
+```
 
 If die has 4 as value, it remove it. \[Kuro System\]
 
-> 4d6i.[=6]{+1d6}
+```
+4d6i.[=6]{+1d6}
+```
 
 if at least one die is equal to 6, then roll another d6 and add it to the result.
 
-> 4d6i*[=6]{+1d6}
+```
+4d6i*[=6]{+1d6}
+```
 
 if all dice are equal to 6, then roll another d6 and add it to the result.
 
-> 2d10i:[>15]{"Success"}{"Fail"}
+```
+2d10i:[>15]{"Success"}{"Fail"}
+```
 
 if the sum of two dice is greater than 15, It displays "Success", otherwise it displays "Fail".
 
-> 2d10i:[>15]{"Success %1 "}{"Fail %1"}
+```
+2d10i:[>15]{"Success %1 "}{"Fail %1"}
+```
 
 Same as above, but the final result is displayed beside Success or Fail.
 
-> 2d10i:[>15]{"Success %1 [%2]"}{"Fail %1 [%2]"}
+```
+ 2d10i:[>15]{"Success %1 [%2]"}{"Fail %1 [%2]"}
+```
 
 Same as above, but the result of each die is displayed inside square brackets.
 
@@ -441,7 +534,9 @@ Group dices, then count the number of group (7th sea system).
 
 #### Example
 
-> 3d20g10
+```
+3d20g10
+```
 
 This will roll 3 dices and then try to group them to make groups of 10. If you get `9 9 2`, you can only create one group whose value is more or equal to ten (`{9,2}`, the second `9` being "wasted").
 
@@ -450,19 +545,22 @@ The `g` operator is allowed to re-order dices to create groups. When rolling `4d
 
 ### Comment (\#)
 
-> 2D6 # Sword attack
+```
+2D6 # Sword attack
+```
 
 Display "Sword attack" and the result of the two dice.
 DiceParser ignore everything after the \#. The whole part is treated as one comment.
 So DiceParser can answer question:
 
-> 1L[yes,no] # Am I evil ?
-
 ```
-Am I evil ?
-yes
+1L[yes,no] # Am I evil ?
 ```
 
+> Am I evil ?
+yes
+
+
 ## Functions
 
 DiceParser provides function to deal with instructions.
@@ -523,112 +621,214 @@ They are really useful but if you have many instructions that can become a bit m
 
 ### Final result
 
-It is also possible to set reference to the scalar result of specific instruction.
+It is also possible to set reference to the final value of specific instruction (the result should be a number or a string)
+
 - To reference the first instruction: `$1`
 - To reference the second instruction: `$2`
 - To reference the third instruction: `$3`
-etc…
-The number of instruction is not limited.
+
+There is no limit on instruction number.
+
+
+#### String as final result
+
+You can reference the sub result of a string result by adding `[x]` after the instruction reference.
+Let see an example, it will be easier to understand.
+
+```
+2Lu[cats,dogs,rats,rabbits,bats,squirrels]
+```
+
+The default result looks like this:
+
+> cats,bats
+
+Now we want to make a sentence with this text:
+
+```
+2Lu[cats,dogs,rats,rabbits,bats,squirrels];"You love $1 and you are afraid of $1"
+```
+
+As $1 refers to "**cats,bats**", it will show:
+
+> You love cats,bats and you are afraid of cats,bats
+
+
+So, it is not really useful. In order to make it a bit better, we must add some sub-indexes.
+
+```
+2Lu[cats,dogs,rats,rabbits,bats,squirrels];"You love $1[0] and you are afraid of $1[1]"
+```
+
+then we have a proper output.
+
+> You love cats and you are afraid of bats
+
 
 #### Let see some examples:
 
-> 8d10;$1c[>6];$1c1;$2-$3
+```
+8d10;$1c[>6];$1c1;$2-$3
+```
 
 The default output displays: `45,4,0,4 details[4,3,10,7,2,2,7,10]`
 
-> 8d10;$1c[>6];$1c1;$2-$3i:[>0]{"%3 Success[%2]"}{i:[<0]{"Critical fail %3 [%2]"}{"Fail %3 [%2]"}}
+```
+8d10;$1c[>6];$1c1;$2-$3i:[>0]{"%3 Success[%2]"}{i:[<0]{"Critical fail %3 [%2]"}{"Fail %3 [%2]"}}
+```
 
-The output is now: `4 Success[4,3,10,7,2,2,7,10]`
-or
-`Fail 0 [10,3,1,1,2,2,7,5]` (2 success - 2 fails = 0)
-or
-`Critical fail -2 [1,3,1,1,2,2,7,5]` (1 success - 3 fails = -2)
+Here, some output example:
+* `4 Success[4,3,10,7,2,2,7,10]`
+* `Fail 0 [10,3,1,1,2,2,7,5]` (2 success - 2 fails = 0)
+* `Critical fail -2 [1,3,1,1,2,2,7,5]` (1 success - 3 fails = -2)
 
 In this example, the critical fail happens when there are more fails than success.
-
 In the next example, the critical fail happens when there was no success and a least one fail.
 
-> 8d10;$1c[>6];$1c1;$2-$3;$4i:[=0]{"Fail $4 [%2]"}{$4i:[>0]{"$2 Success[%2]"}{$2i:[=0]{"Critical Fail $4 [%2]"}{"Fail $4 [%2]"}}}
+```
+8d10;$1c[>6];$1c1;$2-$3;$4i:[=0]{"Fail $4 [%2]"}{$4i:[>0]{"$2 Success[%2]"}{$2i:[=0]{"Critical Fail $4 [%2]"}{"Fail $4 [%2]"}}}
+```
+
+Another example, to show how to combine string and dice result.
+
+```
+1d6+1;1L[gold coins,spell scrolls,weapons];"You found $1 $2"
+```
+
+> You found 5 gold coins
+
+
 
 ### Dice Result
 
 DiceParser provides tags to display dice result (and each rolled values from a specific instruction).
 
-To show dice values from a specific instrustion, just add `@` followed by the instruction's number (e.g: `@1`)
+To show dice values from a specific instruction, just add `@` followed by the instruction's number (e.g: `@1`)
 
-> `2d6;3d8;"Result $2 - d8:[@2] - d6:[@1]"`
+```
+2d6;3d8;"Result $2 - d8:[@2] - d6:[@1]"
+```
 
 The output:
-`Result 15 - d8:[7,4,4] - d6:[3,6]`
+
+> Result 15 - d8:[7,4,4] - d6:[3,6]`
+
+
+### New line
+
+You may need to display your result on several lines. It is really easy:
+
+```
+1d100;1d10;"Attack: $1\nDamage: $2"
+```
+
+This command will display:
+
+> Attack: 31
+Damage: 7
 
 ## Arithmetic
 
 Rolisteam Dice Parser is able to compute primary arithmetic operation such as: +, -, /, * and it also manages those operator priority and it can also manage parenthesis.
 
-> 8+8+8
+```
+8+8+8
+```
 
-Result: 24
+> Result: 24
 
-> 24-4
+```
+24-4
+```
 
-Result: 20
+> Result: 20
 
-> (3+4)\*2
+```
+(3+4)*2
+```
 
-Result: 14
+> Result: 14
 
-> 7/2
+```
+7/2
+```
 
-Result: 3.5
+> Result: 3.5
 
-> (3+2D6)D10
+```
+(3+2D6)D10
+```
 
-Roll 2 dice and add 3 to the sum of those dice. Then the result is used for rolling dice.
+> Roll 2 dice and add 3 to the sum of those dice. Then the result is used for rolling dice.
 
-> 15|6
+```
+15|6
+```
 
-Result: 2
+> Result: 2
 
-> 15/6
+```
+15/6
+```
 
-Result: 2.5
+> Result: 2.5
 
 ## Arithmetic and Dice
 
-It is possible to use arithmetic opearation on dice. Please pay attention that the default operation to translate a
+It is possible to use arithmetic operation on dice. Please pay attention that the default operation to translate a
 dice list to scalar is the sum. So if you roll `3d6`, the result will be a list with 3 values {2, 5 ,1}. Now, we
 change a bit the command `3d6+4`: It is resolved like this: {2, 5 ,1} = 8; 8+4 = 12. The final result is 12.
 
-> 3d6+4
+```
+3d6+4
+```
 
-Roll 3 dice; sum the result; and add 4
+> Roll 3 dice; sum the result; and add 4
 
-> 10D10-2
+```
+10D10-2
+```
 
-Roll 10 dice; sum the result; and then substract 2
+> Roll 10 dice; sum the result; and then subtract 2
 
-> 87-1D20
+```
+87-1D20
+```
+
+> Subtract the result of 1 die to 87
 
-Substract the result of 1 die to 87
+```
+(6-4)D10
+```
 
-> (6-4)D10
+> Subtract 4 to 6 and then roll two dice.
 
-Substract 4 to 6 and then roll two dice.
+```
+1D10/2
+```
 
-> 1D10/2
+> Divide by 2 the result of 1 die.
 
-Divide by 2 the result of 1 die.
+```
+(2+2)**2
+```
+> Result: 16
 
-> (2+2)^2
-Result: 16
+```
+1d10**2
+```
 
-> 1d10^2
+> Roll 1d10 then multiply the result by itself.
 
-> 15|2
-Integer division of 15 by 2. Result: 7
+```
+15|2
+```
+> Integer division of 15 by 2. Result: 7
 
-> 15/2
-Division of 15 by 2. Result: 7.5
+```
+15/2
+```
+> Division of 15 by 2. Result: 7.5
 
 ## Validator
 
@@ -646,7 +846,9 @@ Any operator which requires validator (such as `a,r,e,c`) can use those three ki
 
 The scalar value sets the validator on eguality between the dice value and the validator
 
-> 4d10e10
+```
+4d10e10
+```
 
 This command means: roll 4 dice and they explode on 10.
 
@@ -654,15 +856,18 @@ This command means: roll 4 dice and they explode on 10.
 
 The range is defined as two bounds. You have to use square brackets and the two bounds are separated by `..`.
 
-> 4d10c[8..10]
-
-> 1d[-1..8]
+```
+4d10c[8..10]
+1d[-1..8]
+```
 
 ### Boolean Condition
 
 The command counts how many dice have values between >=8 and <=10.
 
-> 4d10c[>7]
+```
+4d10c[>7]
+```
 
 The command counts how many dice are aboved 7.
 
@@ -689,56 +894,66 @@ As the `if` operator, you can specify the compare method.
 
 ##### Examples:
 
-> 1L[7,8,9]c[>6]
+```
+1L[7,8,9]c[>6]
+```
 
 This command will return 0 because, no die has been rolled, so the result of `1L[7,8,9]` is a final value.
 
-> 1L[7,8,9]c[?>6]
+```
+1L[7,8,9]c[?>6]
+```
 
 Output: 1
 
-> 5d6e6sc[>=8]
-
-Output:
 ```
-0
-details: [8 [6,2] 2 1 1 1]
+5d6e6sc[>=8]
 ```
+Output:
+
+> 0
+details: [8 [6,2] 2 1 1 1]
 
-> 5d6e6f[?>=16]
+
+```
+5d6e6f[?>=16]
+```
 
 Output:
 As the final sum is equal to 11. It's less than 16 so the filter is filtering everything.
-```
-0
+
+> 0
 details: [2 4 1 3 1]
-```
 
 
 The final sum is higher than 16 so the whole result is accepted by the filter operator.
-```
-23
+
+> 23
 details: [3 6 3 5 6]
-```
 
-> 5d6e6sc[:>=8]
 
-Output:
 ```
-1
-details: [8 [6,2] 2 1 1 1]
+5d6e6sc[:>=8]
 ```
 
+Output:
+> 1
+details: [8 [6,2] 2 1 1 1]
+
 ### Operation Condition
 
 This validator offers modulo as operation and a Boolean Condition to validate the value:
 
-> 4d10c[%2=0]
+```
+4d10c[%2=0]
+```
 
 Count how many even numbers have been rolled.
 
 
-> 4d10c[%2=1]
+```
+4d10c[%2=1]
+```
 
 Count how many odd numbers have been rolled.
 
@@ -748,7 +963,9 @@ Count how many odd numbers have been rolled.
 
 Validator can be the result of several validator.
 
-> 4d10c[>4&%2=0]
+```
+4d10c[>4&%2=0]
+```
 
 Count all dice greater than 4 and even [6,8,10].
 
@@ -760,7 +977,9 @@ Composite Validator supports 3 logical operations:
 
 Composite Validator accepts as many validator as you need:
 
-> !9d100c[=1|=3|=5|=7|=11|=13|=17|=19|=23|=29|=31|=37|=41|=43|=47|=53|=59|=61|=67|=71|=73|=79|=83|=89|=97]
+```
+!9d100c[=1|=3|=5|=7|=11|=13|=17|=19|=23|=29|=31|=37|=41|=43|=47|=53|=59|=61|=67|=71|=73|=79|=83|=89|=97]
+```
 
 ## List operator
 
@@ -772,22 +991,27 @@ Composite Validator accepts as many validator as you need:
 
 The L operator (meaning list) provides a way to pick up value from list.
 
-> 1L[sword,bow,knife,gun,shotgun]
+```
+1L[sword,bow,knife,gun,shotgun]
+```
 
 With comment
 
-> 1L[yes,no] # Am I evil ?
-
 ```
-Am I evil ?
-yes
+1L[yes,no] # Am I evil ?
 ```
 
+> Am I evil ?
+yes
+
+
 ### Number values
 
 If the value is a number, it is treated as well and you can do computation on it or use any operator.
 
-> 1L[-1,0,1,2,3,4]+7
+```
+1L[-1,0,1,2,3,4]+7
+```
 
 ### Text and Number at the same time
 
@@ -803,22 +1027,30 @@ There are 2 main ways to control the odd on the pickup in the list.
 
 #### The ant method
 
-> 1L[2,2,3,3,3,3,4,4,4,5]
+```
+1L[2,2,3,3,3,3,4,4,4,5]
+```
 
 or
 
-> 1L[arm,arm,leg,leg,chest,chest,chest,head]
+```
+1L[arm,arm,leg,leg,chest,chest,chest,head]
+```
 
 #### The lazy method
 
 By range:
 
-> 1L[1,2,3,4,5,6[6..10]]
+```
+1L[1,2,3,4,5,6[6..10]]
+```
 
 
 By weight:
 
-> 1L[1[2],2[2],3[4]]
+```
+1L[1[2],2[2],3[4]]
+```
 
 Several results:
 
@@ -841,51 +1073,75 @@ Several results:
 
 ## Examples
 
-> 3D100
+```
+3D100
+```
 
 Roll 3 dice with 100 faces
 
-> 10D10e[=10]s
+```
+10D10e[=10]s
+```
 
 Roll 10 dice with 10 faces, 10 explodes, and sort the result.
 
-> 100291D66666666s
+```
+100291D66666666s
+```
 
 Roll 100291 dice with 66666666666 faces and sort result
 
-> 15D10c[>7]
+```
+15D10c[>7]
+```
 
 roll 15 dice with 10 faces and it counts number of dice which are above 7
 
-> 1D8+2D6+7
+```
+1D8+2D6+7
+```
 
 roll 1 die with 8 faces and add the result to 2 dice with 6 faces and add 7.
 
-> D25
+```
+D25
+```
 
 roll 1 die with 25 faces
 
-> 88-1D20
+```
+88-1D20
+```
 
 88 minus the value of 1 die of 20 faces
 
-> 8+8+8
+```
+8+8+8
+```
 
 compute: 24
 
-> 1L[sword,bow,knife,gun,shotgun]
+```
+1L[sword,bow,knife,gun,shotgun]
+```
 
 One of this word will be picked.
 
-> 8D10c[Validator1]-@c[validator2]
+```
+8D10c[Validator1]-@c[validator2]
+```
 
 Roll 8 dice with 10 faces then it counts how many dice respect the condition Validator1 and substract the number of dice which respect the validator2 and display the number (See Validator for more details about syntax)
 
-> 8D10c[>=6]-@c[=1]
+```
+8D10c[>=6]-@c[=1]
+```
 
 Old World in darkness system.
 
-> 8D10c[>=7]+@c[=10]
+```
+8D10c[>=7]+@c[=10]
+```
 
 Exalted 2nd edition system.
 
@@ -897,19 +1153,27 @@ As DiceParser provides more and more features, you may find several ways to do t
 
 ### Roll several kind of dice and sum them
 
-```Bad```
-> 2d8;2d10m
+**Bad**
+```
+2d8;2d10m
+```
 
-```Good```
-> 2d8+2d10
+**Good**
+```
+2d8+2d10
+```
 
 The merge operator is useful when you want to use dice operator on all rolled dice.
 
-```Bad```
-> 1d20K1+1d10K1
+**Bad**
+```
+1d20K1+1d10K1
+```
 
-```Good```
-> 1d20+1d10
+**Good**
+```
+1d20+1d10
+```
 
 The k operator to keeps as many dice as you roll is pretty useless because it is the default behaviour.