# Precise

Precise is an perk for Invention that increases the minimum hit of abilities and auto attacks by a percentage of its maximum hit. It can be created in weapon gizmos. Damage-over-time abilities are not affected by Precise.

## Calculations

Average hit formula
• Without Precise:
${\displaystyle {\frac {M+m}{2}}=a}$
• With Precise:
${\displaystyle {\frac {M+(m+(r\cdot 1.5\%\cdot M))}{2}}=A}$
• Average hit increase formula:
${\displaystyle {\frac {A-a}{a}}=a_{increase}}$
Notes
• ${\displaystyle m}$ = Minimum ability damage
• ${\displaystyle M}$ = Maximum ability damage
• ${\displaystyle r}$ = rank of the precise perk
• ${\displaystyle a_{increase}}$ = Average hit increase
Examples
• Average hit increase for Slice (damage range 30–120%) with Precise 5:
${\displaystyle a={\frac {120\%+30\%}{2}}=75\%}$
${\displaystyle A={\frac {120\%+(30\%+(5\cdot 1.5\%\cdot 120\%))}{2}}=79.5\%}$
${\displaystyle a_{increase}={\frac {79.5\%-75\%}{75\%}}=6\%}$

## Optimal ancient gizmo combinations

An ideal ancient weapon gizmo for off-hand and two-handed weapons contains one of the following perk combinations:

These combinations give approximately 1% more damage than a common Precise 6 and Genocidal (P6Geno) gizmo.

• P6E1 is slightly better than P6R1.
• P6AS1 is ideal for maintaining aftershock stacks.
• P6R1 is ideal for large amounts of weak monsters.

The suggested combination for P6E2 is 5 Precise components and 4 Armadyl components. For P6AS1, use 7 Armadyl components and 2 Ilujankan components. For P6R1, use 7 Armadyl components and 2 Timeworn components. For P6Geno, use 9 Historic components. Since these gizmos are very rare (and thus expensive), it is recommended to attain level 120 Invention and to drink an extreme invention potion (or super invention for players with lower Herblore) before attempting them. As the damage increase is small, it may be more cost effective to improve gear in other areas before pursuing these combination gizmos.

## Regular gizmo combinations

An ideal weapon gizmo for off-hand and two-handed weapons contains one of the following perk combinations:

• Precise 4 and Equilibrium 2 (P4E2)
• Precise 5 and Equilibrium 1 (P5E1)

These combinations give approximately 1% more damage than a common Precise 5 or Precise 3 and Equilibrium 2 gizmos.

• P4E2 is slightly better than P5E1 for Magic due to four-tick auto attacks.
• P5E1 is ideal for Ranged and melee.

The suggested combination for P4E2 is 5 Precise components. For P5E1, use 2 Precise components and 3 Armadyl component. Since these gizmos are very rare (and thus expensive), it is recommended to attain level 120 Invention and to drink an extreme invention potion (or super invention for players with lower Herblore) before attempting them. As the damage increase is small, it may be more cost effective to improve gear in other areas before pursuing these combination gizmos.

## Analysis

Typically, abilities have ability damage ranges from 20% to 100%; this can be represented as a ratio 1:5. As an example, Havoc's ability damage range is 25–125%; this can be calculated as 20–100%, as the percentage range ratio is 1:5.

As such, Precise increases the ability damage of abilities with a 1:5 ratio as follows:

Rank Increase Avg hit Avg hit increase
N/A 0.0% 60% 0%
1 1.5% 60.75% 1.25%
2 3.0% 61.5% 2.5%
3 4.5% 62.25% 3.75%
4 6.0% 63% 5%
5 7.5% 63.75% 6.25%
6 9.0% 64.5% 7.5%
• The table above applies to abilities with a damage range of 20%–100%, excluding Dismember. The average hit of abilities which cause bleeds are calculated with a different formula; furthermore they are unaffected by the damage increase of Invention perks.

The table below lists the average hit increase of abilities that have a different ratio of ability damage.

