# Biting

Biting is an Invention perk that has a 2% (2.2% on a level 20 item) chance per rank to force each ability and autoattack to become a critical hit. It can be created in weapon and armour gizmos. Biting does not affect damage-over time abilities because they do not have the same critical hit mechanics as other hits. Biting is considered to be one of the most powerful and most expensive armour perks in the game.

Biting does not stack with the set effect of Warpriest of Tuska armour. Additionally, the set effect takes priority over the perk, regardless of which effect is greater.

When Biting causes a critical hit, the following message appears in the chatbox: You deal a critical strike against your opponent!

The Biting perk requires noxious components that are primarily obtained by disassembling noxious weaponry. Alternate and more affordable methods of obtaining the components can be found on the noxious components article.

Activation chance[r 1]
Rank Activation chance Avg hit increase[r 2]
1 +2% (2.2%) 1.267% (1.393%)
2 +4% (4.4%) 2.533% (2.786%)
3 +6% (6.6%) 3.8% (4.18%)
4 +8% (8.8%) 5.07% (5.572%)
1. ^ All numbers in parentheses refer to gear with item level 20.
2. ^ Average hit increase is calculated based on the expected value (${\displaystyle EV}$) of receiving a critical hit from biting, Where: ${\displaystyle EV=AvgC(R_{b})+AvgH(1-R_{b})}$, ${\displaystyle AvgC}$ is the average critical hit which is ${\displaystyle 98\%}$ of the maximum damage, ${\displaystyle AvgH}$ is the average hit which is 60% of the maximum damage, and ${\displaystyle R_{b}}$ is the activation chance based on the rank.

## Analysis

### Calculator

This calculator is for determining the percent increase from the Biting, Precise, and Equilibrium perks; in addition, Erethdor's grimoire is included due to its similarity with the Biting perk. Only ability damage range percents are taken into consideration.

Most abilities' minimum hits are 20% of their maximum hit, but some abilities also mention minimum hits. The minimum and maximum hit numbers can be changed, but leaving them between 20% and 100% gives correct damage increase numbers for most abilities.

Many sources of damage (such as Bleeds, Poison, Aftershock, Familiars and Crackling) are unaffected by Biting, Precise, Equilibrium, and Erethdor's grimoire. For that reason, the damage increases shown in this calculator will likely be higher than the overall damage increase seen during combat.

 Precise rank name=precRank1|type=int|range=0,6|sublist=init Equilibrium rank name=eqRank1|type=int|range=0,4|sublist=init Biting rank name=bitRank1|type=int|range=0,4|sublist=init Is Biting on level 20 gear? name=isLevel20_1|type=select|range=No,Yes|sublist=init Is Erethdor's grimoire active? name=grimoire1|type=select|range=No,Yes|sublist=init Is this PvP combat? name=isPvp1|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/grimoire name=normalAverageHitOut1|type=output Min hit with perks name=abilityMinHitOut1|type=output Max hit with perks name=abilityMaxHitOut1|type=output Average hit with perks/grimoire name=perkAverageHitOut1|type=output % damage increase from perks/grimoire 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) let(grim, grimoire1) let(pvp, isPvp1)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(normalAverageHitOut1, normalAverageHit)
let(abilityMinHitOut1, minHit)
let(abilityMaxHitOut1, maxHit)
let(perkAverageHitOut1, perkAverageHit)
let(percentIncreaseOut1, damageIncrease)
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 (and whether or not Erethdor's grimoire is active).
= perks you can get on one gizmo ${\displaystyle \left({\text{there exists a combination with chance}}\geq {\frac {1}{2000}}\right)}$.
= perks you can not get on one gizmo ${\displaystyle \left({\text{all possibile combinations have chance}}<{\frac {1}{2000}}\right)}$.

 Biting Rank name=bitRank2|type=int|range=0,4|sublist=init Is Biting on level 20 gear? name=isLevel20_2|type=select|range=No,Yes|sublist=init Is Erethdor's grimoire active? name=grimoire2|type=select|range=No,Yes|sublist=init Is this PvP combat? name=isPvp2|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/grimoire name=normalAverageHitOut2|type=output
type=button|sublist=init|value=Calculate
name=wrongInput2|type=output
init|

let(precRank, 6) let(eqRank, 4) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(normalAverageHitOut2, normalAverageHit)
let(minHitP6E4, minHit)
let(maxHitP6E4, maxHit)
let(averageHitP6E4, perkAverageHit)
let(damageIncreaseP6E4, damageIncrease)
let(wrongInput2, "")


}{

   let(normalAverageHitOut2, 60)
let(minHitP6E4, 20)
let(maxHitP6E4, 100)
let(averageHitP6E4, 60)
let(damageIncreaseP6E4, 0)
let(wrongInput2, "Please give a correct minimum and maximum ability damage.")


}

