Calculator:Combat/Biting Precise and Eruptive (2024)

List of damage increases for various Precise and Eruptive combinations, given a certain rank of Biting (and whether or not Erethdor's grimoire is active).
= perks you can get on one gizmo $(there exists a combination with chance \geq \frac{1}{2000})$ .
= perks you can not get on one gizmo $(all possibile combinations have chance < \frac{1}{2000})$ .

Biting rank	name=bitRank2\|type=int\|range=0,4\|sublist=init
Is Biting on level 20 gear?	name=isLevel20_2\|type=select\|range=No,Yes\|sublist=init
Is Erethdor's grimoire active?	name=grimoire2\|type=select\|range=No,Yes\|sublist=init
Min hit of ability	name=abilityMinHitIn2\|type=number\|range=0,2000\|value=90\|sublist=init
Max hit of ability	name=abilityMaxHitIn2\|type=number\|range=0,2000\|value=110\|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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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 * (1 + 0.005* eqRank)) let(minHit, minHit * (1 + 0.005* eqRank))

 let(bitChance, 0.02 * bitRank * (1 + isLevel20 / 10.0)) let(grimEffect, .12 * grim) let(perkAverageHit, (1.0 + 0.5 * (bitChance + grimEffect)) * (maxHit + minHit) / 2)

 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

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