Biting

From the RuneScape Wiki, the wiki for all things RuneScape
Jump to: navigation, search

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.

If going for biting 2 with a standard gizmo shell while trying to avoid co-perking with cautious, it may be useful to lower one's invention level by standing in the snowy entrance area to the God Wars Dungeon, as the highest likelihood of getting this perk happens around level 30 invention, and at higher levels biting 2 without cautious becomes increasingly unlikely.

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

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

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() of receiving a critical hit from biting, Where: , is the average critical hit which is of the maximum damage, is the average hit which is 60% of the maximum damage, and is the activation chance based on the rank.

Analysis[edit | edit source]

Calculator[edit source]

Head over to the calculator page for more documentation.

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' min hits are 20% of their max hit, but some abilities also mention min hits. The min and max hit numbers can be changed, but leaving them between 20% and 100% gives correct damage increase numbers for most abilities.

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

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(forcedCritAverageHit, minHit + 0.975 * (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).
Yes check.svg = perks you can get on one gizmo .
X mark.svg = perks you can not get on one gizmo .

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

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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)

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(forcedCritAverageHit, minHit + 0.975 * (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.")

}

Yes check.svg P E Min hit Max hit Average Hit % damage
increase
X mark.svg Precise.pngPerk rank 6.png6 Equilibrium.pngPerk rank 4.png4 name=minHitP6E4|type=output name=maxHitP6E4|type=output name=averageHitP6E4|type=output name=damageIncreaseP6E4|type=output
X mark.svg Precise.pngPerk rank 6.png6 Equilibrium.pngPerk rank 3.png3 name=minHitP6E3|type=output name=maxHitP6E3|type=output name=averageHitP6E3|type=output name=damageIncreaseP6E3|type=output
Yes check.svg Precise.pngPerk rank 6.png6 Equilibrium.pngPerk rank 2.png2 name=minHitP6E2|type=output name=maxHitP6E2|type=output name=averageHitP6E2|type=output name=damageIncreaseP6E2|type=output
Yes check.svg Precise.pngPerk rank 6.png6 Equilibrium.pngPerk rank 1.png1 name=minHitP6E1|type=output name=maxHitP6E1|type=output name=averageHitP6E1|type=output name=damageIncreaseP6E1|type=output
Yes check.svg Precise.pngPerk rank 6.png6 Equilibrium.png0 name=minHitP6E0|type=output name=maxHitP6E0|type=output name=averageHitP6E0|type=output name=damageIncreaseP6E0|type=output
X mark.svg Precise.pngPerk rank 5.png5 Equilibrium.pngPerk rank 4.png4 name=minHitP5E4|type=output name=maxHitP5E4|type=output name=averageHitP5E4|type=output name=damageIncreaseP5E4|type=output
X mark.svg Precise.pngPerk rank 5.png5 Equilibrium.pngPerk rank 3.png3 name=minHitP5E3|type=output name=maxHitP5E3|type=output name=averageHitP5E3|type=output name=damageIncreaseP5E3|type=output
Yes check.svg Precise.pngPerk rank 5.png5 Equilibrium.pngPerk rank 2.png2 name=minHitP5E2|type=output name=maxHitP5E2|type=output name=averageHitP5E2|type=output name=damageIncreaseP5E2|type=output
Yes check.svg Precise.pngPerk rank 5.png5 Equilibrium.pngPerk rank 1.png1 name=minHitP5E1|type=output name=maxHitP5E1|type=output name=averageHitP5E1|type=output name=damageIncreaseP5E1|type=output
Yes check.svg Precise.pngPerk rank 5.png5 Equilibrium.png0 name=minHitP5E0|type=output name=maxHitP5E0|type=output name=averageHitP5E0|type=output name=damageIncreaseP5E0|type=output
X mark.svg Precise.pngPerk rank 4.png4 Equilibrium.pngPerk rank 4.png4 name=minHitP4E4|type=output name=maxHitP4E4|type=output name=averageHitP4E4|type=output name=damageIncreaseP4E4|type=output
Yes check.svg Precise.pngPerk rank 4.png4 Equilibrium.pngPerk rank 3.png3 name=minHitP4E3|type=output name=maxHitP4E3|type=output name=averageHitP4E3|type=output name=damageIncreaseP4E3|type=output
Yes check.svg Precise.pngPerk rank 4.png4 Equilibrium.pngPerk rank 2.png2 name=minHitP4E2|type=output name=maxHitP4E2|type=output name=averageHitP4E2|type=output name=damageIncreaseP4E2|type=output
Yes check.svg Precise.pngPerk rank 4.png4 Equilibrium.pngPerk rank 1.png1 name=minHitP4E1|type=output name=maxHitP4E1|type=output name=averageHitP4E1|type=output name=damageIncreaseP4E1|type=output
Yes check.svg Precise.pngPerk rank 4.png4 Equilibrium.png0 name=minHitP4E0|type=output name=maxHitP4E0|type=output name=averageHitP4E0|type=output name=damageIncreaseP4E0|type=output
Yes check.svg Precise.pngPerk rank 3.png3 Equilibrium.pngPerk rank 4.png4 name=minHitP3E4|type=output name=maxHitP3E4|type=output name=averageHitP3E4|type=output name=damageIncreaseP3E4|type=output
Yes check.svg Precise.pngPerk rank 3.png3 Equilibrium.pngPerk rank 3.png3 name=minHitP3E3|type=output name=maxHitP3E3|type=output name=averageHitP3E3|type=output name=damageIncreaseP3E3|type=output
Yes check.svg Precise.pngPerk rank 3.png3 Equilibrium.pngPerk rank 2.png2 name=minHitP3E2|type=output name=maxHitP3E2|type=output name=averageHitP3E2|type=output name=damageIncreaseP3E2|type=output
Yes check.svg Precise.pngPerk rank 3.png3 Equilibrium.pngPerk rank 1.png1 name=minHitP3E1|type=output name=maxHitP3E1|type=output name=averageHitP3E1|type=output name=damageIncreaseP3E1|type=output
Yes check.svg Precise.pngPerk rank 3.png3 Equilibrium.png0 name=minHitP3E0|type=output name=maxHitP3E0|type=output name=averageHitP3E0|type=output name=damageIncreaseP3E0|type=output
Yes check.svg Precise.pngPerk rank 2.png2 Equilibrium.pngPerk rank 4.png4 name=minHitP2E4|type=output name=maxHitP2E4|type=output name=averageHitP2E4|type=output name=damageIncreaseP2E4|type=output
Yes check.svg Precise.pngPerk rank 2.png2 Equilibrium.pngPerk rank 3.png3 name=minHitP2E3|type=output name=maxHitP2E3|type=output name=averageHitP2E3|type=output name=damageIncreaseP2E3|type=output
Yes check.svg Precise.pngPerk rank 2.png2 Equilibrium.pngPerk rank 2.png2 name=minHitP2E2|type=output name=maxHitP2E2|type=output name=averageHitP2E2|type=output name=damageIncreaseP2E2|type=output
Yes check.svg Precise.pngPerk rank 2.png2 Equilibrium.pngPerk rank 1.png1 name=minHitP2E1|type=output name=maxHitP2E1|type=output name=averageHitP2E1|type=output name=damageIncreaseP2E1|type=output
Yes check.svg Precise.pngPerk rank 2.png2 Equilibrium.png0 name=minHitP2E0|type=output name=maxHitP2E0|type=output name=averageHitP2E0|type=output name=damageIncreaseP2E0|type=output
Yes check.svg Precise.pngPerk rank 1.png1 Equilibrium.pngPerk rank 4.png4 name=minHitP1E4|type=output name=maxHitP1E4|type=output name=averageHitP1E4|type=output name=damageIncreaseP1E4|type=output
Yes check.svg Precise.pngPerk rank 1.png1 Equilibrium.pngPerk rank 3.png3 name=minHitP1E3|type=output name=maxHitP1E3|type=output name=averageHitP1E3|type=output name=damageIncreaseP1E3|type=output
Yes check.svg Precise.pngPerk rank 1.png1 Equilibrium.pngPerk rank 2.png2 name=minHitP1E2|type=output name=maxHitP1E2|type=output name=averageHitP1E2|type=output name=damageIncreaseP1E2|type=output
Yes check.svg Precise.pngPerk rank 1.png1 Equilibrium.pngPerk rank 1.png1 name=minHitP1E1|type=output name=maxHitP1E1|type=output name=averageHitP1E1|type=output name=damageIncreaseP1E1|type=output
Yes check.svg Precise.pngPerk rank 1.png1 Equilibrium.png0 name=minHitP1E0|type=output name=maxHitP1E0|type=output name=averageHitP1E0|type=output name=damageIncreaseP1E0|type=output
Yes check.svg Precise.png0 Equilibrium.pngPerk rank 4.png4 name=minHitP0E4|type=output name=maxHitP0E4|type=output name=averageHitP0E4|type=output name=damageIncreaseP0E4|type=output
Yes check.svg Precise.png0 Equilibrium.pngPerk rank 3.png3 name=minHitP0E3|type=output name=maxHitP0E3|type=output name=averageHitP0E3|type=output name=damageIncreaseP0E3|type=output
Yes check.svg Precise.png0 Equilibrium.pngPerk rank 2.png2 name=minHitP0E2|type=output name=maxHitP0E2|type=output name=averageHitP0E2|type=output name=damageIncreaseP0E2|type=output
Yes check.svg Precise.png0 Equilibrium.pngPerk rank 1.png1 name=minHitP0E1|type=output name=maxHitP0E1|type=output name=averageHitP0E1|type=output name=damageIncreaseP0E1|type=output
Yes check.svg Precise.png0 Equilibrium.png0 name=minHitP0E0|type=output name=maxHitP0E0|type=output name=averageHitP0E0|type=output name=damageIncreaseP0E0|type=output


Cost[edit | edit source]

The cost of a Biting perk using Direct components obtained by disassembling Huge blunt adamant salvage.png: RS3 Inventory image of Huge blunt adamant salvageHuge blunt adamant salvage is as follows:

Perk Chance to obtain Direct components Total cost
Biting 1 51% chance at 99 Invention or higher Direct components.png: RS3 Inventory image of Direct components 4 1,391,280
Biting 2 96% chance at 99 Invention or higher Direct components.png: RS3 Inventory image of Direct components 7 2,434,740
Biting 3 4.8% chance at 68 Invention Direct components.png: RS3 Inventory image of Direct components 180 62,607,600

The cost of a Biting perk using Noxious components obtained from disassembling a level 9 Noxious longbow.png: RS3 Inventory image of Noxious longbowNoxious longbow is as follows:

Perk Chance to obtain Noxious components Total cost
Biting 3 100% chance Noxious components.png: RS3 Inventory image of Noxious components 5 39,700,185.75
Biting 4 100% chance Noxious components.png: RS3 Inventory image of Noxious components 7 55,580,260.05

The cost of a Biting perk using Noxious components obtained from disassembling a level 9 Noxious staff.png: RS3 Inventory image of Noxious staffNoxious staff is as follows:

Perk Chance to obtain Noxious components Total cost
Biting 3 100% chance Noxious components.png: RS3 Inventory image of Noxious components 5 43,311,220.75
Biting 4 100% chance Noxious components.png: RS3 Inventory image of Noxious components 7 60,635,709.05

Sources[edit | edit source]

MaterialRarityPerk ranks with X materials
Standard gizmoAncient gizmo
12345123456789
Direct components.png
Direct componentsUncommon011–21–21–30111–21–21–21–31–41–4
Noxious components.png
Noxious componentsRare01223011–2222–33–444
Blade parts.png
Blade partsCommon00111–20001111–21–21–2

Suggested gizmos[edit | edit source]

Gizmo layout Possible perks
Noxious components.pngNoxious components.pngNoxious components.png
Noxious components.pngNoxious components.pngNoxious components.png
Direct components.pngNoxious components.pngBlade parts.png
  • Other possible perks:
Noxious components.pngNoxious components.pngNoxious components.png
Noxious components.pngNoxious components.pngNoxious components.png
Undead components.pngNoxious components.pngLiving components.png
44.63% chance for Biting 4 and Undead Slayer at level 120, 49.43% with Extreme invention.png: RS3 Inventory image of Extreme invention
  • Other possible perks:
Noxious components.pngNoxious components.pngNoxious components.png
Noxious components.pngNoxious components.pngNoxious components.png
Dragonfire components.pngNoxious components.pngDragonfire components.png
51.00% chance for Biting 4 and Dragon Slayer at level 120, 56.75% with Extreme invention.png: RS3 Inventory image of Extreme invention
Noxious components.pngNoxious components.pngNoxious components.png
Noxious components.pngNoxious components.pngNoxious components.png
Third-age components.pngNoxious components.pngThird-age components.png
51.00% chance for Biting 4 and Demon Slayer at level 120, 56.75% with Extreme invention.png: RS3 Inventory image of Extreme invention
Noxious components.pngNoxious components.pngNoxious components.png
Noxious components.pngNoxious components.pngNoxious components.png
Dextrous components.pngNoxious components.pngSubtle components.png
Noxious components.pngNoxious components.pngNoxious components.png
Noxious components.pngNoxious components.pngNoxious components.png
Bandos components.pngNoxious components.pngBandos components.png
  • Other possible perks:
Noxious components.png
Noxious components.pngNoxious components.pngNoxious components.png
Noxious components.png
Direct components.pngDirect components.pngDirect components.png
Direct components.pngDirect components.pngDirect components.png
Direct components.pngDirect components.pngDirect components.png
4.86% success chance at 68-69 invention
  • Other possible perks:
Direct components.pngDirect components.pngDirect components.png
Direct components.pngDirect components.pngDirect components.png
Subtle components.pngDirect components.pngSubtle components.png
Chance for Biting 3 increases with Extreme invention.png: RS3 Inventory image of Extreme invention and level 120.
Biting 2 chance is unaffected by Extreme invention.png: RS3 Inventory image of Extreme invention and resides at 55.14% or 1/1.81
Direct components.pngDirect components.pngDirect components.png
Direct components.pngDextrous components.pngDirect components.png
Subtle components.pngDirect components.pngSubtle components.png
78.09% or 1/1.28 at level 120.
Direct components.pngDirect components.pngDirect components.png
Direct components.pngDirect components.pngDirect components.png
Pestiferous components.pngDirect components.pngPestiferous components.png
  • Other possible perks:
Direct components.pngDirect components.pngHealthy components.png
Direct components.pngDirect components.pngDirect components.png
Healthy components.pngDirect components.pngHealthy components.png
57.91% or 1/1.72 at level 120.
  • Other possible perks:
Direct components.pngDirect components.pngDirect components.png
Direct components.pngDirect components.pngDirect components.png
Dragonfire components.pngDirect components.pngDragonfire components.png
  • Other possible perks:
Direct components.pngDirect components.pngDirect components.png
Direct components.pngEnhancing components.pngDirect components.png
Enhancing components.pngDirect components.pngEnhancing components.png
64.33% or 1/1.55 at level 120.
Direct components.pngDirect components.pngDirect components.png
Direct components.pngDirect components.pngDirect components.png
Undead components.pngDirect components.pngLiving components.png
83.86% success chance at level 120, unaffected by Extreme invention.png: RS3 Inventory image of Extreme invention
  • Other possible perks:
Direct components.pngLiving components.pngDirect components.png
Living components.pngBlade parts.pngLiving components.png
Direct components.pngDirect components.pngDirect components.png
49.61% or 1/2.01 at level 120.
  • Other possible perks:
Direct components.pngDirect components.pngDextrous components.png
Direct components.pngBlade parts.pngDirect components.png
Dextrous components.pngDirect components.pngDextrous components.png
49.61% or 1/2.01 at level 120.
Direct components.png
Direct components.pngDirect components.pngDirect components.png
Subtle components.png
  • Other possible perks:
Direct components.png
Direct components.pngDirect components.pngDirect components.png
Dextrous components.png
  • Other possible perks:
Direct components.png
Direct components.pngDirect components.pngSubtle components.png
Subtle components.png
Direct components.png
Direct components.pngDirect components.pngDextrous components.png
Dextrous components.png
Undead components.png
Direct components.pngBandos components.pngDirect components.png
Direct components.png
  • Other possible perks:
Direct components.png
Direct components.pngDirect components.pngPowerful components.png
Bandos components.png
  • Other possible perks:
Direct components.png
Direct components.pngDirect components.pngHealthy components.png
Healthy components.png
  • Other possible perks:
Direct components.png
Direct components.pngDirect components.pngDirect components.png
Harnessed components.png
  • Other possible perks:

Update history[edit | edit source]

The update history project is a work-in-progress – not all updates to this topic may be covered below. 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.
  • hotfix 18 September 2017) (Update):
    • 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.