Precise

Precise

Release date	25 January 2016 (Update)
Gizmo type	Weapon
Maximum rank
Standard	5
Ancient	6
In-game description
Increases your minimum damage by 1.5% per rank of your maximum damage.
Infobox • Talk page

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[edit | edit source]

Average hit formula

Without Precise:

{\frac {M+m}{2}}=a

With Precise:

{\frac {M+(m+(r\cdot 1.5\%\cdot M))}{2}}=A

Average hit increase formula:

{\frac {A-a}{a}}=a_{increase}

Notes

$m$ = Minimum ability damage
$M$ = Maximum ability damage
$r$ = rank of the precise perk
$a_{increase}$ = Average hit increase

Examples

Average hit increase for Slice (damage range 30–120%) with Precise 5:

a={\frac {120\%+30\%}{2}}=75\%

A={\frac {120\%+(30\%+(5\cdot 1.5\%\cdot 120\%))}{2}}=79.5\%

a_{increase}={\frac {79.5\%-75\%}{75\%}}=6\%

Optimal ancient gizmo combinations[edit | edit source]

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

Precise 6 and Equilibrium 2 (P6E2)
Precise 6 and Equilibrium 1 (P6E1)
Precise 6 and Aftershock 1 (P6AS1)
Precise 6 and Ruthless 1 (P6R1)

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[edit | edit source]

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[edit | edit source]

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
Constitution	Tuska's Wrath	30%	38.2%	110%	70%	74.1%	5.86%

Calculator[edit source]

This dynamic calculator requires JavaScript.

This page takes user input via JavaScript and may use changing prices from the Grand Exchange Market Watch.

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' 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 $\left({\text{there exists a combination with chance}}\geq {\frac {1}{2000}}\right)$ .
= perks you can not get on one gizmo $\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[edit | edit source]

	Rarity	Perk ranks with X materials
		Standard gizmo					Ancient gizmo
		1	2	3	4	5	1	2	3	4	5	6	7	8	9
Armadyl components	Rare	1	2	3	4	5	0	1–2	2	3	4	5	5–6	6	6
Historic components	Ancient	0	0	0	0	0	0	1–2	1–3	1–4	1–5	1–6	1–6	2–6	2–6
Precise components	Uncommon	0	1–2	1–2	1–3	1–4	0	1	1–2	1–2	1–3	1–4	1–5	1–5	1–6
Connector parts	Common	0	0	1	1–2	1–2	0	0	0	1	1	1–2	1–2	1–2	1–3

Suggested gizmos[edit | edit source]

Gizmo layout

Possible perks

Approx costs

Precise 6
Genocidal

Other possible perks:

Open in calculator:

Ancient weapon

392,170

9x Historic 9,178 each
Ancient weapon gizmo 309,568 each

See RS:Material prices for details on how prices are approximated.

This combination is for Precise 6, Aftershock 1.

Precise 6
Aftershock 1

Open in calculator:

Ancient weapon

52,086,559

7x Armadyl 4,660,739 each
2x Ilujankan 9,575,909 each
Ancient weapon gizmo 309,568 each

See RS:Material prices for details on how prices are approximated.

This combination is for Precise 6, Caroming 1.

Precise 6
Caroming 1

Open in calculator:

Ancient weapon

58,656,007

7x Armadyl 4,660,739 each
2x Shadow 12,860,633 each
Ancient weapon gizmo 309,568 each

See RS:Material prices for details on how prices are approximated.

This combination is for Precise 6, Ruthless 1.

Precise 6
Ruthless 1

Open in calculator:

Ancient weapon

33,002,793

7x Armadyl 4,660,739 each
2x Timeworn 34,026 each
Ancient weapon gizmo 309,568 each

See RS:Material prices for details on how prices are approximated.

This combination is for Precise 6, Dragon Slayer.

Precise 6
Dragon Slayer

Open in calculator:

Ancient weapon

33,604,477

7x Armadyl 4,660,739 each
2x Dragonfire 334,868 each
Ancient weapon gizmo 309,568 each

See RS:Material prices for details on how prices are approximated.

This combination is for Precise 6, Demon Slayer.

Precise 6
Demon Slayer

Open in calculator:

Ancient weapon

64,006,031

7x Armadyl 4,660,739 each
2x Third-age 15,535,645 each
Ancient weapon gizmo 309,568 each

See RS:Material prices for details on how prices are approximated.

This combination is for Precise 6, Undead Slayer.

Precise 6
Undead Slayer

Other possible perks:

Talking

Open in calculator:

Ancient weapon

36,716,431

7x Armadyl 4,660,739 each
1x Living 24,800 each
1x Undead 3,756,890 each
Ancient weapon gizmo 309,568 each

See RS:Material prices for details on how prices are approximated.

This combination is for Precise 2, Aftershock 4.

Precise 2
Aftershock 4