let(precRank, 6) let(eqRank, 3) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP6E3, minHit)
let(maxHitP6E3, maxHit)
let(averageHitP6E3, perkAverageHit)
let(damageIncreaseP6E3, damageIncrease)
let(n, "")


}{

   let(n, 60)
let(minHitP6E3, 20)
let(maxHitP6E3, 100)
let(averageHitP6E3, 60)
let(damageIncreaseP6E3, 0)
let(n, "Please give a correct minimum and maximum ability damage.")


}

let(precRank, 6) let(eqRank, 2) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP6E2, minHit)
let(maxHitP6E2, maxHit)
let(averageHitP6E2, perkAverageHit)
let(damageIncreaseP6E2, damageIncrease)
let(n, "")


}{

   let(n, 60)
let(minHitP6E2, 20)
let(maxHitP6E2, 100)
let(averageHitP6E2, 60)
let(damageIncreaseP6E2, 0)
let(n, "Please give a correct minimum and maximum ability damage.")


}

let(precRank, 6) let(eqRank, 1) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP6E1, minHit)
let(maxHitP6E1, maxHit)
let(averageHitP6E1, perkAverageHit)
let(damageIncreaseP6E1, damageIncrease)
let(n, "")


}{

   let(n, 60)
let(minHitP6E1, 20)
let(maxHitP6E1, 100)
let(averageHitP6E1, 60)
let(damageIncreaseP6E1, 0)
let(n, "Please give a correct minimum and maximum ability damage.")


}

let(precRank, 6) let(eqRank, 0) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP6E0, minHit)
let(maxHitP6E0, maxHit)
let(averageHitP6E0, perkAverageHit)
let(damageIncreaseP6E0, damageIncrease)
let(n, "")


}{

   let(n, 60)
let(minHitP6E0, 20)
let(maxHitP6E0, 100)
let(averageHitP6E0, 60)
let(damageIncreaseP6E0, 0)
let(n, "Please give a correct minimum and maximum ability damage.")


}