Skill Ability Min hit (Normal) Min hit (Precise 5) Max hit Average hit (Normal) Average hit (Precise 5) Average hit increase
Attack
Slice 30% 39% 120% 75% 79.5% 6%
Slice (Stun) 80% 90.95% 146% 113% 118.475% 4.845%
Overpower 200% 230% 400% 300% 315% 5%
Strength
Hurricane 84% 96.08% 161% 122.5% 128.54% 4.93%
Hurricane (Adjacent) 66% 82.43% 219% 142.5% 150.71% 5.76%
Meteor Strike 250% 276.25% 350% 300% 313.125% 4.375%
Pulverise 250% 276.25% 350% 300% 313.125% 4.375%
Frenzy (Hit #1) 80% 93.5% 180% 130% 136.75% 5.19%
Frenzy (Hit #2) 90% 105% 200% 145% 152.5% 5.17%
Frenzy (Hit #3) 100% 116.5% 220% 160% 168.25% 5.16%
Frenzy (Hit #4) 110% 128% 240% 175% 184% 5.14%
Ranged
Snap Shot (Hit #1) 100% 109% 120% 110% 114.5% 4.09%
Snap Shot (Hit #2) 100% 115.75% 210% 155% 162.88% 5.08%
Snipe 125% 141.43% 219% 172% 180.21% 4.77%
Magic
Omnipower 200% 230% 400% 300% 315% 5%
Detonate 100% 126.25% 350% 225% 238.13% 5.84%
Tsunami 200% 222.50% 300% 250% 261.25% 4.5%
Constitution
Tuska's Wrath 30% 38.2% 110% 70% 74.1% 5.86%

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

## Sources

MaterialRarityPerk ranks with X materials
Standard gizmoAncient gizmo
12345123456789
Historic componentsAncient0000001–21–31–41–51–61–62–62–6
Precise componentsUncommon01–21–21–31–4011–21–21–31–41–51–51–6
Connector partsCommon0011–21–2000111–21–21–21–3

### Suggested gizmos

Gizmo layout Possible perks Approx costs
• Other possible perks:
392,170
See RS:Material prices for details on how prices are approximated.
This combination is for Precise 6, Aftershock 1.
52,086,559
See RS:Material prices for details on how prices are approximated.
This combination is for Precise 6, Caroming 1.
58,656,007
See RS:Material prices for details on how prices are approximated.
This combination is for Precise 6, Ruthless 1.
33,002,793
See RS:Material prices for details on how prices are approximated.
This combination is for Precise 6, Dragon Slayer.
33,604,477
See RS:Material prices for details on how prices are approximated.
This combination is for Precise 6, Demon Slayer.
64,006,031
See RS:Material prices for details on how prices are approximated.
This combination is for Precise 6, Undead Slayer.
• Other possible perks:
36,716,431
See RS:Material prices for details on how prices are approximated.
This combination is for Precise 2, Aftershock 4.
67,095,678
See RS:Material prices for details on how prices are approximated.
This combination is highly recommended for Precise 6 Equilibrium 1 at 120 Invention.
• Other possible perks:
23,638,199
See RS:Material prices for details on how prices are approximated.
This is the cheapest combination for Precise 6 Equilibrium 2.
• Other possible perks:
374,506
See RS:Material prices for details on how prices are approximated.
This is the cheapest combination for Precise 6 Equilibrium 2 that uses armadyl components.
• Other possible perks:
14,329,189
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
18,983,694
See RS:Material prices for details on how prices are approximated.
This combination is for Precise 6, Equilibrium 1.
• Other possible perks:
28,320,496
See RS:Material prices for details on how prices are approximated.
23,356,904
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
4,738,884
See RS:Material prices for details on how prices are approximated.
• Other possible perks:
84,379
See RS:Material prices for details on how prices are approximated.
This combination is for Precise 5 Equilibrium 1, and should only be used in attempts for that gizmo.
• Other possible perks:
14,047,894
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!
• patch 29 February 2016 (Update):
• Abilities no longer suffer the 10k damage cap when using the 'Precise' perk.
• patch 22 February 2016 (Update):
• The Precise perk now has an increased minimum damage of 1.5% per rank of your maximum damage, up from 1%.