# Calculator:Biting Precise and Equilibrium

### 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

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. = 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.