let(precRank, 5) let(eqRank, 4) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP5E4, minHit)
let(maxHitP5E4, maxHit)
let(averageHitP5E4, perkAverageHit)
let(damageIncreaseP5E4, damageIncrease)
let(n, "")


}{

   let(n, 60)
let(minHitP5E4, 20)
let(maxHitP5E4, 100)
let(averageHitP5E4, 60)
let(damageIncreaseP5E4, 0)
let(n, "Please give a correct minimum and maximum ability damage.")


}

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

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP5E3, minHit)
let(maxHitP5E3, maxHit)
let(averageHitP5E3, perkAverageHit)
let(damageIncreaseP5E3, damageIncrease)
let(n, "")


}{

   let(n, 60)
let(minHitP5E3, 20)
let(maxHitP5E3, 100)
let(averageHitP5E3, 60)
let(damageIncreaseP5E3, 0)
let(n, "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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP5E2, minHit)
let(maxHitP5E2, maxHit)
let(averageHitP5E2, perkAverageHit)
let(damageIncreaseP5E2, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP5E1, minHit)
let(maxHitP5E1, maxHit)
let(averageHitP5E1, perkAverageHit)
let(damageIncreaseP5E1, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP5E0, minHit)
let(maxHitP5E0, maxHit)
let(averageHitP5E0, perkAverageHit)
let(damageIncreaseP5E0, damageIncrease)
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, 4) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP4E4, minHit)
let(maxHitP4E4, maxHit)
let(averageHitP4E4, perkAverageHit)
let(damageIncreaseP4E4, damageIncrease)
let(n, "")


}{

   let(n, 60)
let(minHitP4E4, 20)
let(maxHitP4E4, 100)
let(averageHitP4E4, 60)
let(damageIncreaseP4E4, 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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP4E3, minHit)
let(maxHitP4E3, maxHit)
let(averageHitP4E3, perkAverageHit)
let(damageIncreaseP4E3, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP4E2, minHit)
let(maxHitP4E2, maxHit)
let(averageHitP4E2, perkAverageHit)
let(damageIncreaseP4E2, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP4E1, minHit)
let(maxHitP4E1, maxHit)
let(averageHitP4E1, perkAverageHit)
let(damageIncreaseP4E1, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP4E0, minHit)
let(maxHitP4E0, maxHit)
let(averageHitP4E0, perkAverageHit)
let(damageIncreaseP4E0, damageIncrease)
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, 4) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP3E4, minHit)
let(maxHitP3E4, maxHit)
let(averageHitP3E4, perkAverageHit)
let(damageIncreaseP3E4, damageIncrease)
let(n, "")


}{

   let(n, 60)
let(minHitP3E4, 20)
let(maxHitP3E4, 100)
let(averageHitP3E4, 60)
let(damageIncreaseP3E4, 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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP3E3, minHit)
let(maxHitP3E3, maxHit)
let(averageHitP3E3, perkAverageHit)
let(damageIncreaseP3E3, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP3E2, minHit)
let(maxHitP3E2, maxHit)
let(averageHitP3E2, perkAverageHit)
let(damageIncreaseP3E2, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP3E1, minHit)
let(maxHitP3E1, maxHit)
let(averageHitP3E1, perkAverageHit)
let(damageIncreaseP3E1, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP3E0, minHit)
let(maxHitP3E0, maxHit)
let(averageHitP3E0, perkAverageHit)
let(damageIncreaseP3E0, damageIncrease)
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, 4) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP2E4, minHit)
let(maxHitP2E4, maxHit)
let(averageHitP2E4, perkAverageHit)
let(damageIncreaseP2E4, damageIncrease)
let(n, "")


}{

   let(n, 60)
let(minHitP2E4, 20)
let(maxHitP2E4, 100)
let(averageHitP2E4, 60)
let(damageIncreaseP2E4, 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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP2E3, minHit)
let(maxHitP2E3, maxHit)
let(averageHitP2E3, perkAverageHit)
let(damageIncreaseP2E3, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP2E2, minHit)
let(maxHitP2E2, maxHit)
let(averageHitP2E2, perkAverageHit)
let(damageIncreaseP2E2, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP2E1, minHit)
let(maxHitP2E1, maxHit)
let(averageHitP2E1, perkAverageHit)
let(damageIncreaseP2E1, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP2E0, minHit)
let(maxHitP2E0, maxHit)
let(averageHitP2E0, perkAverageHit)
let(damageIncreaseP2E0, damageIncrease)
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, 4) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP1E4, minHit)
let(maxHitP1E4, maxHit)
let(averageHitP1E4, perkAverageHit)
let(damageIncreaseP1E4, damageIncrease)
let(n, "")


}{

   let(n, 60)
let(minHitP1E4, 20)
let(maxHitP1E4, 100)
let(averageHitP1E4, 60)
let(damageIncreaseP1E4, 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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP1E3, minHit)
let(maxHitP1E3, maxHit)
let(averageHitP1E3, perkAverageHit)
let(damageIncreaseP1E3, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP1E2, minHit)
let(maxHitP1E2, maxHit)
let(averageHitP1E2, perkAverageHit)
let(damageIncreaseP1E2, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP1E1, minHit)
let(maxHitP1E1, maxHit)
let(averageHitP1E1, perkAverageHit)
let(damageIncreaseP1E1, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP1E0, minHit)
let(maxHitP1E0, maxHit)
let(averageHitP1E0, perkAverageHit)
let(damageIncreaseP1E0, damageIncrease)
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, 4) let(bitRank, bitRank2) let(minHit, abilityMinHitIn2) let(maxHit, abilityMaxHitIn2) let(normalAverageHit, (maxHit + minHit)/2) let(isLevel20, isLevel20_2) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP0E4, minHit)
let(maxHitP0E4, maxHit)
let(averageHitP0E4, perkAverageHit)
let(damageIncreaseP0E4, damageIncrease)
let(n, "")


}{

   let(n, 60)
let(minHitP0E4, 20)
let(maxHitP0E4, 100)
let(averageHitP0E4, 60)
let(damageIncreaseP0E4, 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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP0E3, minHit)
let(maxHitP0E3, maxHit)
let(averageHitP0E3, perkAverageHit)
let(damageIncreaseP0E3, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP0E2, minHit)
let(maxHitP0E2, maxHit)
let(averageHitP0E2, perkAverageHit)
let(damageIncreaseP0E2, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP0E1, minHit)
let(maxHitP0E1, maxHit)
let(averageHitP0E1, perkAverageHit)
let(damageIncreaseP0E1, damageIncrease)
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) let(grim, grimoire2) let(pvp, isPvp2)

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(grimEffect, .12 * grim)
let(pvpLowerCrits, .145 * pvp)
let(forcedCritAverageHit, minHit + (0.975 - pvpLowerCrits) * (maxHit - minHit))
let(perkAverageHit, (1.0 - bitChance - grimEffect) * (maxHit + minHit) / 2 + (bitChance + grimEffect) * forcedCritAverageHit)

   let(damageIncrease, (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(damageIncrease, round(damageIncrease * 1000))
let(damageIncrease, damageIncrease / 1000)

   let(n, normalAverageHit)
let(minHitP0E0, minHit)
let(maxHitP0E0, maxHit)
let(averageHitP0E0, perkAverageHit)
let(damageIncreaseP0E0, damageIncrease)
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
6 4 name=minHitP6E4|type=output name=maxHitP6E4|type=output name=averageHitP6E4|type=output name=damageIncreaseP6E4|type=output
6 3 name=minHitP6E3|type=output name=maxHitP6E3|type=output name=averageHitP6E3|type=output name=damageIncreaseP6E3|type=output
6 2 name=minHitP6E2|type=output name=maxHitP6E2|type=output name=averageHitP6E2|type=output name=damageIncreaseP6E2|type=output
6 1 name=minHitP6E1|type=output name=maxHitP6E1|type=output name=averageHitP6E1|type=output name=damageIncreaseP6E1|type=output
6 0 name=minHitP6E0|type=output name=maxHitP6E0|type=output name=averageHitP6E0|type=output name=damageIncreaseP6E0|type=output
5 4 name=minHitP5E4|type=output name=maxHitP5E4|type=output name=averageHitP5E4|type=output name=damageIncreaseP5E4|type=output
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 4 name=minHitP4E4|type=output name=maxHitP4E4|type=output name=averageHitP4E4|type=output name=damageIncreaseP4E4|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 4 name=minHitP3E4|type=output name=maxHitP3E4|type=output name=averageHitP3E4|type=output name=damageIncreaseP3E4|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 4 name=minHitP2E4|type=output name=maxHitP2E4|type=output name=averageHitP2E4|type=output name=damageIncreaseP2E4|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 4 name=minHitP1E4|type=output name=maxHitP1E4|type=output name=averageHitP1E4|type=output name=damageIncreaseP1E4|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 4 name=minHitP0E4|type=output name=maxHitP0E4|type=output name=averageHitP0E4|type=output name=damageIncreaseP0E4|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

## Cost

The cost of a Biting perk using 180 direct components obtained by disassembling different types of salvage is as follows:

Perk Chance to obtain
Components per attempt Item Quantity required Total cost[note 1]
Biting 3 4.8% chance at precisely 68 Invention

(Use GWD entrance to lower your level to 68)

+ Mithril spear 2276 24,728,951
Rune spear 1364 33,759,545
Large blunt mithril salvage 4455 29,842,574
Huge blunt mithril salvage 3564 39,535,842
Large blunt adamant salvage 3346 62,317,472
Huge blunt adamant salvage 2675 116,007,727
Large blunt rune salvage 2675 81,960,178
Huge blunt rune salvage 2140 83,198,098

The cost of a Biting perk using noxious components obtained from disassembling a level 9 Noxious longbow, Noxious staff, and Noxious scythe is as follows:

Perk Chance to obtain
Components Total cost[note 2]
Biting 3 100% chance at level 120 + 53,799,767.75 57,413,765.25 84,152,882.5
Biting 4 100% chance at level 120 + 1  + 1  + 75,319,674.85 80,379,271.35 117,814,035.5
1. ^ The value of creating the ancient armour gizmo shell is ignored.
2. ^ The value of creating the (ancient) armour gizmo shell as well as obtaining the direct component and blade parts are ignored.

## Sources

MaterialRarityPerk ranks with X materials
Standard gizmoAncient gizmo
12345123456789
Direct componentsUncommon011–21–21–30111–21–21–21–31–41–4
Noxious componentsRare01223011–2222–33–444

### Suggested gizmos

Gizmo layout Possible perks Approx costs
• Other possible perks:
75,448,355.88
See RS:Material prices for details on how prices are approximated.
44.63% chance for Biting 4 and Undead Slayer at level 120, 49.43% with
• Other possible perks:
78,584,144.31
See RS:Material prices for details on how prices are approximated.
51.00% chance for Biting 4 and Dragon Slayer at level 120, 56.75% with
76,001,671.19
See RS:Material prices for details on how prices are approximated.
51.00% chance for Biting 4 and Demon Slayer at level 120, 56.75% with
102,461,528.45
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
75,419,277.89
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
77,058,167.11
See RS:Material prices for details on how prices are approximated.
53,799,767.75
See RS:Material prices for details on how prices are approximated.
4.86% success chance at 68-69 invention
• Other possible perks:
1,041,693.57
See RS:Material prices for details on how prices are approximated.
Chance for Biting 3 increases with and level 120.
Biting 2 chance is unaffected by and resides at 55.14% or 1/1.81
• Other possible perks:
991,915.21
See RS:Material prices for details on how prices are approximated.
78.09% or 1/1.28 at level 120.
• Other possible perks:
884,919.97
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
6,581,104.11
See RS:Material prices for details on how prices are approximated.
57.91% or 1/1.72 at level 120.
• Other possible perks:
847,931.88
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
1,492,202.45
See RS:Material prices for details on how prices are approximated.
64.33% or 1/1.55 at level 120.
• Other possible perks:
761,454.6
See RS:Material prices for details on how prices are approximated.
83.86% success chance at level 120, unaffected by
• Other possible perks:
4,074,675.57
See RS:Material prices for details on how prices are approximated.
49.61% or 1/2.01 at level 120.
• Other possible perks:
657,342.63
See RS:Material prices for details on how prices are approximated.
49.61% or 1/2.01 at level 120.
• Other possible perks:
617,901.42
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
553,829.47
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
471,723.41
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
528,940.29
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
364,728.17
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
4,459,051.22
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
1,232,785.86
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
449,544.19
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
465,035.92
See RS:Material prices for details on how prices are approximated.
73.25% at level 120. A 37% chance for biting 2 without cautious at level 34[1].
• Other possible perks:
475,912.22
See RS:Material prices for details on how prices are approximated.

## Update history

This information has been compiled as part of the update history project. Some updates may not be included - see here for how to help out!
• hotfix 18 September 2017 (Update):
• The activation rate of the Biting perk was corrected, and the perk reactivated.
• The Biting perk was deactivated, as it was triggering too often.
• patch 6 March 2017 (Update):
• Sources of crit chance now function whilst you have the equilibrium perk or aura active. This means that both the Tuska warpriest set effect and Biting perk now stack with the Equilibrium aura and perk.
• patch 22 February 2016 (Update):
• The Biting perk critical hit chance has been increased from +1% per rank to +2% per rank.
1. ^ You can lower your invention level through various ways, for example by lingering at the entrance to the god wars dungeon. Play around with the calculator first; the optimum levels if you want to have the highest chance for biting 2 only, without cautious, seem to be 34 & 35. Below and above these levels the percentage decreases according to the calculator.