Open in calculator:

Ancient weapon

67,095,678

1x Historic 9,178 each
2x Armadyl 4,660,739 each
6x Ilujankan 9,575,909 each
Ancient weapon gizmo 309,568 each

See RS:Material prices for details on how prices are approximated.

This combination is highly recommended for Precise 6 Equilibrium 1 at 120 Invention.

Precise 4–6
Equilibrium 1–2 (2 is very rare)

Other possible perks:

Open in calculator:

Ancient weapon

23,638,199

5x Armadyl 4,660,739 each
4x Precise 6,234 each
Ancient weapon gizmo 309,568 each

See RS:Material prices for details on how prices are approximated.

This is the cheapest combination for Precise 6 Equilibrium 2.

Precise 4–6 (6 is very rare)
Equilibrium 2

Other possible perks:

Open in calculator:

Ancient weapon

374,506

3x Historic 9,178 each
6x Precise 6,234 each
Ancient weapon gizmo 309,568 each

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.

Precise 6
Equilibrium 1–2

Other possible perks:

Open in calculator:

Ancient weapon

14,329,189

3x Armadyl 4,660,739 each
6x Precise 6,234 each
Ancient weapon gizmo 309,568 each

See RS:Material prices for details on how prices are approximated.

Precise 6
Equilibrium 1–2

Other possible perks:

Open in calculator:

Ancient weapon

18,983,694

4x Armadyl 4,660,739 each
5x Precise 6,234 each
Ancient weapon gizmo 309,568 each

See RS:Material prices for details on how prices are approximated.

This combination is for Precise 6, Equilibrium 1.

Precise 6
Equilibrium 1

Other possible perks:

Open in calculator:

Ancient weapon

28,320,496

1x Timeworn 34,026 each
2x Precise 6,234 each
6x Armadyl 4,660,739 each
Ancient weapon gizmo 309,568 each

See RS:Material prices for details on how prices are approximated.

Precise 5

Open in calculator:

Weapon

23,356,904

5x Armadyl 4,660,739 each
Weapon gizmo 53,209 each

See RS:Material prices for details on how prices are approximated.

Precise 2–5
Equilibrium 1–2

Other possible perks:

Open in calculator:

Weapon

4,738,884

1x Armadyl 4,660,739 each
4x Precise 6,234 each
Weapon gizmo 53,209 each

See RS:Material prices for details on how prices are approximated.

Precise 1–4
Equilibrium 1–2

Other possible perks:

Open in calculator:

Weapon

84,379

5x Precise 6,234 each
Weapon gizmo 53,209 each

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.

Precise 1–5 (5 is very rare)
Equilibrium 1

Other possible perks:

Open in calculator:

Weapon

14,047,894

3x Armadyl 4,660,739 each
2x Precise 6,234 each
Weapon gizmo 53,209 each

See RS:Material prices for details on how prices are approximated.

Update history[edit | edit source]

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

update 25 January 2016 (Update):
- Added to game.

v • d • e RS3 Invention perks
Abilities	Brief Respite Bulwark Caroming Clear Headed Energising Lunging Mobile Planted Feet Preparation Reflexes Shield Bashing Turtling Ultimatums Taunting
Damage/Accuracy modifying	Aftershock Biting Blunted Crackling Demon Bait Demon Slayer Dragon Bait Dragon Slayer Equilibrium Flanking Genocidal Inaccurate Mediocrity Precise Spendthrift Undead Bait Undead Slayer
Damage reduction	Absorbative Crystal Shield Devoted Enhanced Devoted Lucky Venomblood
Adrenaline	Fatiguing Invigorating Impatient
Prayer	Antitheism Profane Hoarding
Additional items	Brassican Looting Prosper Scavenging
Experience	Enlightened Tinker Wise
Skilling	Butterfingers Breakdown Charitable Cheapskate Confused Furnace Honed Imp Souled Polishing Pyromaniac Rapid Refined
Energy drain reduction	Efficient Enhanced Efficient
Utility	Cautious Committed Glow Worm Trophy-taker's
Miscellaneous	Hallucinogenic Junk Food Mysterious Talking
Ancient	Fortune Relentless Ruthless

Precise

Contents

Calculations[edit | edit source]

Optimal ancient gizmo combinations[edit | edit source]

Regular gizmo combinations[edit | edit source]

Analysis[edit | edit source]

Calculator[edit source]

Sources[edit | edit source]

Suggested gizmos[edit | edit source]

Update history[edit | edit source]

Navigation menu

Precise

Calculations[edit | edit source]

Optimal ancient gizmo combinations[edit | edit source]

Regular gizmo combinations[edit | edit source]

Analysis[edit | edit source]

Calculator[edit source]

Sources[edit | edit source]

Suggested gizmos[edit | edit source]

Update history[edit | edit source]

Navigation menu

Search