44,136
pages

### Perk comparison

For abilities with a damage range 20–100%; a ratio 1:5:

Perk(s) Rank(s) Avg hit increase
Equilibrium, Precise 3, 5 9.875%
Biting, Precise 3, 5 9.694%
Precise 5 6.25%
Equilibrium 3 4%
Biting 3 3.80%

### Calculator

 This is a dynamic calculator that requires Javascript.This takes user input via Javascript, and may use changing prices from the Grand Exchange Market Watch.If prices appear to be outdated, purge the page by clicking here.

Most abilities' min hits are 20% of their max hit, but some abilities also mention min hits. In that case, you can change the min and max hit numbers, but leaving them between 20% and 100% gives correct damage increase numbers for most abilities.

 Precise rank name=precRank1|type=int|range=0,5|sublist=init Equilibrium rank name=eqRank1|type=int|range=0,3|sublist=init Biting rank name=bitRank1|type=int|range=0,3|sublist=init Is Biting on level 20 gear? name=isLevel20_1|type=select|range=No,Yes|sublist=init Min hit of ability name=abilityMinHitIn1|type=number|range=0,1000|value=20|sublist=init Max hit of ability name=abilityMaxHitIn1|type=number|range=0,1000|value=100|sublist=init Average hit without perks name=normalAverageHitOut1|type=output Min hit with perks name=abilityMinHitOut1|type=output Max hit with perks name=abilityMaxHitOut1|type=output Average hit with perks name=perkAverageHitOut1|type=output % damage increase from perks name=percentIncreaseOut1|type=output
type=button|sublist=init|value=Calculate
name=wrongInput1|type=output
init|

let(precRank, precRank1) let(eqRank, eqRank1) let(bitRank, bitRank1) let(minHit, abilityMinHitIn1) let(maxHit, abilityMaxHitIn1) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_1)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn1 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(normalAverageHitOut1, normalAverageHit)
let(abilityMinHitOut1, minHit)
let(abilityMaxHitOut1, maxHit)
let(perkAverageHitOut1, perkAverageHit)
let(percentIncreaseOut1, damageIcrease)
let(wrongInput1, "")
```

}{

```   let(normalAverageHitOut1, 60)
let(abilityMinHitOut1, 20)
let(abilityMaxHitOut1, 100)
let(perkAverageHitOut1, 60)
let(percentIncreaseOut1, 0)
let(wrongInput1, "Please give a correct minimum and maximum ability damage.")
```

}

Full table of Biting Precise and Equilibrium Combinations

List of damage increases for various precise and equilibrium combinations, given a certain rank of biting. If you want to sort the tables by damage increase, note that you need to refresh the page for them to re-sort if you change the biting rank. = perks you can get on one gizmo.

 Biting Rank name=bitRank2|type=int|range=0,3|sublist=init Is Biting on level 20 gear? name=isLevel20_2|type=select|range=No,Yes|sublist=init Min hit of ability name=abilityMinHitIn2|type=number|range=0,1000|value=20|sublist=init Max hit of ability name=abilityMaxHitIn2|type=number|range=0,1000|value=100|sublist=init Average Hit without perks name=normalAverageHitOut2|type=output
type=button|sublist=init|value=Calculate
name=wrongInput2|type=output
init|

let(precRank, 5) let(eqRank, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(normalAverageHitOut2, normalAverageHit)
let(minHitP5E3, minHit)
let(maxHitP5E3, maxHit)
let(averageHitP5E3, perkAverageHit)
let(damageIncreaseP5E3, damageIcrease)
let(wrongInput2, "")
```

}{

```   let(normalAverageHitOut2, 60)
let(minHitP5E3, 20)
let(maxHitP5E3, 100)
let(averageHitP5E3, 60)
let(damageIncreaseP5E3, 0)
let(wrongInput2, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 5) let(eqRank, 2) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP5E2, minHit)
let(maxHitP5E2, maxHit)
let(averageHitP5E2, perkAverageHit)
let(damageIncreaseP5E2, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP5E2, 20)
let(maxHitP5E2, 100)
let(averageHitP5E2, 60)
let(damageIncreaseP5E2, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 5) let(eqRank, 1) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP5E1, minHit)
let(maxHitP5E1, maxHit)
let(averageHitP5E1, perkAverageHit)
let(damageIncreaseP5E1, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP5E1, 20)
let(maxHitP5E1, 100)
let(averageHitP5E1, 60)
let(damageIncreaseP5E1, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 5) let(eqRank, 0) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP5E0, minHit)
let(maxHitP5E0, maxHit)
let(averageHitP5E0, perkAverageHit)
let(damageIncreaseP5E0, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP5E0, 20)
let(maxHitP5E0, 100)
let(averageHitP5E0, 60)
let(damageIncreaseP5E0, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 4) let(eqRank, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP4E3, minHit)
let(maxHitP4E3, maxHit)
let(averageHitP4E3, perkAverageHit)
let(damageIncreaseP4E3, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP4E3, 20)
let(maxHitP4E3, 100)
let(averageHitP4E3, 60)
let(damageIncreaseP4E3, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 4) let(eqRank, 2) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP4E2, minHit)
let(maxHitP4E2, maxHit)
let(averageHitP4E2, perkAverageHit)
let(damageIncreaseP4E2, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP4E2, 20)
let(maxHitP4E2, 100)
let(averageHitP4E2, 60)
let(damageIncreaseP4E2, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 4) let(eqRank, 1) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP4E1, minHit)
let(maxHitP4E1, maxHit)
let(averageHitP4E1, perkAverageHit)
let(damageIncreaseP4E1, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP4E1, 20)
let(maxHitP4E1, 100)
let(averageHitP4E1, 60)
let(damageIncreaseP4E1, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 4) let(eqRank, 0) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP4E0, minHit)
let(maxHitP4E0, maxHit)
let(averageHitP4E0, perkAverageHit)
let(damageIncreaseP4E0, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP4E0, 20)
let(maxHitP4E0, 100)
let(averageHitP4E0, 60)
let(damageIncreaseP4E0, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 3) let(eqRank, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP3E3, minHit)
let(maxHitP3E3, maxHit)
let(averageHitP3E3, perkAverageHit)
let(damageIncreaseP3E3, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP3E3, 20)
let(maxHitP3E3, 100)
let(averageHitP3E3, 60)
let(damageIncreaseP3E3, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 3) let(eqRank, 2) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP3E2, minHit)
let(maxHitP3E2, maxHit)
let(averageHitP3E2, perkAverageHit)
let(damageIncreaseP3E2, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP3E2, 20)
let(maxHitP3E2, 100)
let(averageHitP3E2, 60)
let(damageIncreaseP3E2, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 3) let(eqRank, 1) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP3E1, minHit)
let(maxHitP3E1, maxHit)
let(averageHitP3E1, perkAverageHit)
let(damageIncreaseP3E1, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP3E1, 20)
let(maxHitP3E1, 100)
let(averageHitP3E1, 60)
let(damageIncreaseP3E1, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 3) let(eqRank, 0) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP3E0, minHit)
let(maxHitP3E0, maxHit)
let(averageHitP3E0, perkAverageHit)
let(damageIncreaseP3E0, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP3E0, 20)
let(maxHitP3E0, 100)
let(averageHitP3E0, 60)
let(damageIncreaseP3E0, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 2) let(eqRank, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP2E3, minHit)
let(maxHitP2E3, maxHit)
let(averageHitP2E3, perkAverageHit)
let(damageIncreaseP2E3, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP2E3, 20)
let(maxHitP2E3, 100)
let(averageHitP2E3, 60)
let(damageIncreaseP2E3, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 2) let(eqRank, 2) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP2E2, minHit)
let(maxHitP2E2, maxHit)
let(averageHitP2E2, perkAverageHit)
let(damageIncreaseP2E2, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP2E2, 20)
let(maxHitP2E2, 100)
let(averageHitP2E2, 60)
let(damageIncreaseP2E2, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 2) let(eqRank, 1) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP2E1, minHit)
let(maxHitP2E1, maxHit)
let(averageHitP2E1, perkAverageHit)
let(damageIncreaseP2E1, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP2E1, 20)
let(maxHitP2E1, 100)
let(averageHitP2E1, 60)
let(damageIncreaseP2E1, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 2) let(eqRank, 0) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP2E0, minHit)
let(maxHitP2E0, maxHit)
let(averageHitP2E0, perkAverageHit)
let(damageIncreaseP2E0, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP2E0, 20)
let(maxHitP2E0, 100)
let(averageHitP2E0, 60)
let(damageIncreaseP2E0, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 1) let(eqRank, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP1E3, minHit)
let(maxHitP1E3, maxHit)
let(averageHitP1E3, perkAverageHit)
let(damageIncreaseP1E3, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP1E3, 20)
let(maxHitP1E3, 100)
let(averageHitP1E3, 60)
let(damageIncreaseP1E3, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 1) let(eqRank, 2) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP1E2, minHit)
let(maxHitP1E2, maxHit)
let(averageHitP1E2, perkAverageHit)
let(damageIncreaseP1E2, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP1E2, 20)
let(maxHitP1E2, 100)
let(averageHitP1E2, 60)
let(damageIncreaseP1E2, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 1) let(eqRank, 1) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP1E1, minHit)
let(maxHitP1E1, maxHit)
let(averageHitP1E1, perkAverageHit)
let(damageIncreaseP1E1, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP1E1, 20)
let(maxHitP1E1, 100)
let(averageHitP1E1, 60)
let(damageIncreaseP1E1, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 1) let(eqRank, 0) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP1E0, minHit)
let(maxHitP1E0, maxHit)
let(averageHitP1E0, perkAverageHit)
let(damageIncreaseP1E0, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP1E0, 20)
let(maxHitP1E0, 100)
let(averageHitP1E0, 60)
let(damageIncreaseP1E0, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 0) let(eqRank, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP0E3, minHit)
let(maxHitP0E3, maxHit)
let(averageHitP0E3, perkAverageHit)
let(damageIncreaseP0E3, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP0E3, 20)
let(maxHitP0E3, 100)
let(averageHitP0E3, 60)
let(damageIncreaseP0E3, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 0) let(eqRank, 2) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP0E2, minHit)
let(maxHitP0E2, maxHit)
let(averageHitP0E2, perkAverageHit)
let(damageIncreaseP0E2, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP0E2, 20)
let(maxHitP0E2, 100)
let(averageHitP0E2, 60)
let(damageIncreaseP0E2, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 0) let(eqRank, 1) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP0E1, minHit)
let(maxHitP0E1, maxHit)
let(averageHitP0E1, perkAverageHit)
let(damageIncreaseP0E1, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP0E1, 20)
let(maxHitP0E1, 100)
let(averageHitP0E1, 60)
let(damageIncreaseP0E1, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

let(precRank, 0) let(eqRank, 0) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2)

if(minHit < maxHit){

```   let(minHit, minHit + 0.015 * precRank * maxHit)
```
```   let(maxHit, maxHit - 0.01 * eqRank * (maxHit - minHit))
let(minHit, minHit + 0.03 * eqRank * (abilityMaxHitIn2 - minHit))
```
```   let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0))
let(bitAverageHit, minHit + 0.975 * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance) * (maxHit + minHit) / 2 + bitChance * bitAverageHit)
```
```   let(damageIcrease, (perkAverageHit - normalAverageHit) / normalAverageHit * 100)
```
```   let(normalAverageHit, round(normalAverageHit * 1000))
let(normalAverageHit, normalAverageHit / 1000)
let(minHit, round(minHit * 1000))
let(minHit, minHit / 1000)
let(maxHit, round(maxHit * 1000))
let(maxHit, maxHit / 1000)
let(perkAverageHit, round(perkAverageHit * 1000))
let(perkAverageHit, perkAverageHit / 1000)
let(damageIcrease, round(damageIcrease * 1000))
let(damageIcrease, damageIcrease / 1000)
```
```   let(n, normalAverageHit)
let(minHitP0E0, minHit)
let(maxHitP0E0, maxHit)
let(averageHitP0E0, perkAverageHit)
let(damageIncreaseP0E0, damageIcrease)
let(n, "")
```

}{

```   let(n, 60)
let(minHitP0E0, 20)
let(maxHitP0E0, 100)
let(averageHitP0E0, 60)
let(damageIncreaseP0E0, 0)
let(n, "Please give a correct minimum and maximum ability damage.")
```

}

P E Min hit Max hit Average Hit % damage
increase
5 3 name=minHitP5E3|type=output name=maxHitP5E3|type=output name=averageHitP5E3|type=output name=damageIncreaseP5E3|type=output
5 2 name=minHitP5E2|type=output name=maxHitP5E2|type=output name=averageHitP5E2|type=output name=damageIncreaseP5E2|type=output
5 1 name=minHitP5E1|type=output name=maxHitP5E1|type=output name=averageHitP5E1|type=output name=damageIncreaseP5E1|type=output
5 0 name=minHitP5E0|type=output name=maxHitP5E0|type=output name=averageHitP5E0|type=output name=damageIncreaseP5E0|type=output
4 3 name=minHitP4E3|type=output name=maxHitP4E3|type=output name=averageHitP4E3|type=output name=damageIncreaseP4E3|type=output
4 2 name=minHitP4E2|type=output name=maxHitP4E2|type=output name=averageHitP4E2|type=output name=damageIncreaseP4E2|type=output
4 1 name=minHitP4E1|type=output name=maxHitP4E1|type=output name=averageHitP4E1|type=output name=damageIncreaseP4E1|type=output
4 0 name=minHitP4E0|type=output name=maxHitP4E0|type=output name=averageHitP4E0|type=output name=damageIncreaseP4E0|type=output
3 3 name=minHitP3E3|type=output name=maxHitP3E3|type=output name=averageHitP3E3|type=output name=damageIncreaseP3E3|type=output
3 2 name=minHitP3E2|type=output name=maxHitP3E2|type=output name=averageHitP3E2|type=output name=damageIncreaseP3E2|type=output
3 1 name=minHitP3E1|type=output name=maxHitP3E1|type=output name=averageHitP3E1|type=output name=damageIncreaseP3E1|type=output
3 0 name=minHitP3E0|type=output name=maxHitP3E0|type=output name=averageHitP3E0|type=output name=damageIncreaseP3E0|type=output
2 3 name=minHitP2E3|type=output name=maxHitP2E3|type=output name=averageHitP2E3|type=output name=damageIncreaseP2E3|type=output
2 2 name=minHitP2E2|type=output name=maxHitP2E2|type=output name=averageHitP2E2|type=output name=damageIncreaseP2E2|type=output
2 1 name=minHitP2E1|type=output name=maxHitP2E1|type=output name=averageHitP2E1|type=output name=damageIncreaseP2E1|type=output
2 0 name=minHitP2E0|type=output name=maxHitP2E0|type=output name=averageHitP2E0|type=output name=damageIncreaseP2E0|type=output
1 3 name=minHitP1E3|type=output name=maxHitP1E3|type=output name=averageHitP1E3|type=output name=damageIncreaseP1E3|type=output
1 2 name=minHitP1E2|type=output name=maxHitP1E2|type=output name=averageHitP1E2|type=output name=damageIncreaseP1E2|type=output
1 1 name=minHitP1E1|type=output name=maxHitP1E1|type=output name=averageHitP1E1|type=output name=damageIncreaseP1E1|type=output
1 0 name=minHitP1E0|type=output name=maxHitP1E0|type=output name=averageHitP1E0|type=output name=damageIncreaseP1E0|type=output
0 3 name=minHitP0E3|type=output name=maxHitP0E3|type=output name=averageHitP0E3|type=output name=damageIncreaseP0E3|type=output
0 2 name=minHitP0E2|type=output name=maxHitP0E2|type=output name=averageHitP0E2|type=output name=damageIncreaseP0E2|type=output
0 1 name=minHitP0E1|type=output name=maxHitP0E1|type=output name=averageHitP0E1|type=output name=damageIncreaseP0E1|type=output
0 0 name=minHitP0E0|type=output name=maxHitP0E0|type=output name=averageHitP0E0|type=output name=damageIncreaseP0E0|type=output
Template documentation [purge]
This documentation is transcluded from Calculator:Biting Precise and Equilibrium/doc.

### Precise Rank

The rank of the precise perk on your gizmo. Accepted values are all integers from 0 to 5.

### Equilibrium Rank

The rank of the equilibrium perk on your gizmo. Accepted values are all integers from 0 to 3.

### Biting Rank

The rank of the biting perk on your gizmo. Accepted values are all integers from 0 to 3.

### Is biting on level 20 gear?

Level 20 gear provides an extra 10% chance (multiplicative) for biting to trigger, so this will affect the final result. This only works if the biting perk itself is on a piece of gear that is level 20.

### Min hit and Max hit of ability

These are the damage values displayed on the ability tooltip. If the tooltip only gives a maximum value then the minimum hit is 20% of the maximum hit. Note that exact values of the ability damage do not matter, it is the ratio between the min and maximum damage that determines the damage increase. Example: Sonic Waves tooltip states that it hit 157% of your ability damage. So max hit = 157% and min hit is 20% * 157% = 31.4%. But since 31.4%-157% is a 1:5 ratio it will give the same result if we just use 20%-100% (also a 1:5 ratio). All abilities that only give one damage value in their tooltip are 1:5 abilities and can be calculated with 20%-100% as input.

### Average Hit without perks

The average percentage of your ability damage that you will hit without perks.

### Min Hit and Max hit with perks

These are the new min and max hits of the ability after the effect of the perks are applied.

### % damage increase from perks

The average damage increase that the perks provide given in procent.