roll20-character-sheets/Demon Gate/DemonGate.html

<script type="text/worker">
    function GetRank(att)
    {
        if(att <= 0) return 0;
        
        if(att <= 15) return Math.floor((att + 2) / 3);
        
        if(att <= 99) return Math.floor((att - 14) / 2) + 5;
        
        return x - 52;
    }
    
    function GetDice(rank)
    {
        if(rank === "" || rank === "-") {
            return "";
        }
    
        if(rank > 50) return "4d20!+2d10!";
        
        switch(rank)
        {
            case 1:
                return "d2";
            case 2:
                return "d4!";
            case 3:
                return "d6!";
            case 4:
                return "d8!";
            case 5:
                return "d10!";
            case 6:
                return "d12!";
            case 7:
                return "d8!+d6!";
            case 8:
                return "2d8!";
            case 9:
                return "d10!+d8!";
            case 10:
                return "2d10!";
            case 11:
                return "d12!+d10!";
            case 12:
                return "2d12!";
            case 13:
                return "d20!+d6!";
            case 14:
                return "d20!+d8!";
            case 15:
                return "d20!+d10!";
            case 16:
                return "d20!+d12!";
            case 17:
                return "d20!+d8!+d6!";
            case 18:
                return "d20!+2d8!";
            case 19:
                return "d20!+d10!+d8!";
            case 20:
                return "d20!+2d10!";
            case 21:
                return "d20!+d12!+d10!";
            case 22:
                return "d20!+2d12!";
            case 23:
                return "2d20!+d6!";
            case 24:
                return "2d20!+d8!";
            case 25:
                return "2d20!+d10!";
            case 26:
                return "2d20!+d12!";
            case 27:
                return "2d20!+d8!+d6!";
            case 28:
                return "2d20!+2d8!";
            case 29:
                return "2d20!+d10!+d8!";
            case 30:
                return "2d20!+2d10!";
            case 31:
                return "2d20!+d12!+d10!";
            case 32:
                return "2d20!+2d12!";
            case 33:
                return "3d20!+d6!";
            case 34:
                return "3d20!+d8!";
            case 35:
                return "3d20!+d10!";
            case 36:
                return "3d20!+d12!";
            case 37:
                return "3d20!+d8!+d6!";
            case 38:
                return "3d20!+2d8!";
            case 39:
                return "3d20!+d10!+d8!";
            case 40:
                return "3d20!+2d10!";
            case 41:
                return "3d20!+d12!+d10!";
            case 42:
                return "3d20!+2d12!";
            case 43:
                return "4d20!+d6!";
            case 44:
                return "4d20!+d8!";
            case 45:
                return "4d20!+d10!";
            case 46:
                return "4d20!+d12!";
            case 47:
                return "4d20!+d6!+d8!";
            case 48:
                return "4d20!+2d8!";
            case 49:
                return "4d20!+d8!+d10!";
            case 50:
                return "4d20!+2d10!";
            default:
                return "";
        }
    }
    
    function GetDmgMod(str)
    {
        if(str <= 3) return Math.min(-3, 4 - str);
        if(str >= 80) return 33;
        if(str >= 15) return Math.floor((str - 13) / 2);
        return 0;
    }
    
    function GetWtAllow(str)
    {
        if(str <= 3) return "vl";
        if(str <= 9) return "l";
        if(str <= 14) return "m/2vl";
        if(str <= 19) return "h/2l";
        if(str <= 30) return "vh/2m";
        if(str <= 49) return "vh/2h";
        return "vh/2vh";
    }
    
    function GetDefMod(dex)
    {
        if(dex <= 3) return Math.min(-3, 4 - dex);
        if(dex >= 80) return 8;
        if(dex >= 15) return Math.floor(dex / 10);
        return 0;
    }
    
    function GetMvMod(dex)
    {
        if(dex <= 3) return -1;
        if(dex >= 60) return 5;
        if(dex >= 50) return 4;
        if(dex >= 15) return Math.floor(dex / 10);
        return 0;
    }
    
    function GetToughness(bdy)
    {
        if(bdy <= 17) return 0;
        if(bdy <= 21) return bdy - 17;
        if(bdy <= 26) return Math.floor((bdy - 13) / 2);
        if(bdy <= 35) return Math.floor((bdy - 6) / 3);
        if(bdy <= 47) return Math.floor((bdy + 4) / 4);
        if(bdy <= 62) return Math.floor((bdy + 17) / 5);
        if(bdy <= 74) return Math.floor((bdy + 33) / 6);
        return 18;
    }
    
    function GetHPAdj(bdy)
    {
        if(bdy <= 14) return 0;
        if(bdy == 15) return 1;
        if(bdy == 16) return 3;
        if(bdy == 17) return 6;
        if(bdy == 18) return 10;
        if(bdy == 19) return 15;
        if(bdy <= 21) return 21;
        if(bdy <= 23) return 28;
        if(bdy <= 25) return 36;
        if(bdy <= 27) return 45;
        if(bdy <= 30) return 55;
        if(bdy <= 33) return 66;
        if(bdy <= 36) return 78;
        if(bdy <= 39) return 91;
        if(bdy <= 42) return 105;
        if(bdy <= 46) return 120;
        if(bdy <= 50) return 136;
        if(bdy <= 54) return 153;
        if(bdy <= 58) return 171;
        if(bdy <= 62) return 190;
        if(bdy <= 67) return 210;
        if(bdy <= 72) return 231;
        if(bdy <= 77) return 253;
        return 276;
    }
    
    function GetBodySave(bdy)
    {
        if(bdy <= 15) return 18;
        if(bdy <= 17) return 17;
        if(bdy <= 19) return 16;
        if(bdy <= 21) return 15;
        if(bdy <= 24) return 14;
        if(bdy <= 27) return 13;
        if(bdy <= 30) return 12;
        if(bdy <= 34) return 11;
        if(bdy <= 39) return 10;
        if(bdy <= 49) return 9;
        if(bdy <= 59) return 8;
        if(bdy <= 69) return 7;
        return 6;
    }
    
    function GetShotDmg(prc)
    {
        if(prc >= 78) return 22;
        if(prc >= 15) return Math.floor((prc - 12) / 3);
        return 0;
    }
    
    function GetRange(prc)
    {
        if(prc >= 80) return 8;
        if(prc >= 15) return Math.floor(prc / 10);
        return 0;
    }
    
    function GetSpellEffect(int)
    {
        if(int >= 80) return 8;
        if(int >= 15) return Math.floor(int / 10);
        return 0;
    }
    
    function GetSpellTime(int)
    {
        if(int <= 3) return "";
        if(int <= 6) return "d4";
        if(int <= 9) return "d12";
        if(int <= 12) return "d8";
        if(int <= 14) return "d4";
        if(int <= 19) return "2d6";
        if(int <= 24) return "d8";
        if(int <= 29) return "d6";
        if(int <= 39) return "2d10";
        if(int <= 49) return "2d6";
        if(int <= 59) return "d10";
        if(int <= 69) return "d8";
        if(int <= 79) return "d6";
        return "d4";
    }
    
    function GetSpellTimeText(int)
    {
        if(int <= 3) return "";
        if(int <= 6) return "years";
        if(int <= 14) return "months";
        if(int <= 29) return "weeks";
        return "days";
    }
    
    function GetLangs(int)
    {
        if(int <= 3) return 0;
        if(int <= 11) return 1;
        if(int <= 14) return 2;
        if(int <= 19) return 3;
        return Math.floor(int / 10 + 2);
    }
    
    function GetFortitude(wil)
    {
        if(wil >= 80) return 33;
        if(wil >= 15) return Math.floor((wil - 13) / 2);
        return 0;
    }
    
    function GetSocialPool(chr)
    {
        if(chr <= 30) return Math.max(0, Math.floor(chr / 15));
        return Math.min(Math.floor((chr + 10) / 20), 4);
    }
    
    function GetRepBonus(chr)
    {
        if(chr >= 80) return 40;
        if(chr >= 15) return Math.floor(chr / 10) * 5;
        return 0;
    }
    
    function GetLevel(saga)
    {
        if(saga < 16) return 1;
        if(saga < 37) return 2;
        if(saga < 60) return 3;
        if(saga < 85) return 4;
        if(saga < 115) return 5;
        if(saga < 150) return 6;
        if(saga < 190) return 7;
        if(saga < 235) return 8;
        if(saga < 285) return 9;
        if(saga < 340) return 10;
        if(saga < 400) return 11;
        if(saga < 465) return 12;
        if(saga < 535) return 13;
        if(saga < 610) return 14;
        if(saga < 690) return 15;
        if(saga < 775) return 16;
        if(saga < 865) return 17;
        if(saga < 960) return 18;
        if(saga < 1060) return 19;
        if(saga < 1165) return 20;
        if(saga < 1275) return 21;
        if(saga < 1390) return 22;
        if(saga < 1510) return 23;
        if(saga < 1635) return 24;
        if(saga < 1765) return 25;
        if(saga < 1900) return 26;
        if(saga < 2040) return 27;
        if(saga < 2185) return 28;
        if(saga < 2335) return 29;
        if(saga < 2490) return 30;
        if(saga < 2650) return 31;
        if(saga < 2815) return 32;
        if(saga < 2985) return 33;
        if(saga < 3160) return 34;
        if(saga < 3340) return 35;
        if(saga < 3525) return 36;
        if(saga < 3715) return 37;
        if(saga < 3910) return 38;
        if(saga < 4105) return 39;
        if(saga < 4300) return 40;
        if(saga < 4495) return 41;
        if(saga < 4690) return 42;
        if(saga < 4890) return 43;
        if(saga < 5095) return 44;
        if(saga < 5300) return 45;
        if(saga < 5500) return 46;
        if(saga < 5700) return 47;
        if(saga < 5900) return 48;
        if(saga < 6100) return 49;
        if(saga < 6400) return 50;
        if(saga < 6700) return 51;
        if(saga < 7000) return 52;
        if(saga < 7300) return 53;
        if(saga < 7600) return 54;
        if(saga < 7900) return 55;
        if(saga < 8200) return 56;
        if(saga < 8500) return 57;
        if(saga < 8800) return 58;
        if(saga < 9100) return 59;
        if(saga < 9500) return 60;
        if(saga < 9900) return 61;
        if(saga < 10300) return 62;
        if(saga < 10700) return 63;
        if(saga < 11100) return 64;
        if(saga < 11500) return 65;
        if(saga < 11900) return 66;
        if(saga < 12300) return 67;
        if(saga < 12700) return 68;
        if(saga < 13100) return 69;
        if(saga < 13600) return 70;
        if(saga < 14100) return 71;
        if(saga < 14600) return 72;
        if(saga < 15100) return 73;
        if(saga < 15600) return 74;
        if(saga < 16100) return 75;
        if(saga < 16600) return 76;
        if(saga < 17100) return 77;
        if(saga < 17600) return 78;
        if(saga < 18100) return 79;
        if(saga < 18700) return 80;
        if(saga < 19200) return 81;
        if(saga < 19800) return 82;
        if(saga < 20400) return 83;
        if(saga < 21000) return 84;
        if(saga < 21600) return 85;
        if(saga < 22200) return 86;
        if(saga < 22800) return 87;
        if(saga < 23400) return 88;
        if(saga < 24000) return 89;
        if(saga < 24700) return 90;
        if(saga < 25400) return 91;
        if(saga < 26100) return 92;
        if(saga < 26800) return 93;
        if(saga < 27500) return 94;
        if(saga < 28200) return 95;
        if(saga < 28900) return 96;
        if(saga < 29600) return 97;
        if(saga < 30300) return 98;
        if(saga < 31000) return 99;
        return 100;
    }
    
    function GetSagaPointsForNextLevel(saga)
    {
        if(saga < 16) return 16;
        if(saga < 37) return 37;
        if(saga < 60) return 60;
        if(saga < 85) return 85;
        if(saga < 115) return 115;
        if(saga < 150) return 150;
        if(saga < 190) return 190;
        if(saga < 235) return 235;
        if(saga < 285) return 285;
        if(saga < 340) return 340;
        if(saga < 400) return 400;
        if(saga < 465) return 465;
        if(saga < 535) return 535;
        if(saga < 610) return 610;
        if(saga < 690) return 690;
        if(saga < 775) return 775;
        if(saga < 865) return 865;
        if(saga < 960) return 960;
        if(saga < 1060) return 1060;
        if(saga < 1165) return 1165;
        if(saga < 1275) return 1275;
        if(saga < 1390) return 1390;
        if(saga < 1510) return 1510;
        if(saga < 1635) return 1635;
        if(saga < 1765) return 1765;
        if(saga < 1900) return 1900;
        if(saga < 2040) return 2040;
        if(saga < 2185) return 2185;
        if(saga < 2335) return 2335;
        if(saga < 2490) return 2490;
        if(saga < 2650) return 2650;
        if(saga < 2815) return 2815;
        if(saga < 2985) return 2985;
        if(saga < 3160) return 3160;
        if(saga < 3340) return 3340;
        if(saga < 3525) return 3525;
        if(saga < 3715) return 3715;
        if(saga < 3910) return 3910;
        if(saga < 4105) return 4105;
        if(saga < 4300) return 4300;
        if(saga < 4495) return 4495;
        if(saga < 4690) return 4690;
        if(saga < 4890) return 4890;
        if(saga < 5095) return 5095;
        if(saga < 5300) return 5300;
        if(saga < 5500) return 5500;
        if(saga < 5700) return 5700;
        if(saga < 5900) return 5900;
        if(saga < 6100) return 6100;
        if(saga < 6400) return 6400;
        if(saga < 6700) return 6700;
        if(saga < 7000) return 7000;
        if(saga < 7300) return 7300;
        if(saga < 7600) return 7600;
        if(saga < 7900) return 7900;
        if(saga < 8200) return 8200;
        if(saga < 8500) return 8500;
        if(saga < 8800) return 8800;
        if(saga < 9100) return 9100;
        if(saga < 9500) return 9500;
        if(saga < 9900) return 9900;
        if(saga < 10300) return 10300;
        if(saga < 10700) return 10700;
        if(saga < 11100) return 11100;
        if(saga < 11500) return 11500;
        if(saga < 11900) return 11900;
        if(saga < 12300) return 12300;
        if(saga < 12700) return 12700;
        if(saga < 13100) return 13100;
        if(saga < 13600) return 13600;
        if(saga < 14100) return 14100;
        if(saga < 14600) return 14600;
        if(saga < 15100) return 15100;
        if(saga < 15600) return 15600;
        if(saga < 16100) return 16100;
        if(saga < 16600) return 16600;
        if(saga < 17100) return 17100;
        if(saga < 17600) return 17600;
        if(saga < 18100) return 18100;
        if(saga < 18700) return 18700;
        if(saga < 19200) return 19200;
        if(saga < 19800) return 19800;
        if(saga < 20400) return 20400;
        if(saga < 21000) return 21000;
        if(saga < 21600) return 21600;
        if(saga < 22200) return 22200;
        if(saga < 22800) return 22800;
        if(saga < 23400) return 23400;
        if(saga < 24000) return 24000;
        if(saga < 24700) return 24700;
        if(saga < 25400) return 25400;
        if(saga < 26100) return 26100;
        if(saga < 26800) return 26800;
        if(saga < 27500) return 27500;
        if(saga < 28200) return 28200;
        if(saga < 28900) return 28900;
        if(saga < 29600) return 29600;
        if(saga < 30300) return 30300;
        if(saga < 31000) return 31000;
        return '-';
    }
    
    function GetAttributeBonus(attribute, strRank, dexRank, bdyRank, prcRank, intRank, wilRank, chrRank) {
        switch (attribute) {
            case "str":
                return strRank;
            case "dex":
                return dexRank;
            case "bdy":
                return bdyRank;
            case "prc":
                return prcRank;
            case "int":
                return intRank;
            case "wil":
                return wilRank;
            case "chr":
                return chrRank;
            default:
                console.log('Invalid character attribute: ' + attribute);
                return 0;
        }
    }
    
    function GetConditionModifier(attribute, physMod, menMod) {
        switch (attribute) {
            case "str":
            case "dex":
            case "bdy":
            case "prc":
                return physMod;
            case "int":
            case "wil":
            case "chr":
                return menMod;
            default:
                console.log('Invalid character attribute: ' + attribute);
                return 0;
        }
    }
    
    function UpdateStrength()
    {
        getAttrs(["StrBase", "StrBonus", "StrRace"], function(values)
        {
            var total = Number(values.StrBase) + Number(values.StrBonus) + Number(values.StrRace);
            var rank = GetRank(total);
            setAttrs({StrTotal: total});
            setAttrs({StrRank: rank});
            setAttrs({StrDice: GetDice(rank)});
            UpdateDmgMod();
            setAttrs({WtAllow: GetWtAllow(total)});
            UpdateStrSkills();
        });
    }
    
    function UpdateDmgMod()
    {
        getAttrs(["StrTotal", "DmgModBonus"], function(values)
        {
            var dmg = GetDmgMod(values.StrTotal);
            setAttrs({DmgModBase: Number(dmg)});
            setAttrs({DmgModTotal: Number(dmg) + Number(values.DmgModBonus)});
            UpdateWeaponDmgMods();
        });
    }
    
    function UpdateDexterity()
    {
        getAttrs(["DexBase", "DexBonus", "DexRace"], function(values)
        {
            var total = Number(values.DexBase) + Number(values.DexBonus) + Number(values.DexRace);
            var rank = GetRank(total);
            setAttrs({DexTotal: Number(total)});
            setAttrs({DexRank: Number(GetRank(total))});
            setAttrs({DexDice: String(GetDice(rank))});
            UpdateDefMod();
            UpdateInitMod();
            UpdateMvmt();
            UpdateDexSkills();
        });
    }
    
    function UpdateDefMod()
    {
        getAttrs(["DexTotal", "DefModBonus"], function(values)
        {
            var def = GetDefMod(values.DexTotal);
            setAttrs({DefModBase: Number(def)});
            setAttrs({DefModTotal: Number(def) + Number(values.DefModBonus)});
        });
    }
    
    function UpdateInitMod()
    {
        getAttrs(["DexTotal", "InitModBonus"], function(values)
        {
            var init = GetDefMod(values.DexTotal);
            setAttrs({InitModBase: Number(init)});
            setAttrs({InitModTotal: Number(init) + Number(values.InitModBonus)});
        });
    }
    
    function UpdateMvmt()
    {
        getAttrs(["DexTotal", "RaceMvmt", "MvmtBonus"], function(values)
        {
            var mv = Number(values.RaceMvmt) + Number(GetMvMod(values.DexTotal)) + Number(values.MvmtBonus);
            setAttrs({Mvmt: mv});
            setAttrs({RunMvmt: Number(mv * 2)});
        });
    }
    
    function UpdateBody()
    {
        getAttrs(["BdyBase", "BdyBonus", "BdyRace", "HPAdj", "MaxHP"], function(values)
        {
            var total = Number(values.BdyBase) + Number(values.BdyBonus) + Number(values.BdyRace);
            var rank = GetRank(total);
            setAttrs({BdyTotal: Number(total)});
            setAttrs({BdyRank: Number(GetRank(total))});
            setAttrs({BdyDice: String(GetDice(rank))});
            setAttrs({BdySave: GetBodySave(total)});
            UpdateToughness();
            UpdateBdySkills();
            
            var prevHPAdj = values.HPAdj;
            var newHPAdj = GetHPAdj(total);
            setAttrs({HPAdj: Number(newHPAdj)});
            var prevMaxHP = values.MaxHP;
            setAttrs({MaxHP: Number(Number(newHPAdj) - Number(prevHPAdj) + Number(prevMaxHP))});
        });
    }
    
    function UpdateToughness()
    {
        getAttrs(["BdyTotal", "ToughBonus"], function(values)
        {
            var t = GetToughness(values.BdyTotal);
            setAttrs({ToughBase: Number(t)});
            setAttrs({ToughTotal: Number(t) + Number(values.ToughBonus)});
            UpdateAR();
        });
    }
    
    function UpdateAR()
    {
        getAttrs(["HelmetAR", "AmuletAR", "CloakAR", "PauldronsAR", "ClothingAR", "TorsoAR", "BracersAR", "GlovesAR", "BeltAR", "GreavesAR", "BootsAR", "RingAR", "Ring2AR", "OtherAR", "Other2AR", "ToughTotal"], function(values)
        {
            var x = Number(values.HelmetAR) +
            Number(values.AmuletAR) +
            Number(values.CloakAR) +
            Number(values.PauldronsAR) +
            Number(values.ClothingAR) +
            Number(values.TorsoAR) +
            Number(values.BracersAR) +
            Number(values.GlovesAR) +
            Number(values.BeltAR) +
            Number(values.GreavesAR) +
            Number(values.BootsAR) +
            Number(values.RingAR) +
            Number(values.Ring2AR) +
            Number(values.OtherAR) +
            Number(values.Other2AR) +
            Number(values.ToughTotal);
            setAttrs({TotalAR: x});
        });
    }
    
    function UpdatePerception()
    {
        getAttrs(["PrcBase", "PrcBonus", "PrcRace"], function(values)
        {
            var total = Number(values.PrcBase) + Number(values.PrcBonus) + Number(values.PrcRace);
            var rank = GetRank(total);
            setAttrs({PrcTotal: Number(total)});
            setAttrs({PrcRank: Number(GetRank(total))});
            setAttrs({PrcDice: String(GetDice(rank))});
            UpdateShotDmgMod();
            UpdateRange();
            UpdatePrcSkills();
        });
    }
    
    function UpdateShotDmgMod()
    {
        getAttrs(["PrcTotal", "ShotDmgModBonus"], function(values)
        {
            var dmg = GetShotDmg(values.PrcTotal);
            setAttrs({ShotDmgModBase: Number(dmg)});
            setAttrs({ShotDmgModTotal: Number(dmg) + Number(values.ShotDmgModBonus)});
            UpdateWeaponDmgMods();
        });
    }
    
    function UpdateRange()
    {
        getAttrs(["PrcTotal", "RgBonus"], function(values)
        {
            var rg = GetRange(values.PrcTotal);
            setAttrs({RgBase: Number(rg)});
            setAttrs({RgTotal: Number(rg) + Number(values.RgBonus)});
        });
    }
    
    function UpdateIntelligence()
    {
        getAttrs(["IntBase", "IntBonus", "IntRace"], function(values)
        {
            var total = Number(values.IntBase) + Number(values.IntBonus) + Number(values.IntRace);
            var rank = GetRank(total);
            setAttrs({IntTotal: Number(total)});
            setAttrs({IntRank: Number(GetRank(total))});
            setAttrs({IntDice: String(GetDice(rank))});
            UpdateSpellEffect();
            setAttrs({SpellTime: GetSpellTime(total)});
            setAttrs({SpText: GetSpellTimeText(total)});
            setAttrs({Langs: GetLangs(total)});
            UpdateIntSkills();
        });
    }
    
    function UpdateSpellEffect()
    {
        getAttrs(["IntTotal", "SpEffBonus"], function(values)
        {
            var se = GetSpellEffect(values.IntTotal);
            setAttrs({SpEffBase: Number(se)});
            setAttrs({SpEffTotal: Number(se) + Number(values.SpEffBonus)});
        });
    }
    
    function UpdateWillpower()
    {
        getAttrs(["WilBase", "WilBonus", "WilRace", "ManaAdj", "MaxMana"], function(values)
        {
            var total = Number(values.WilBase) + Number(values.WilBonus) + Number(values.WilRace);
            var rank = GetRank(total);
            setAttrs({WilTotal: Number(total)});
            setAttrs({WilRank: Number(GetRank(total))});
            setAttrs({WilDice: String(GetDice(rank))});
            UpdateMenDefMod();
            UpdateFortitude();
            UpdateWilSkills();
            
            var prevManaAdj = values.ManaAdj;
            var newManaAdj = GetHPAdj(total);
            setAttrs({ManaAdj: Number(newManaAdj)});
            var prevMaxMana = values.MaxMana;
            setAttrs({MaxMana: Number(Number(newManaAdj) - Number(prevManaAdj) + Number(prevMaxMana))});
        });
    }
    
    function UpdateMenDefMod()
    {
        getAttrs(["WilTotal", "MenDefBonus"], function(values)
        {
            var mdef = GetDefMod(values.WilTotal);
            setAttrs({MenDefBase: Number(mdef)});
            setAttrs({MenDefTotal: Number(mdef) + Number(values.MenDefBonus)});
        });
    }
    
    function UpdateFortitude()
    {
        getAttrs(["WilTotal", "FortBonus"], function(values)
        {
            var f = GetFortitude(values.WilTotal);
            setAttrs({FortBase: Number(f)});
            setAttrs({FortTotal: Number(f) + Number(values.FortBonus)});
        });
    }
    
    function UpdateCharisma()
    {
        getAttrs(["ChrBase", "ChrBonus", "ChrRace"], function(values)
        {
            var total = Number(values.ChrBase) + Number(values.ChrBonus) + Number(values.ChrRace);
            var rank = GetRank(total);
            setAttrs({ChrTotal: Number(total)});
            setAttrs({ChrRank: Number(GetRank(total))});
            setAttrs({ChrDice: String(GetDice(rank))});
            UpdateSocialPool();
            setAttrs({RepBonus: GetRepBonus(total)});
            UpdateChrSkills();
        });
    }
    
    function UpdateSocialPool()
    {
        getAttrs(["ChrTotal", "SocialBonus"], function(values)
        {
            var sp = GetSocialPool(values.ChrTotal);
            setAttrs({SocialBase: Number(sp)});
            setAttrs({SocialPool: Number(sp) + Number(values.SocialBonus)});
        });
    }
    
    function UpdateBeauty()
    {
        getAttrs(["BtyBase", "BtyBonus", "BtyRace"], function(values)
        {
            var total = Number(values.BtyBase) + Number(values.BtyBonus) + Number(values.BtyRace);
            setAttrs({BtyTotal: Number(total)});
        });
    }
    
    function UpdateStrSkills()
    {
        updateAllSkills();

        UpdateLifting();
    }
    
    function UpdateBdySkills()
    {
        updateAllSkills();

        UpdateDrinking();
        UpdateDrugTolerance();
        UpdateEndurance();    
    }
    
    function UpdateDexSkills()
    {
        updateAllSkills();

        UpdateAcrobatics();
        UpdateClimbing();
        UpdateDancing();
        UpdateEscapeArtistry();
        UpdateFlying();
        UpdateJuggling();
        UpdateJumping();
        UpdateLockPicking();
        UpdateRiding();
        UpdateRunning();
        UpdateStealing();
        UpdateStealth();
        UpdateSwimming();
        UpdateTeamster();
    }
    
    function UpdatePrcSkills()
    {
        updateAllSkills();

        UpdateArt();
        UpdateAstronomy();
        UpdateConcealment();
        UpdateCooking();
        UpdateDetectLies();
        UpdateDisguise();
        UpdateFishing();
        UpdateForaging();
        UpdateForgery();
        UpdateGambling();
        UpdateGemCutting();
        UpdateGlassBlowing();
        UpdateHunting();
        UpdateLipReading();
        UpdateListening();
        UpdateLooting();
        UpdateMapping();
        UpdateMusic();
        UpdateNavigation();
        UpdateObservation();
        UpdatePottery();
        UpdateSewing();
        UpdateTracking();
        UpdateTrailing();
        UpdateTraps();
        UpdateWeatherSense();
        UpdateWeaving();
    }
    
    function UpdateIntSkills()
    {
        updateAllSkills();

        UpdateAlchemy();
        UpdateAppraisal();
        UpdateArmorer();
        UpdateAstrology();
        UpdateBlacksmith();
        UpdateBowyer();
        UpdateBrewing();
        UpdateCarpentry();
        UpdateCircleMagic();
        UpdateCreatureLore();
        UpdateCrystalLore();
        UpdateDecipher();
        UpdateDemonLore();
        UpdateFarming();
        UpdateHealing();
        UpdateHeraldry();
        UpdateHistory();
        UpdateLaw();
        UpdateLeatherWorking();
        UpdateLiguistics();
        UpdateLocksmith();
        UpdateMasonry();
        UpdateMedicine();
        UpdateMining();
        UpdatePlantLore();
        UpdatePoisons();
        UpdateReadWrite();
        UpdateResearch();
        UpdateSeafaring();
        UpdateSiegeCraft();
        UpdateSkyfaring();
        UpdateSpellCraft();
        UpdateStreetSurvival();
        UpdateTeaching();
        UpdateThaumaturgy();
        UpdateTheology();
        UpdateTinker();
        UpdateWeaponsmith();
        UpdateWildSurvival();
        UpdateLangSkills();
    }
    
    function UpdateWilSkills()
    {
        updateAllSkills();

        UpdateBattleChant();
        UpdateBloodMagic();
        UpdateConjuring();
        UpdateExorcism();
        UpdateMeditation();
        UpdateNecromancy();
    }
    
    function UpdateChrSkills()
    {
        updateAllSkills();

        UpdateActing();
        UpdateAnimalKinship();
        UpdateBarter();
        UpdateBegging();
        UpdateDeception();
        UpdateImpersonation();
        UpdateInterrogation();
        UpdateLeadership();
        UpdatePhilosophy();
        UpdateSeduction();
        UpdateSinging();
        UpdateSpeech();
        UpdateStoryTelling();
        UpdateStreetwise();
    }
    
    function UpdateLevel()
    {
        getAttrs(["MaxSaga"], function(values)
        {
            setAttrs({Level: GetLevel(values.MaxSaga)});
            setAttrs({NextLevelSaga: GetSagaPointsForNextLevel(values.MaxSaga)});
        });
    }
    
    function UpdateUnarmed()
    {
        getAttrs(["Unarmed", "RaceUnarmedRank", "Race"], function(values)
        {
            setAttrs({UnarmedHit: Number(values.Unarmed)});
            var rk = Math.max(0, Number(values.Unarmed) - 2);
            setAttrs({UnarmedRank: rk});
            var rank = Number(values.RaceUnarmedRank) + Number(rk);
            setAttrs({UnarmedDmg: GetDice(rank)});
            
            setAttrs({AltUnarmedName: ""});
            setAttrs({AltUnarmedHit: Number(values.Unarmed)});
            setAttrs({AltUnarmedRank: rk});
            setAttrs({AltUnarmedDmg: GetDice(rank)});
            
            if(values.Race == "mungreel")
            {
                setAttrs({AltUnarmedName: "Blade Teeth"});
                setAttrs({AltUnarmedRank: Number(rk) + 3});
                setAttrs({AltUnarmedDmg: GetDice(Number(rank) + 3)});
            }
            if(values.Race == "mhentep")
            {
                setAttrs({AltUnarmedName: "Claws"});
                setAttrs({AltUnarmedDmg: String(GetDice(rank)) + String("+3")});
            }
        });
    }
    
    function UpdateAcrobatics()
    {
        getAttrs(["DexRank", "AcrobatRating", "AcrobatBonus"], function(values)
        {
            var total = "-";
            if(Number(values.AcrobatRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.AcrobatRating) + Number(values.AcrobatBonus);
            }
            setAttrs({AcrobatTotal: total});
            setAttrs({AcrobatDice: GetDice(total)});
        });
    }
    
    function UpdateActing()
    {
        getAttrs(["ChrRank", "ActRating", "ActBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ActRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.ActRating) + Number(values.ActBonus);
            }
            setAttrs({ActTotal: total});
            setAttrs({ActDice: GetDice(total)});
        });
    }
    
    function UpdateAlchemy()
    {
        getAttrs(["IntRank", "AlchRating", "AlchBonus"], function(values)
        {
            var total = "-";
            if(Number(values.AlchRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.AlchRating) + Number(values.AlchBonus);
            }
            setAttrs({AlchTotal: total});
            setAttrs({AlchDice: GetDice(total)});
        });
    }
    
    function UpdateAnimalKinship()
    {
        getAttrs(["ChrRank", "AnimalRating", "AnimalBonus"], function(values)
        {
            var total = "-";
            if(Number(values.AnimalRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.AnimalRating) + Number(values.AnimalBonus);
            }
            setAttrs({AnimalTotal: total});
            setAttrs({AnimalDice: GetDice(total)});
        });
    }
    
    function UpdateAppraisal()
    {
        getAttrs(["IntRank", "AppraisalRating", "AppraisalBonus"], function(values)
        {
            var total = "-";
            if(Number(values.AppraisalRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.AppraisalRating) + Number(values.AppraisalBonus);
            }
            setAttrs({AppraisalTotal: total});
            setAttrs({AppraisalDice: GetDice(total)});
        });
    }
    
    function UpdateArmorer()
    {
        getAttrs(["IntRank", "ArmorerRating", "ArmorerBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ArmorerRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.ArmorerRating) + Number(values.ArmorerBonus);
            }
            setAttrs({ArmorerTotal: total});
            setAttrs({ArmorerDice: GetDice(total)});
        });
    }
    
    function UpdateArt()
    {
        getAttrs(["PrcRank", "ArtRating", "ArtBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ArtRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.ArtRating) + Number(values.ArtBonus);
            }
            setAttrs({ArtTotal: total});
            setAttrs({ArtDice: GetDice(total)});
        });
    }
    
    function UpdateAstrology()
    {
        getAttrs(["IntRank", "AstroRating", "AstroBonus"], function(values)
        {
            var total = "-";
            if(Number(values.AstroRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.AstroRating) + Number(values.AstroBonus);
            }
            setAttrs({AstroTotal: total});
            setAttrs({AstroDice: GetDice(total)});
        });
    }
    
    function UpdateAstronomy()
    {
        getAttrs(["PrcRank", "AstronomyRating", "AstronomyBonus"], function(values)
        {
            var total = "-";
            if(Number(values.AstronomyRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.AstronomyRating) + Number(values.AstronomyBonus);
            }
            setAttrs({AstronomyTotal: total});
            setAttrs({AstronomyDice: GetDice(total)});
        });
    }
    
    function UpdateBarter()
    {
        getAttrs(["ChrRank", "BarterRating", "BarterBonus"], function(values)
        {
            var total = "-";
            if(Number(values.BarterRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.BarterRating) + Number(values.BarterBonus);
            }
            setAttrs({BarterTotal: total});
            setAttrs({BarterDice: GetDice(total)});
        });
    }
    
    function UpdateBattleChant()
    {
        getAttrs(["WilRank", "ChantRating", "ChantBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ChantRating) > 0)
            {
                total = Number(values.WilRank) + Number(values.ChantRating) + Number(values.ChantBonus);
            }
            setAttrs({ChantTotal: total});
            setAttrs({ChantDice: GetDice(total)});
        });
    }
    
    function UpdateBegging()
    {
        getAttrs(["ChrRank", "BegRating", "BegBonus"], function(values)
        {
            var total = "-";
            if(Number(values.BegRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.BegRating) + Number(values.BegBonus);
            }
            setAttrs({BegTotal: total});
            setAttrs({BegDice: GetDice(total)});
        });
    }
    
    function UpdateBlacksmith()
    {
        getAttrs(["IntRank", "BlackRating", "BlackBonus"], function(values)
        {
            var total = "-";
            if(Number(values.BlackRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.BlackRating) + Number(values.BlackBonus);
            }
            setAttrs({BlackTotal: total});
            setAttrs({BlackDice: GetDice(total)});
        });
    }
    
    function UpdateBloodMagic()
    {
        getAttrs(["WilRank", "BloodRating", "BloodBonus"], function(values)
        {
            var total = "-";
            if(Number(values.BloodRating) > 0)
            {
                total = Number(values.WilRank) + Number(values.BloodRating) + Number(values.BloodBonus);
            }
            setAttrs({BloodTotal: total});
            setAttrs({BloodDice: GetDice(total)});
        });
    }
    
    function UpdateBowyer()
    {
        getAttrs(["IntRank", "BowyerRating", "BowyerBonus"], function(values)
        {
            var total = "-";
            if(Number(values.BowyerRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.BowyerRating) + Number(values.BowyerBonus);
            }
            setAttrs({BowyerTotal: total});
            setAttrs({BowyerDice: GetDice(total)});
        });
    }
    
    function UpdateBrewing()
    {
        getAttrs(["IntRank", "BrewRating", "BrewBonus"], function(values)
        {
            var total = "-";
            if(Number(values.BrewRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.BrewRating) + Number(values.BrewBonus);
            }
            setAttrs({BrewTotal: total});
            setAttrs({BrewDice: GetDice(total)});
        });
    }
    
    function UpdateCarpentry()
    {
        getAttrs(["IntRank", "CarpRating", "CarpBonus"], function(values)
        {
            var total = "-";
            if(Number(values.CarpRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.CarpRating) + Number(values.CarpBonus);
            }
            setAttrs({CarpTotal: total});
            setAttrs({CarpDice: GetDice(total)});
        });
    }
    
    function UpdateCircleMagic()
    {
        getAttrs(["IntRank", "CircleRating", "CircleBonus"], function(values)
        {
            var total = "-";
            if(Number(values.CircleRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.CircleRating) + Number(values.CircleBonus);
            }
            setAttrs({CircleTotal: total});
            setAttrs({CircleDice: GetDice(total)});
        });
    }
    
    function UpdateClimbing()
    {
        getAttrs(["DexRank", "ClimbRating", "ClimbBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ClimbRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.ClimbRating) + Number(values.ClimbBonus);
            }
            setAttrs({ClimbTotal: total});
            setAttrs({ClimbDice: GetDice(total)});
        });
    }
    
    function UpdateConcealment()
    {
        getAttrs(["PrcRank", "ConcRating", "ConcBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ConcRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.ConcRating) + Number(values.ConcBonus);
            }
            setAttrs({ConcTotal: total});
            setAttrs({ConcDice: GetDice(total)});
        });
    }
    
    function UpdateConjuring()
    {
        getAttrs(["WilRank", "ConjRating", "ConjBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ConjRating) > 0)
            {
                total = Number(values.WilRank) + Number(values.ConjRating) + Number(values.ConjBonus);
            }
            setAttrs({ConjTotal: total});
            setAttrs({ConjDice: GetDice(total)});
        });
    }
    
    function UpdateCooking()
    {
        getAttrs(["PrcRank", "CookRating", "CookBonus"], function(values)
        {
            var total = "-";
            if(Number(values.CookRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.CookRating) + Number(values.CookBonus);
            }
            setAttrs({CookTotal: total});
            setAttrs({CookDice: GetDice(total)});
        });
    }
    
    function UpdateCreatureLore()
    {
        getAttrs(["IntRank", "CreatureRating", "CreatureBonus"], function(values)
        {
            var total = "-";
            if(Number(values.CreatureRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.CreatureRating) + Number(values.CreatureBonus);
            }
            setAttrs({CreatureTotal: total});
            setAttrs({CreatureDice: GetDice(total)});
        });
    }
    
    function UpdateCrystalLore()
    {
        getAttrs(["IntRank", "CrystalRating", "CrystalBonus"], function(values)
        {
            var total = "-";
            if(Number(values.CrystalRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.CrystalRating) + Number(values.CrystalBonus);
            }
            setAttrs({CrystalTotal: total});
            setAttrs({CrystalDice: GetDice(total)});
        });
    }
    
    function UpdateDancing()
    {
        getAttrs(["DexRank", "DanceRating", "DanceBonus"], function(values)
        {
            var total = "-";
            if(Number(values.DanceRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.DanceRating) + Number(values.DanceBonus);
            }
            setAttrs({DanceTotal: total});
            setAttrs({DanceDice: GetDice(total)});
        });
    }
    
    function UpdateDeception()
    {
        getAttrs(["ChrRank", "DeceptRating", "DeceptBonus"], function(values)
        {
            var total = "-";
            if(Number(values.DeceptRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.DeceptRating) + Number(values.DeceptBonus);
            }
            setAttrs({DeceptTotal: total});
            setAttrs({DeceptDice: GetDice(total)});
        });
    }
    
    function UpdateDecipher()
    {
        getAttrs(["IntRank", "DecipherRating", "DecipherBonus"], function(values)
        {
            var total = "-";
            if(Number(values.DecipherRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.DecipherRating) + Number(values.DecipherBonus);
            }
            setAttrs({DecipherTotal: total});
            setAttrs({DecipherDice: GetDice(total)});
        });
    }
    
    function UpdateDemonLore()
    {
        getAttrs(["IntRank", "DemonRating", "DemonBonus"], function(values)
        {
            var total = "-";
            if(Number(values.DemonRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.DemonRating) + Number(values.DemonBonus);
            }
            setAttrs({DemonTotal: total});
            setAttrs({DemonDice: GetDice(total)});
        });
    }
    
    function UpdateDetectLies()
    {
        getAttrs(["PrcRank", "LiesRating", "LiesBonus"], function(values)
        {
            var total = "-";
            if(Number(values.LiesRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.LiesRating) + Number(values.LiesBonus);
            }
            setAttrs({LiesTotal: total});
            setAttrs({LiesDice: GetDice(total)});
        });
    }
    
    function UpdateDisguise()
    {
        getAttrs(["PrcRank", "DisgRating", "DisgBonus"], function(values)
        {
            var total = "-";
            if(Number(values.DisgRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.DisgRating) + Number(values.DisgBonus);
            }
            setAttrs({DisgTotal: total});
            setAttrs({DisgDice: GetDice(total)});
        });
    }
    
    function UpdateDrinking()
    {
        getAttrs(["BdyRank", "DrinkRating", "DrinkBonus"], function(values)
        {
            var total = "-";
            if(Number(values.DrinkRating) > 0)
            {
                total = Number(values.BdyRank) + Number(values.DrinkRating) + Number(values.DrinkBonus);
            }
            setAttrs({DrinkTotal: total});
            setAttrs({DrinkDice: GetDice(total)});
        });
    }
    
    function UpdateDrugTolerance()
    {
        getAttrs(["BdyRank", "DrugRating", "DrugBonus"], function(values)
        {
            var total = "-";
            if(Number(values.DrugRating) > 0)
            {
                total = Number(values.BdyRank) + Number(values.DrugRating) + Number(values.DrugBonus);
            }
            setAttrs({DrugTotal: total});
            setAttrs({DrugDice: GetDice(total)});
        });
    }
    
    function UpdateEndurance()
    {
        getAttrs(["BdyRank", "EndurRating", "EndurBonus"], function(values)
        {
            var total = "-";
            if(Number(values.EndurRating) > 0)
            {
                total = Number(values.BdyRank) + Number(values.EndurRating) + Number(values.EndurBonus);
            }
            setAttrs({EndurTotal: total});
            setAttrs({EndurDice: GetDice(total)});
        });
    }
    
    function UpdateEscapeArtistry()
    {
        getAttrs(["DexRank", "EscapeRating", "EscapeBonus"], function(values)
        {
            var total = "-";
            if(Number(values.EscapeRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.EscapeRating) + Number(values.EscapeBonus);
            }
            setAttrs({EscapeTotal: total});
            setAttrs({EscapeDice: GetDice(total)});
        });
    }
    
    function UpdateExorcism()
    {
        getAttrs(["WilRank", "ExorcismRating", "ExorcismBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ExorcismRating) > 0)
            {
                total = Number(values.WilRank) + Number(values.ExorcismRating) + Number(values.ExorcismBonus);
            }
            setAttrs({ExorcismTotal: total});
            setAttrs({ExorcismDice: GetDice(total)});
        });
    }
    
    function UpdateFarming()
    {
        getAttrs(["IntRank", "FarmRating", "FarmBonus"], function(values)
        {
            var total = "-";
            if(Number(values.FarmRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.FarmRating) + Number(values.FarmBonus);
            }
            setAttrs({FarmTotal: total});
            setAttrs({FarmDice: GetDice(total)});
        });
    }
    
    function UpdateFishing()
    {
        getAttrs(["PrcRank", "FishRating", "FishBonus"], function(values)
        {
            var total = "-";
            if(Number(values.FishRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.FishRating) + Number(values.FishBonus);
            }
            setAttrs({FishTotal: total});
            setAttrs({FishDice: GetDice(total)});
        });
    }
    
    function UpdateForaging()
    {
        getAttrs(["PrcRank", "ForageRating", "ForageBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ForageRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.ForageRating) + Number(values.ForageBonus);
            }
            setAttrs({ForageTotal: total});
            setAttrs({ForageDice: GetDice(total)});
        });
    }
    
    function UpdateForgery()
    {
        getAttrs(["PrcRank", "ForgeryRating", "ForgeryBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ForgeryRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.ForgeryRating) + Number(values.ForgeryBonus);
            }
            setAttrs({ForgeryTotal: total});
            setAttrs({ForgeryDice: GetDice(total)});
        });
    }
    
    function UpdateFlying()
    {
        getAttrs(["DexRank", "FlyRating", "FlyBonus"], function(values)
        {
            var total = "-";
            if(Number(values.FlyRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.FlyRating) + Number(values.FlyBonus);
            }
            setAttrs({FlyTotal: total});
            setAttrs({FlyDice: GetDice(total)});
        });
    }
    
    function UpdateGambling()
    {
        getAttrs(["PrcRank", "GambleRating", "GambleBonus"], function(values)
        {
            var total = "-";
            if(Number(values.GambleRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.GambleRating) + Number(values.GambleBonus);
            }
            setAttrs({GambleTotal: total});
            setAttrs({GambleDice: GetDice(total)});
        });
    }
    
    function UpdateGemCutting()
    {
        getAttrs(["PrcRank", "GemRating", "GemBonus"], function(values)
        {
            var total = "-";
            if(Number(values.GemRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.GemRating) + Number(values.GemBonus);
            }
            setAttrs({GemTotal: total});
            setAttrs({GemDice: GetDice(total)});
        });
    }
    
    function UpdateGlassBlowing()
    {
        getAttrs(["PrcRank", "GlassRating", "GlassBonus"], function(values)
        {
            var total = "-";
            if(Number(values.GlassRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.GlassRating) + Number(values.GlassBonus);
            }
            setAttrs({GlassTotal: total});
            setAttrs({GlassDice: GetDice(total)});
        });
    }
    
    function UpdateHealing()
    {
        getAttrs(["IntRank", "HealRating", "HealBonus"], function(values)
        {
            var total = "-";
            if(Number(values.HealRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.HealRating) + Number(values.HealBonus);
            }
            setAttrs({HealTotal: total});
            setAttrs({HealDice: GetDice(total)});
        });
    }
    
    function UpdateHeraldry()
    {
        getAttrs(["IntRank", "HeraldRating", "HeraldBonus"], function(values)
        {
            var total = "-";
            if(Number(values.HeraldRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.HeraldRating) + Number(values.HeraldBonus);
            }
            setAttrs({HeraldTotal: total});
            setAttrs({HeraldDice: GetDice(total)});
        });
    }
    
    function UpdateHistory()
    {
        getAttrs(["IntRank", "HistoryRating", "HistoryBonus"], function(values)
        {
            var total = "-";
            if(Number(values.HistoryRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.HistoryRating) + Number(values.HistoryBonus);
            }
            setAttrs({HistoryTotal: total});
            setAttrs({HistoryDice: GetDice(total)});
        });
    }
    
    function UpdateHunting()
    {
        getAttrs(["PrcRank", "HuntRating", "HuntBonus"], function(values)
        {
            var total = "-";
            if(Number(values.HuntRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.HuntRating) + Number(values.HuntBonus);
            }
            setAttrs({HuntTotal: total});
            setAttrs({HuntDice: GetDice(total)});
        });
    }
    
    function UpdateImpersonation()
    {
        getAttrs(["ChrRank", "ImpersonRating", "ImpersonBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ImpersonRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.ImpersonRating) + Number(values.ImpersonBonus);
            }
            setAttrs({ImpersonTotal: total});
            setAttrs({ImpersonDice: GetDice(total)});
        });
    }
    
    function UpdateInterrogation()
    {
        getAttrs(["ChrRank", "IntrgRating", "IntrgBonus"], function(values)
        {
            var total = "-";
            if(Number(values.IntrgRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.IntrgRating) + Number(values.IntrgBonus);
            }
            setAttrs({IntrgTotal: total});
            setAttrs({IntrgDice: GetDice(total)});
        });
    }
    
    function UpdateJuggling()
    {
        getAttrs(["DexRank", "JuggleRating", "JuggleBonus"], function(values)
        {
            var total = "-";
            if(Number(values.JuggleRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.JuggleRating) + Number(values.JuggleBonus);
            }
            setAttrs({JuggleTotal: total});
            setAttrs({JuggleDice: GetDice(total)});
        });
    }
    
    function UpdateJumping()
    {
        getAttrs(["DexRank", "JumpRating", "JumpBonus"], function(values)
        {
            var total = "-";
            if(Number(values.JumpRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.JumpRating) + Number(values.JumpBonus);
            }
            setAttrs({JumpTotal: total});
            setAttrs({JumpDice: GetDice(total)});
        });
    }
    
    function UpdateLaw()
    {
        getAttrs(["IntRank", "LawRating", "LawBonus"], function(values)
        {
            var total = "-";
            if(Number(values.LawRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.LawRating) + Number(values.LawBonus);
            }
            setAttrs({LawTotal: total});
            setAttrs({LawDice: GetDice(total)});
        });
    }
    
    function UpdateLeadership()
    {
        getAttrs(["ChrRank", "LeadRating", "LeadBonus"], function(values)
        {
            var total = "-";
            if(Number(values.LeadRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.LeadRating) + Number(values.LeadBonus);
            }
            setAttrs({LeadTotal: total});
            setAttrs({LeadDice: GetDice(total)});
        });
    }
    
    function UpdateLeatherWorking()
    {
        getAttrs(["IntRank", "LWorkRating", "LWorkBonus"], function(values)
        {
            var total = "-";
            if(Number(values.LWorkRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.LWorkRating) + Number(values.LWorkBonus);
            }
            setAttrs({LWorkTotal: total});
            setAttrs({LWorkDice: GetDice(total)});
        });
    }
    
    function UpdateLifting()
    {
        getAttrs(["StrRank", "LiftRating", "LiftBonus"], function(values)
        {
            var total = "-";
            if(Number(values.LiftRating) > 0)
            {
                total = Number(values.StrRank) + Number(values.LiftRating) + Number(values.LiftBonus);
            }
            setAttrs({LiftTotal: total});
            setAttrs({LiftDice: GetDice(total)});
        });
    }
    
    function UpdateLiguistics()
    {
        getAttrs(["IntRank", "LingRating", "LingBonus"], function(values)
        {
            var total = "-";
            if(Number(values.LingRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.LingRating) + Number(values.LingBonus);
            }
            setAttrs({LingTotal: total});
            setAttrs({LingDice: GetDice(total)});
        });
    }
    
    function UpdateLipReading()
    {
        getAttrs(["PrcRank", "LipRating", "LipBonus"], function(values)
        {
            var total = "-";
            if(Number(values.LipRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.LipRating) + Number(values.LipBonus);
            }
            setAttrs({LipTotal: total});
            setAttrs({LipDice: GetDice(total)});
        });
    }
    
    function UpdateListening()
    {
        getAttrs(["PrcRank", "ListenRating", "ListenBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ListenRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.ListenRating) + Number(values.ListenBonus);
            }
            setAttrs({ListenTotal: total});
            setAttrs({ListenDice: GetDice(total)});
        });
    }
    
    function UpdateLockPicking()
    {
        getAttrs(["DexRank", "LockRating", "LockBonus"], function(values)
        {
            var total = "-";
            if(Number(values.LockRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.LockRating) + Number(values.LockBonus);
            }
            setAttrs({LockTotal: total});
            setAttrs({LockDice: GetDice(total)});
        });
    }
    
    function UpdateLocksmith()
    {
        getAttrs(["IntRank", "LocksmithRating", "LocksmithBonus"], function(values)
        {
            var total = "-";
            if(Number(values.LocksmithRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.LocksmithRating) + Number(values.LocksmithBonus);
            }
            setAttrs({LocksmithTotal: total});
            setAttrs({LocksmithDice: GetDice(total)});
        });
    }
    
    function UpdateLooting()
    {
        getAttrs(["PrcRank", "LootRating", "LootBonus"], function(values)
        {
            var total = "-";
            if(Number(values.LootRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.LootRating) + Number(values.LootBonus);
            }
            setAttrs({LootTotal: total});
            setAttrs({LootDice: GetDice(total)});
        });
    }
    
    function UpdateMapping()
    {
        getAttrs(["PrcRank", "MapRating", "MapBonus"], function(values)
        {
            var total = "-";
            if(Number(values.MapRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.MapRating) + Number(values.MapBonus);
            }
            setAttrs({MapTotal: total});
            setAttrs({MapDice: GetDice(total)});
        });
    }
    
    function UpdateMasonry()
    {
        getAttrs(["IntRank", "MasonRating", "MasonBonus"], function(values)
        {
            var total = "-";
            if(Number(values.MasonRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.MasonRating) + Number(values.MasonBonus);
            }
            setAttrs({MasonTotal: total});
            setAttrs({MasonDice: GetDice(total)});
        });
    }
    
    function UpdateMedicine()
    {
        getAttrs(["IntRank", "MedicRating", "MedicBonus"], function(values)
        {
            var total = "-";
            if(Number(values.MedicRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.MedicRating) + Number(values.MedicBonus);
            }
            setAttrs({MedicTotal: total});
            setAttrs({MedicDice: GetDice(total)});
        });
    }
    
    function UpdateMeditation()
    {
        getAttrs(["WilRank", "MeditationRating", "MeditationBonus"], function(values)
        {
            var total = "-";
            if(Number(values.MeditationRating) > 0)
            {
                total = Number(values.WilRank) + Number(values.MeditationRating) + Number(values.MeditationBonus);
            }
            setAttrs({MeditationTotal: total});
            setAttrs({MeditationDice: GetDice(total)});
        });
    }
    
    function UpdateMining()
    {
        getAttrs(["IntRank", "MiningRating", "MiningBonus"], function(values)
        {
            var total = "-";
            if(Number(values.MiningRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.MiningRating) + Number(values.MiningBonus);
            }
            setAttrs({MiningTotal: total});
            setAttrs({MiningDice: GetDice(total)});
        });
    }
    
    function UpdateMusic()
    {
        getAttrs(["PrcRank", "MusicRating", "MusicBonus"], function(values)
        {
            var total = "-";
            if(Number(values.MusicRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.MusicRating) + Number(values.MusicBonus);
            }
            setAttrs({MusicTotal: total});
            setAttrs({MusicDice: GetDice(total)});
        });
    }
    
    function UpdateNavigation()
    {
        getAttrs(["PrcRank", "NavRating", "NavBonus"], function(values)
        {
            var total = "-";
            if(Number(values.NavRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.NavRating) + Number(values.NavBonus);
            }
            setAttrs({NavTotal: total});
            setAttrs({NavDice: GetDice(total)});
        });
    }
    
    function UpdateNecromancy()
    {
        getAttrs(["WilRank", "NecroRating", "NecroBonus"], function(values)
        {
            var total = "-";
            if(Number(values.NecroRating) > 0)
            {
                total = Number(values.WilRank) + Number(values.NecroRating) + Number(values.NecroBonus);
            }
            setAttrs({NecroTotal: total});
            setAttrs({NecroDice: GetDice(total)});
        });
    }
    
    function UpdateObservation()
    {
        getAttrs(["PrcRank", "ObservRating", "ObservBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ObservRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.ObservRating) + Number(values.ObservBonus);
            }
            setAttrs({ObservTotal: total});
            setAttrs({ObservDice: GetDice(total)});
        });
    }
    
    function UpdatePhilosophy()
    {
        getAttrs(["ChrRank", "PhilRating", "PhilBonus"], function(values)
        {
            var total = "-";
            if(Number(values.PhilRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.PhilRating) + Number(values.PhilBonus);
            }
            setAttrs({PhilTotal: total});
            setAttrs({PhilDice: GetDice(total)});
        });
    }
    
    function UpdatePlantLore()
    {
        getAttrs(["IntRank", "PlantRating", "PlantBonus"], function(values)
        {
            var total = "-";
            if(Number(values.PlantRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.PlantRating) + Number(values.PlantBonus);
            }
            setAttrs({PlantTotal: total});
            setAttrs({PlantDice: GetDice(total)});
        });
    }
    
    function UpdatePoisons()
    {
        getAttrs(["IntRank", "PoisRating", "PoisBonus"], function(values)
        {
            var total = "-";
            if(Number(values.PoisRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.PoisRating) + Number(values.PoisBonus);
            }
            setAttrs({PoisTotal: total});
            setAttrs({PoisDice: GetDice(total)});
        });
    }
    
    function UpdatePottery()
    {
        getAttrs(["PrcRank", "PotteryRating", "PotteryBonus"], function(values)
        {
            var total = "-";
            if(Number(values.PotteryRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.PotteryRating) + Number(values.PotteryBonus);
            }
            setAttrs({PotteryTotal: total});
            setAttrs({PotteryDice: GetDice(total)});
        });
    }
    
    function UpdateReadWrite()
    {
        getAttrs(["IntRank", "ReadRating", "ReadBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ReadRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.ReadRating) + Number(values.ReadBonus);
            }
            setAttrs({ReadTotal: total});
            setAttrs({ReadDice: GetDice(total)});
        });
    }
    
    function UpdateResearch()
    {
        getAttrs(["IntRank", "ResearchRating", "ResearchBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ResearchRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.ResearchRating) + Number(values.ResearchBonus);
            }
            setAttrs({ResearchTotal: total});
            setAttrs({ResearchDice: GetDice(total)});
        });
    }
    
    function UpdateRiding()
    {
        getAttrs(["DexRank", "RidingRating", "RidingBonus"], function(values)
        {
            var total = "-";
            if(Number(values.RidingRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.RidingRating) + Number(values.RidingBonus);
            }
            setAttrs({RidingTotal: total});
            setAttrs({RidingDice: GetDice(total)});
        });
    }
    
    function UpdateRunning()
    {
        getAttrs(["DexRank", "RunRating", "RunBonus"], function(values)
        {
            var total = "-";
            if(Number(values.RunRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.RunRating) + Number(values.RunBonus);
            }
            setAttrs({RunTotal: total});
            setAttrs({RunDice: GetDice(total)});
        });
    }
    
    function UpdateSeafaring()
    {
        getAttrs(["IntRank", "SeaRating", "SeaBonus"], function(values)
        {
            var total = "-";
            if(Number(values.SeaRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.SeaRating) + Number(values.SeaBonus);
            }
            setAttrs({SeaTotal: total});
            setAttrs({SeaDice: GetDice(total)});
        });
    }
    
    function UpdateSeduction()
    {
        getAttrs(["ChrRank", "SeducRating", "SeducBonus"], function(values)
        {
            var total = "-";
            if(Number(values.SeducRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.SeducRating) + Number(values.SeducBonus);
            }
            setAttrs({SeducTotal: total});
            setAttrs({SeducDice: GetDice(total)});
        });
    }
    
    function UpdateSewing()
    {
        getAttrs(["PrcRank", "SewRating", "SewBonus"], function(values)
        {
            var total = "-";
            if(Number(values.SewRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.SewRating) + Number(values.SewBonus);
            }
            setAttrs({SewTotal: total});
            setAttrs({SewDice: GetDice(total)});
        });
    }
    
    function UpdateSiegeCraft()
    {
        getAttrs(["IntRank", "SiegeRating", "SiegeBonus"], function(values)
        {
            var total = "-";
            if(Number(values.SiegeRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.SiegeRating) + Number(values.SiegeBonus);
            }
            setAttrs({SiegeTotal: total});
            setAttrs({SiegeDice: GetDice(total)});
        });
    }
    
    function UpdateSinging()
    {
        getAttrs(["ChrRank", "SingRating", "SingBonus"], function(values)
        {
            var total = "-";
            if(Number(values.SingRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.SingRating) + Number(values.SingBonus);
            }
            setAttrs({SingTotal: total});
            setAttrs({SingDice: GetDice(total)});
        });
    }
    
    function UpdateSkyfaring()
    {
        getAttrs(["IntRank", "SkyRating", "SkyBonus"], function(values)
        {
            var total = "-";
            if(Number(values.SkyRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.SkyRating) + Number(values.SkyBonus);
            }
            setAttrs({SkyTotal: total});
            setAttrs({SkyDice: GetDice(total)});
        });
    }
    
    function UpdateSpeech()
    {
        getAttrs(["ChrRank", "SpeechRating", "SpeechBonus"], function(values)
        {
            var total = "-";
            if(Number(values.SpeechRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.SpeechRating) + Number(values.SpeechBonus);
            }
            setAttrs({SpeechTotal: total});
            setAttrs({SpeechDice: GetDice(total)});
        });
    }
    
    function UpdateSpellCraft()
    {
        getAttrs(["IntRank", "SpCraftRating", "SpCraftBonus"], function(values)
        {
            var total = "-";
            if(Number(values.SpCraftRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.SpCraftRating) + Number(values.SpCraftBonus);
            }
            setAttrs({SpCraftTotal: total});
            setAttrs({SpCraftDice: GetDice(total)});
        });
    }
    
    function UpdateStealing()
    {
        getAttrs(["DexRank", "StealRating", "StealBonus"], function(values)
        {
            var total = "-";
            if(Number(values.StealRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.StealRating) + Number(values.StealBonus);
            }
            setAttrs({StealTotal: total});
            setAttrs({StealDice: GetDice(total)});
        });
    }
    
    function UpdateStealth()
    {
        getAttrs(["DexRank", "StealthRating", "StealthBonus"], function(values)
        {
            var total = "-";
            if(Number(values.StealthRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.StealthRating) + Number(values.StealthBonus);
            }
            setAttrs({StealthTotal: total});
            setAttrs({StealthDice: GetDice(total)});
        });
    }
    
    function UpdateStoryTelling()
    {
        getAttrs(["ChrRank", "StoryRating", "StoryBonus"], function(values)
        {
            var total = "-";
            if(Number(values.StoryRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.StoryRating) + Number(values.StoryBonus);
            }
            setAttrs({StoryTotal: total});
            setAttrs({StoryDice: GetDice(total)});
        });
    }
    
    function UpdateStreetSurvival()
    {
        getAttrs(["IntRank", "StSurvRating", "StSurvBonus"], function(values)
        {
            var total = "-";
            if(Number(values.StSurvRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.StSurvRating) + Number(values.StSurvBonus);
            }
            setAttrs({StSurvTotal: total});
            setAttrs({StSurvDice: GetDice(total)});
        });
    }
    
    function UpdateStreetwise()
    {
        getAttrs(["ChrRank", "StreetRating", "StreetBonus"], function(values)
        {
            var total = "-";
            if(Number(values.StreetRating) > 0)
            {
                total = Number(values.ChrRank) + Number(values.StreetRating) + Number(values.StreetBonus);
            }
            setAttrs({StreetTotal: total});
            setAttrs({StreetDice: GetDice(total)});
        });
    }
    
    function UpdateSwimming()
    {
        getAttrs(["DexRank", "SwimRating", "SwimBonus"], function(values)
        {
            var total = "-";
            if(Number(values.SwimRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.SwimRating) + Number(values.SwimBonus);
            }
            setAttrs({SwimTotal: total});
            setAttrs({SwimDice: GetDice(total)});
        });
    }
    
    function UpdateTeaching()
    {
        getAttrs(["IntRank", "TeachRating", "TeachBonus"], function(values)
        {
            var total = "-";
            if(Number(values.TeachRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.TeachRating) + Number(values.TeachBonus);
            }
            setAttrs({TeachTotal: total});
            setAttrs({TeachDice: GetDice(total)});
        });
    }
    
    function UpdateTeamster()
    {
        getAttrs(["DexRank", "TeamRating", "TeamBonus"], function(values)
        {
            var total = "-";
            if(Number(values.TeamRating) > 0)
            {
                total = Number(values.DexRank) + Number(values.TeamRating) + Number(values.TeamBonus);
            }
            setAttrs({TeamTotal: total});
            setAttrs({TeamDice: GetDice(total)});
        });
    }
    
    function UpdateThaumaturgy()
    {
        getAttrs(["IntRank", "ThaumRating", "ThaumBonus"], function(values)
        {
            var total = "-";
            if(Number(values.ThaumRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.ThaumRating) + Number(values.ThaumBonus);
            }
            setAttrs({ThaumTotal: total});
            setAttrs({ThaumDice: GetDice(total)});
        });
    }
    
    function UpdateTheology()
    {
        getAttrs(["IntRank", "TheoRating", "TheoBonus"], function(values)
        {
            var total = "-";
            if(Number(values.TheoRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.TheoRating) + Number(values.TheoBonus);
            }
            setAttrs({TheoTotal: total});
            setAttrs({TheoDice: GetDice(total)});
        });
    }
    
    function UpdateTinker()
    {
        getAttrs(["IntRank", "TinkerRating", "TinkerBonus"], function(values)
        {
            var total = "-";
            if(Number(values.TinkerRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.TinkerRating) + Number(values.TinkerBonus);
            }
            setAttrs({TinkerTotal: total});
            setAttrs({TinkerDice: GetDice(total)});
        });
    }
    
    function UpdateTracking()
    {
        getAttrs(["PrcRank", "TrackRating", "TrackBonus"], function(values)
        {
            var total = "-";
            if(Number(values.TrackRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.TrackRating) + Number(values.TrackBonus);
            }
            setAttrs({TrackTotal: total});
            setAttrs({TrackDice: GetDice(total)});
        });
    }
    
    function UpdateTrailing()
    {
        getAttrs(["PrcRank", "TrailRating", "TrailBonus"], function(values)
        {
            var total = "-";
            if(Number(values.TrailRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.TrailRating) + Number(values.TrailBonus);
            }
            setAttrs({TrailTotal: total});
            setAttrs({TrailDice: GetDice(total)});
        });
    }
    
    function UpdateTraps()
    {
        getAttrs(["PrcRank", "TrapRating", "TrapBonus"], function(values)
        {
            var total = "-";
            if(Number(values.TrapRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.TrapRating) + Number(values.TrapBonus);
            }
            setAttrs({TrapTotal: total});
            setAttrs({TrapDice: GetDice(total)});
        });
    }
    
    function UpdateWeaponsmith()
    {
        getAttrs(["IntRank", "WpnSmRating", "WpnSmBonus"], function(values)
        {
            var total = "-";
            if(Number(values.WpnSmRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.WpnSmRating) + Number(values.WpnSmBonus);
            }
            setAttrs({WpnSmTotal: total});
            setAttrs({WpnSmDice: GetDice(total)});
        });
    }
    
    function UpdateWeatherSense()
    {
        getAttrs(["PrcRank", "WeatherRating", "WeatherBonus"], function(values)
        {
            var total = "-";
            if(Number(values.WeatherRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.WeatherRating) + Number(values.WeatherBonus);
            }
            setAttrs({WeatherTotal: total});
            setAttrs({WeatherDice: GetDice(total)});
        });
    }
    
    function UpdateWeaving()
    {
        getAttrs(["PrcRank", "WeaveRating", "WeaveBonus"], function(values)
        {
            var total = "-";
            if(Number(values.WeaveRating) > 0)
            {
                total = Number(values.PrcRank) + Number(values.WeaveRating) + Number(values.WeaveBonus);
            }
            setAttrs({WeaveTotal: total});
            setAttrs({WeaveDice: GetDice(total)});
        });
    }
    
    function UpdateWildSurvival()
    {
        getAttrs(["IntRank", "WildRating", "WildBonus"], function(values)
        {
            var total = "-";
            if(Number(values.WildRating) > 0)
            {
                total = Number(values.IntRank) + Number(values.WildRating) + Number(values.WildBonus);
            }
            setAttrs({WildTotal: total});
            setAttrs({WildDice: GetDice(total)});
        });
    }

    // Does not update the "Skills (old) tab"
    function updateAllSkills() {
        updateAllFixedNonCombatSkills();
        updateAllAdditionalSkills();
    }
    
    function updateAllAdditionalSkills() {
        console.log('Updating all additional skills');
    
        getSectionIDs("skills", function(ids) {
            var details = '';
    
            for(var i=0; i < ids.length; i++) {
                var rowId = ids[i];
                
                UpdateAdditionalSkill(rowId);
    
                var skillsRowName = `repeating_skills_${rowId}_`;
                if(details !== '') {
                    details += ', \r\n';
                }
                details += skillsRowName;
            }
    
            setAttrs({RepeatedSkillFieldIds: details});
        });
    }
    
    function UpdateAdditionalSkill(repeatingRowId) {
        var skillsRowName = `repeating_skills_${repeatingRowId}`;
        if(repeatingRowId !== '') {
            skillsRowName = skillsRowName + '_';
        }
    
        var skillNameName = `${skillsRowName}SkillName`;
        var skillAttributeName = `${skillsRowName}SkillAttribute`;
        var skillRatingName = `${skillsRowName}SkillRating`;
        var skillBonusName = `${skillsRowName}SkillBonus`;
    
        getAttrs(
            ['StrRank',
            'DexRank',
            'BdyRank',
            'PrcRank',
            'IntRank',
            'WilRank',
            'ChrRank',
            'PhysMod',
            'MenMod',
            skillNameName,
            skillAttributeName,
            skillRatingName,
            skillBonusName],
            function(values) {
    
            var skillName = values[skillNameName];
            var skillAttribute = values[skillAttributeName];
            var skillRating = Number(values[skillRatingName]);
            var skillBonus = Number(values[skillBonusName]);
    
            var attributeBonus = GetAttributeBonus(
                skillAttribute,
                values.StrRank,
                values.DexRank,
                values.BdyRank,
                values.PrcRank,
                values.IntRank,
                values.WilRank,
                values.ChrRank
            );
    
            var conditionMod = GetConditionModifier(skillAttribute, values.PhysMod, values.MenMod);
            
            var total = "-";
            if(skillRating > 0)
            {
                total = attributeBonus + skillRating + skillBonus;
            }
    
            var calculatedAttributes = {};
            calculatedAttributes[`${skillsRowName}SkillTotal`] = total;
            calculatedAttributes[`${skillsRowName}SkillDice`] = GetDice(total);
            calculatedAttributes[`${skillsRowName}SkillConditionMod`] = conditionMod;
    
            setAttrs(calculatedAttributes);
        });
    }
    
    function UpdateLangSkills()
    {
        getAttrs(["IntRank", "Lang1Rating", "Lang1Bonus", "Lang2Rating", "Lang2Bonus", "Lang3Rating", "Lang3Bonus"], function(values)
        {
            var total = "-";
            if(Number(values.Lang1Rating) > 0)
            {
                total = Number(values.IntRank) + Number(values.Lang1Rating) + Number(values.Lang1Bonus);
            }
            setAttrs({Lang1Total: total});
            setAttrs({Lang1Dice: GetDice(total)});
    
            total = 0;
            if(Number(values.Lang2Rating) > 0)
            {
                total = Number(values.IntRank) + Number(values.Lang2Rating) + Number(values.Lang2Bonus);
            }
            setAttrs({Lang2Total: total});
            setAttrs({Lang2Dice: GetDice(total)});
    
            total = 0;
            if(Number(values.Lang3Rating) > 0)
            {
                total = Number(values.IntRank) + Number(values.Lang3Rating) + Number(values.Lang3Bonus);
            }
            setAttrs({Lang3Total: total});
            setAttrs({Lang3Dice: GetDice(total)});
        });
    }
    
    function UpdateWeaponDmgMods()
    {
        UpdateW1DmgMod();
        UpdateW2DmgMod();
        UpdateW3DmgMod();
        UpdateW4DmgMod();
        UpdateW5DmgMod();
        UpdateW6DmgMod();
    }
    
    function UpdateW1DmgMod()
    {
        getAttrs(["W1Type", "DmgModTotal", "ShotDmgModTotal"], function(values)
        {
            var x = 0;
            if(values.W1Type == "m")
            {
                x = values.DmgModTotal;
            }
            else if(values.W1Type == "r")
            {
                x = values.ShotDmgModTotal;
            }
            setAttrs({W1DmgMod: x});
        });
    }
    
    function UpdateW2DmgMod()
    {
        getAttrs(["W2Type", "DmgModTotal", "ShotDmgModTotal"], function(values)
        {
            var x = 0;
            if(values.W2Type == "m")
            {
                x = values.DmgModTotal;
            }
            else if(values.W2Type == "r")
            {
                x = values.ShotDmgModTotal;
            }
            setAttrs({W2DmgMod: x});
        });
    }
    
    function UpdateW3DmgMod()
    {
        getAttrs(["W3Type", "DmgModTotal", "ShotDmgModTotal"], function(values)
        {
            var x = 0;
            if(values.W3Type == "m")
            {
                x = values.DmgModTotal;
            }
            else if(values.W3Type == "r")
            {
                x = values.ShotDmgModTotal;
            }
            setAttrs({W3DmgMod: x});
        });
    }
    
    function UpdateW4DmgMod()
    {
        getAttrs(["W4Type", "DmgModTotal", "ShotDmgModTotal"], function(values)
        {
            var x = 0;
            if(values.W4Type == "m")
            {
                x = values.DmgModTotal;
            }
            else if(values.W4Type == "r")
            {
                x = values.ShotDmgModTotal;
            }
            setAttrs({W4DmgMod: x});
        });
    }
    
    function UpdateW5DmgMod()
    {
        getAttrs(["W5Type", "DmgModTotal", "ShotDmgModTotal"], function(values)
        {
            var x = 0;
            if(values.W5Type == "m")
            {
                x = values.DmgModTotal;
            }
            else if(values.W5Type == "r")
            {
                x = values.ShotDmgModTotal;
            }
            setAttrs({W5DmgMod: x});
        });
    }
    
    function UpdateW6DmgMod()
    {
        getAttrs(["W6Type", "DmgModTotal", "ShotDmgModTotal"], function(values)
        {
            var x = 0;
            if(values.W6Type == "m")
            {
                x = values.DmgModTotal;
            }
            else if(values.W6Type == "r")
            {
                x = values.ShotDmgModTotal;
            }
            setAttrs({W6DmgMod: x});
        });
    }
    
    on("change:strbase change:strbonus", function()
    {
        UpdateStrength();
    });
    
    on("change:dmgmodbonus", function()
    {
        UpdateDmgMod();
    });
    
    on("change:dexbase change:dexbonus", function()
    {
        UpdateDexterity();
    });
    
    on("change:defmodbonus", function()
    {
        UpdateDefMod();
    });
    
    on("change:initmodbonus", function()
    {
        UpdateInitMod();
    });
    
    on("change:mvmtbonus", function()
    {
        UpdateMvmt();
    });
    
    on("change:bdybase change:bdybonus", function()
    {
        UpdateBody();
    });
    
    on("change:toughbonus", function()
    {
        UpdateToughness();
    });
    
    on("change:prcbase change:prcbonus", function()
    {
        UpdatePerception();
    });
    
    on("change:shotdmgmodbonus", function()
    {
        UpdateShotDmgMod();
    });
    
    on("change:rgbonus", function()
    {
        UpdateRange();
    });
    
    on("change:intbase change:intbonus", function()
    {
        UpdateIntelligence();
    });
    
    on("change:speffbonus", function()
    {
        UpdateSpellEffect();
    });
    
    on("change:wilbase change:wilbonus", function()
    {
        UpdateWillpower();
    });
    
    on("change:mendefbonus", function()
    {
        UpdateMenDefMod();
    });
    
    on("change:fortbonus", function()
    {
        UpdateFortitude();
    });
    
    on("change:chrbase change:chrbonus", function()
    {
        UpdateCharisma();
    });
    
    on("change:socialbonus", function()
    {
        UpdateSocialPool();
    });
    
    on("change:btybase change:btybonus", function()
    {
        UpdateBeauty();
    });
    
    on("change:maxsaga", function()
    {
        UpdateLevel();
    });
    
    on("change:class", function()
    {
        getAttrs(["Class", "ClassSI", "SpiritInf"], function(values)
        {
            var si = 2;
            switch(values.Class)
            {
                case "chaplain":
                case "monk":
                case "priest":
                case "shaman":
                case "templar":
                case "zealot":
                    si = 10;
                    break;
            }
    
            var bonus = Number(values.SpiritInf) - Number(values.ClassSI);
            setAttrs({ClassSI: si});
            setAttrs({SpiritInf: Number(si) + Number(bonus)});
        });
    });
    
    on("change:race", function()
    {
        getAttrs(["Race"], function(values)
        {
            var mv = 3;
            var un = 3;
            var str = 0;
            var dex = 0;
            var bdy = 0;
            var prc = 0;
            var int = 0;
            var wil = 0;
            var chr = 0;
            var bty = 0;
            var vis = "";
            var soul = 10;
            
            switch(values.Race)
            {
                case "ogre":
                    str = 4; dex = -2; bdy = 1; int = -2; chr = -1; mv = 2; un = 6; vis = "Twilight";
                    break;
                case "troll":
                    str = 4; dex = -2; bdy = 1; int = -2; chr = -1; mv = 2; un = 6; vis = "Dark Sight";
                    break;
                case "highelf":
                    str = -2; dex = 1; bdy = -2; prc = 1; int = 1; wil = 1; bty = 2; vis = "Twilight";
                    break;
                case "halfelf":
                    str = -1; bdy = -1; prc = 1; int = 1; bty = 1; vis = "Twilight";
                    break;
                case "shadow":
                    str = -2; dex = 1; bdy = -2; prc = 1; int = 1; wil = 1; bty = 2; vis = "Dark Sight";
                    break;
                case "dungoblin":
                    str = -1; dex = 1; prc = 1; chr = -1; mv = 4; vis = "Twilight";
                    break;
                case "knocker":
                    str = -2; dex = 2; prc = 1; chr = -1; mv = 4; vis = "Dark Sight";
                    break;
                case "mungreel":
                    str = -2; dex = 2; prc = 1; chr = -1; mv = 4; vis = "Dark Sight";
                    break;
                case "dark":
                    str = -1; dex = 1; bdy = -1; prc = 1; int = 1; wil = 1; chr = -2; bty = 2; vis = "Dark Sight";
                    break;
                case "halfdark":
                    bdy = -1; prc = 1; int = 1; wil = 1; chr = -2; bty = 1; vis = "Twilight";
                    break;
                case "kuthalan":
                    bdy = 2; prc = 2; wil = -1; chr = -3; vis = "Infravision";
                    break;
                case "mhentep":
                    str = -1; dex = 2; bdy = -1; prc = 2; wil = -2; mv = 4; vis = "Twilight";
                    break;
                case "minotaur":
                    str = 3; dex = -1; bdy = 2; prc = -2; int = -2; un = 5; vis = "Twilight";
                    break;
                case "highdwarf":
                    str = 2; dex = -1; bdy = 1; chr = -2; mv = 2; vis = "Dark Sight";
                    break;
                case "paledwarf":
                    str = 2; dex = -1; bdy = 1; chr = -2; mv = 2; vis = "Dark Sight";
                    break;
                case "stonedwarf":
                    str = 2; dex = -1; bdy = 1; chr = -2; mv = 2; vis = "Dark Sight";
                    break;
                case "nephilim":
                    str = 1; prc = 1; wil = -2; vis = "Chromatic / Astral Sight";
                    break;
                case "darkorc":
                    str = 2; bdy = 1; int = -1; chr = -2; un = 5; vis = "Dark Sight";
                    break;
                case "halforc":
                    str = 2; chr = -1; un = 4; vis = "Twilight";
                    break;
                case "orc":
                    str = 1; bdy = 1; int = -1; chr = -1; un = 4; vis = "Dark Sight";
                    break;
                case "sharpheen":
                    str = 2; bdy = 1; int = -1; chr = -2; un = 4; vis = "Infravision";
                    break;
                case "mulpheen":
                    str = 2; bdy = 1; int = -1; chr = -2; un = 4; vis = "Infravision";
                    break;
                case "skog":
                    str = 2; bdy = 1; prc = 2; int = -1; wil = -2; chr = -2; un = 4; vis = "Twilight";
                    break;
                case "halfskog":
                    str = 1; bdy = 1; int = -1; chr = -1; un = 4; vis = "Chromatic";
                    break;
                case "tarkanys":
                    str = -2; dex = 2; prc = 2; chr = -2; mv = 4; vis = "Dark Sight";
                    break;
                case "bloodtark":
                    str = 2; dex = -2; prc = 2; chr = -2; un = 5; vis = "Dark Sight";
                    break;
                case "human":
                    vis = "Chromatic"; soul = 12;
                    break;
                case "mutant":
                    un = 4; vis = "Dark Sight"; soul = 8;
                    break;
            }
            setAttrs({RaceMvmt: mv});
            setAttrs({Vision: vis});
            setAttrs({SoulPoints: soul});
            
            setAttrs({RaceUnarmedRank: un});
            UpdateUnarmed();
            
            setAttrs({StrRace: str});
            UpdateStrength();
            
            setAttrs({DexRace: dex});
            UpdateDexterity();
            
            setAttrs({BdyRace: bdy});
            UpdateBody();
            
            setAttrs({PrcRace: prc});
            UpdatePerception();
            
            setAttrs({IntRace: int});
            UpdateIntelligence();
            
            setAttrs({WilRace: wil});
            UpdateWillpower();
            
            setAttrs({ChrRace: chr});
            UpdateCharisma();
            
            setAttrs({BtyRace: bty});
            UpdateBeauty();
        });
    });
    
    on("change:unarmed", function()
    {
        UpdateUnarmed();
    });
    
    on("change:alchrating change:alchbonus", function()
    {
        UpdateAlchemy();
    });
    
    on("change:acrobatrating change:acrobatbonus", function()
    {
        UpdateAcrobatics();
    });
    
    on("change:actrating change:actbonus", function()
    {
        UpdateActing();
    });
    
    on("change:animalrating change:animalbonus", function()
    {
        UpdateAnimalKinship();
    });
    
    on("change:appraisalrating change:appraisalbonus", function()
    {
        UpdateAppraisal();
    });
    
    on("change:armorerrating change:armorerbonus", function()
    {
        UpdateArmorer();
    });
    
    on("change:artrating change:artbonus", function()
    {
        UpdateArt();
    });
    
    on("change:astrorating change:astrobonus", function()
    {
        UpdateAstrology();
    });
    
    on("change:astronomyrating change:astronomybonus", function()
    {
        UpdateAstronomy();
    });
    
    on("change:barterrating change:barterbonus", function()
    {
        UpdateBarter();
    });
    
    on("change:begrating change:begbonus", function()
    {
        UpdateBegging();
    });
    
    on("change:blackrating change:blackbonus", function()
    {
        UpdateBlacksmith();
    });
    
    on("change:bowyerrating change:bowyerbonus", function()
    {
        UpdateBowyer();
    });
    
    on("change:brewrating change:brewbonus", function()
    {
        UpdateBrewing();
    });
    
    on("change:carprating change:carpbonus", function()
    {
        UpdateCarpentry();
    });
    
    on("change:chantrating change:chantbonus", function()
    {
        UpdateBattleChant();
    });
    
    on("change:bloodrating change:bloodbonus", function()
    {
        UpdateBloodMagic();
    });
    
    on("change:circlerating change:circlebonus", function()
    {
        UpdateCircleMagic();
    });
    
    on("change:climbrating change:climbbonus", function()
    {
        UpdateClimbing();
    });
    
    on("change:concrating change:concbonus", function()
    {
        UpdateConcealment();
    });
    
    on("change:conjrating change:conjbonus", function()
    {
        UpdateConjuring();
    });
    
    on("change:cookrating change:cookbonus", function()
    {
        UpdateCooking();
    });
    
    on("change:creaturerating change:creaturebonus", function()
    {
        UpdateCreatureLore();
    });
    
    on("change:crystalrating change:crystalbonus", function()
    {
        UpdateCrystalLore();
    });
    
    on("change:dancerating change:dancebonus", function()
    {
        UpdateDancing();
    });
    
    on("change:deceptrating change:deceptbonus", function()
    {
        UpdateDeception();
    });
    
    on("change:decipherrating change:decipherbonus", function()
    {
        UpdateDecipher();
    });
    
    on("change:demonrating change:demonbonus", function()
    {
        UpdateDemonLore();
    });
    
    on("change:disgrating change:disgbonus", function()
    {
        UpdateDisguise();
    });
    
    on("change:drinkrating change:drinkbonus", function()
    {
        UpdateDrinking();
    });
    
    on("change:drugrating change:drugbonus", function()
    {
        UpdateDrugTolerance();
    });
    
    on("change:liesrating change:liesbonus", function()
    {
        UpdateDetectLies();
    });
    
    on("change:endurrating change:endurbonus", function()
    {
        UpdateEndurance();
    });
    
    on("change:escaperating change:escapebonus", function()
    {
        UpdateEscapeArtistry();
    });
    
    on("change:exorcismrating change:exorcismbonus", function()
    {
        UpdateExorcism();
    });
    
    on("change:farmrating change:farmbonus", function()
    {
        UpdateFarming();
    });
    
    on("change:fishrating change:fishbonus", function()
    {
        UpdateFishing();
    });
    
    on("change:flyrating change:flybonus", function()
    {
        UpdateFlying();
    });
    
    on("change:foragerating change:foragebonus", function()
    {
        UpdateForaging();
    });
    
    on("change:forgeryrating change:forgerybonus", function()
    {
        UpdateForgery();
    });
    
    on("change:gamblerating change:gamblebonus", function()
    {
        UpdateGambling();
    });
    
    on("change:gemrating change:gembonus", function()
    {
        UpdateGemCutting();
    });
    
    on("change:glassrating change:glassbonus", function()
    {
        UpdateGlassBlowing();
    });
    
    on("change:healrating change:healbonus", function()
    {
        UpdateHealing();
    });
    
    on("change:heraldrating change:heraldbonus", function()
    {
        UpdateHeraldry();
    });
    
    on("change:historyrating change:historybonus", function()
    {
        UpdateHistory();
    });
    
    on("change:huntrating change:huntbonus", function()
    {
        UpdateHunting();
    });
    
    on("change:impersonrating change:impersonbonus", function()
    {
        UpdateImpersonation();
    });
    
    on("change:intrgrating change:intrgbonus", function()
    {
        UpdateInterrogation();
    });
    
    on("change:jugglerating change:jugglebonus", function()
    {
        UpdateJuggling();
    });
    
    on("change:jumprating change:jumpbonus", function()
    {
        UpdateJumping();
    });
    
    on("change:lawrating change:lawbonus", function()
    {
        UpdateLaw();
    });
    
    on("change:leadrating change:leadbonus", function()
    {
        UpdateLeadership();
    });
    
    on("change:lworkrating change:lworkbonus", function()
    {
        UpdateLeatherWorking();
    });
    
    on("change:liftrating change:liftbonus", function()
    {
        UpdateLifting();
    });
    
    on("change:lingrating change:lingbonus", function()
    {
        UpdateLiguistics();
    });
    
    on("change:liprating change:lipbonus", function()
    {
        UpdateLipReading();
    });
    
    on("change:listenrating change:listenbonus", function()
    {
        UpdateListening();
    });
    
    on("change:lockrating change:lockbonus", function()
    {
        UpdateLockPicking();
    });
    
    on("change:locksmithrating change:locksmithbonus", function()
    {
        UpdateLocksmith();
    });
    
    on("change:lootrating change:lootbonus", function()
    {
        UpdateLooting();
    });
    
    on("change:maprating change:mapbonus", function()
    {
        UpdateMapping();
    });
    
    on("change:masonrating change:masonbonus", function()
    {
        UpdateMasonry();
    });
    
    on("change:medicrating change:medicbonus", function()
    {
        UpdateMedicine();
    });
    
    on("change:meditationrating change:meditationbonus", function()
    {
        UpdateMeditation();
    });
    
    on("change:miningrating change:miningbonus", function()
    {
        UpdateMining();
    });
    
    on("change:musicrating change:musicbonus", function()
    {
        UpdateMusic();
    });
    
    on("change:navrating change:navbonus", function()
    {
        UpdateNavigation();
    });
    
    on("change:necrorating change:necrobonus", function()
    {
        UpdateNecromancy();
    });
    
    on("change:observrating change:observbonus", function()
    {
        UpdateObservation();
    });
    
    on("change:philrating change:philbonus", function()
    {
        UpdatePhilosophy();
    });
    
    on("change:plantrating change:plantbonus", function()
    {
        UpdatePlantLore();
    });
    
    on("change:poisrating change:poisbonus", function()
    {
        UpdatePoisons();
    });
    
    on("change:potteryrating change:potterybonus", function()
    {
        UpdatePottery();
    });
    
    on("change:readrating change:readbonus", function()
    {
        UpdateReadWrite();
    });
    
    on("change:researchrating change:researchbonus", function()
    {
        UpdateResearch();
    });
    
    on("change:ridingrating change:ridingbonus", function()
    {
        UpdateRiding();
    });
    
    on("change:runrating change:runbonus", function()
    {
        UpdateRunning();
    });
    
    on("change:searating change:seabonus", function()
    {
        UpdateSeafaring();
    });
    
    on("change:seducrating change:seducbonus", function()
    {
        UpdateSeduction();
    });
    
    on("change:sewrating change:sewbonus", function()
    {
        UpdateSewing();
    });
    
    on("change:siegerating change:siegebonus", function()
    {
        UpdateSiegeCraft();
    });
    
    on("change:singrating change:singbonus", function()
    {
        UpdateSinging();
    });
    
    on("change:skyrating change:skybonus", function()
    {
        UpdateSkyfaring();
    });
    
    on("change:speechrating change:speechbonus", function()
    {
        UpdateSpeech();
    });
    
    on("change:spcraftrating change:spcraftbonus", function()
    {
        UpdateSpellCraft();
    });
    
    on("change:stealrating change:stealbonus", function()
    {
        UpdateStealing();
    });
    
    on("change:stealthrating change:stealthbonus", function()
    {
        UpdateStealth();
    });
    
    on("change:storyrating change:storybonus", function()
    {
        UpdateStoryTelling();
    });
    
    on("change:stsurvrating change:stsurvbonus", function()
    {
        UpdateStreetSurvival();
    });
    
    on("change:streetrating change:streetbonus", function()
    {
        UpdateStreetwise();
    });
    
    on("change:swimrating change:swimbonus", function()
    {
        UpdateSwimming();
    });
    
    on("change:teachrating change:teachbonus", function()
    {
        UpdateTeaching();
    });
    
    on("change:teamrating change:teambonus", function()
    {
        UpdateTeamster();
    });
    
    on("change:thaumrating change:thaumbonus", function()
    {
        UpdateThaumaturgy();
    });
    
    on("change:theorating change:theobonus", function()
    {
        UpdateTheology();
    });
    
    on("change:tinkerrating change:tinkerbonus", function()
    {
        UpdateTinker();
    });
    
    on("change:trackrating change:trackbonus", function()
    {
        UpdateTracking();
    });
    
    on("change:trailrating change:trailbonus", function()
    {
        UpdateTrailing();
    });
    
    on("change:traprating change:trapbonus", function()
    {
        UpdateTraps();
    });
    
    on("change:wpnsmrating change:wpnsmbonus", function()
    {
        UpdateWeaponsmith();
    });
    
    on("change:weatherrating change:weatherbonus", function()
    {
        UpdateWeatherSense();
    });
    
    on("change:weaverating change:weavebonus", function()
    {
        UpdateWeaving();
    });
    
    on("change:wildrating change:wildbonus", function()
    {
        UpdateWildSurvival();
    });
    
    on("change:physmod change:menmod", function() {
        updateAllAdditionalSkills();
    });
    
    on("change:repeating_skills:skillattribute change:repeating_skills:skillrating change:repeating_skills:skillbonus", function() {
        var repeatingRowId = '';
    
        UpdateAdditionalSkill(repeatingRowId);
    });
    
    on("change:lang1rating change:lang1bonus change:lang2rating change:lang2bonus change:lang3rating change:lang3bonus", function()
    {
        UpdateLangSkills();
    });
    
    on("change:helmetar change:amuletar change:cloakar change:pauldronsar change:clothingar change:torsoar change:bracersar change:glovesar change:beltar change:greavesar change:bootsar change:ringar change:ring2ar change:otherar change:other2ar", function()
    {
        UpdateAR();
    });
    
    on("change:w1type", function()
    {
        UpdateW1DmgMod();
    });
    
    on("change:w2type", function()
    {
        UpdateW2DmgMod();
    });
    
    on("change:w3type", function()
    {
        UpdateW3DmgMod();
    });
    
    on("change:w4type", function()
    {
        UpdateW4DmgMod();
    });
    
    on("change:w5type", function()
    {
        UpdateW5DmgMod();
    });
    
    on("change:w6type", function()
    {
        UpdateW6DmgMod();
    });
    
    on("change:honorrep change:corruptrep", function()
    {
        getAttrs(["HonorRep", "CorruptRep"], function(values)
        {
            var goodRepDetails = GetReputationDetails(values.HonorRep);
    
            var badRepDetails = GetReputationDetails(values.CorruptRep);
    
            var totalReputation = Number.parseInt(values.HonorRep) + Number.parseInt(values.CorruptRep);
            var totalRepDetails = GetReputationDetails(totalReputation);
            var talents = totalRepDetails.level - 1;
            var totalReputationString = totalReputation.toLocaleString();
    
            setAttrs({
                TotalReputation: totalReputationString,
                TotalReputationForNextLevel: totalRepDetails.nextLevel,
                ReputationTalents: talents,
                Glory: totalRepDetails.glory,
                HonorTitle: goodRepDetails.goodTitle,
                CorruptionTitle: badRepDetails.badTitle
            });
        });
    });

    function GetReputationDetails(reputation)
    {
        if(reputation < 100) return { level: 1, nextLevel: '100', glory: 0, goodTitle: 'Unknown', badTitle: 'Unknown' };
        if(reputation < 250) return { level: 2, nextLevel: '250', glory: 10, goodTitle: 'Known', badTitle: 'Wanted' };
        if(reputation < 600) return { level: 3, nextLevel: '600', glory: 20, goodTitle: 'Respected', badTitle: 'Hunted' };
        if(reputation < 1000) return { level: 4, nextLevel: '1,000', glory: 30, goodTitle: 'Highly Respected', badTitle: 'Feared' };
        if(reputation < 1450) return { level: 5, nextLevel: '1,450', glory: 40, goodTitle: 'Local Hero', badTitle: 'Villain' };
        if(reputation < 2000) return { level: 6, nextLevel: '2,000', glory: 50, goodTitle: 'Great Hero', badTitle: 'Infamous Villain' };
        if(reputation < 3000) return { level: 7, nextLevel: '3,000', glory: 55, goodTitle: 'Immortal Hero', badTitle: 'Immortal Villain' };
        if(reputation < 5000) return { level: 8, nextLevel: '5,000', glory: 60, goodTitle: 'Epic Hero', badTitle: 'Arch-villain' };
        if(reputation < 8000) return { level: 9, nextLevel: '8,000', glory: 65, goodTitle: 'Revered Hero', badTitle: 'Nemesis' };
        if(reputation < 12000) return { level: 10, nextLevel: '12,000', glory: 70, goodTitle: 'Legendary Hero', badTitle: 'Arch-nemesis' };
        if(reputation < 50000) return { level: 11, nextLevel: '50,000', glory: 80, goodTitle: 'Great Legendary Hero', badTitle: 'Legendary Arch-nemesis' };
        if(reputation < 100000) return { level: 12, nextLevel: '100,000', glory: 90, goodTitle: 'Exalted Legendary Hero', badTitle: 'Unhallowed Scourge' };
        return { level: 13, nextLevel: '-', glory: 99, goodTitle: 'Demigod', badTitle: 'Demigod' };
    }

    on("change:physmod change:menmod", function() {
        UpdateNonCombatSkills();
    });

    on("change:repeating_NonCombatSkills:skillattribute change:repeating_NonCombatSkills:skillrating change:repeating_NonCombatSkills:skillbonus", function() {
        var repeatingRowId = '';
    
        UpdateAdditionalNonCombatSkill(repeatingRowId);

        UpdateAllAdditionalNonCombatSkills();
    });

    on("change:Skill1Attribute change:Skill1Rating change:Skill1Bonus", function()
    {
        UpdateFixedNonCombatSkill(1);
    });

    on("change:Skill2Attribute change:Skill2Rating change:Skill2Bonus", function()
    {
        UpdateFixedNonCombatSkill(2);
    });

    on("change:Skill3Attribute change:Skill3Rating change:Skill3Bonus", function()
    {
        UpdateFixedNonCombatSkill(3);
    });

    on("change:Skill4Attribute change:Skill4Rating change:Skill4Bonus", function()
    {
        UpdateFixedNonCombatSkill(4);
    });

    on("change:Skill5Attribute change:Skill5Rating change:Skill5Bonus", function()
    {
        UpdateFixedNonCombatSkill(5);
    });

    on("change:Skill6Attribute change:Skill6Rating change:Skill6Bonus", function()
    {
        UpdateFixedNonCombatSkill(6);
    });

    on("change:Skill7Attribute change:Skill7Rating change:Skill7Bonus", function()
    {
        UpdateFixedNonCombatSkill(7);
    });

    on("change:Skill8Attribute change:Skill8Rating change:Skill8Bonus", function()
    {
        UpdateFixedNonCombatSkill(8);
    });

    on("change:Skill9Attribute change:Skill9Rating change:Skill9Bonus", function()
    {
        UpdateFixedNonCombatSkill(9);
    });

    on("change:Skill10Attribute change:Skill10Rating change:Skill10Bonus", function()
    {
        UpdateFixedNonCombatSkill(10);
    });
    
    on("change:Skill11Attribute change:Skill11Rating change:Skill11Bonus", function()
    {
        UpdateFixedNonCombatSkill(11);
    });

    on("change:Skill12Attribute change:Skill12Rating change:Skill12Bonus", function()
    {
        UpdateFixedNonCombatSkill(12);
    });

    on("change:Skill13Attribute change:Skill13Rating change:Skill13Bonus", function()
    {
        UpdateFixedNonCombatSkill(13);
    });

    on("change:Skill14Attribute change:Skill14Rating change:Skill14Bonus", function()
    {
        UpdateFixedNonCombatSkill(14);
    });

    on("change:Skill15Attribute change:Skill15Rating change:Skill15Bonus", function()
    {
        UpdateFixedNonCombatSkill(15);
    });

    on("change:Skill16Attribute change:Skill16Rating change:Skill16Bonus", function()
    {
        UpdateFixedNonCombatSkill(16);
    });

    on("change:Skill17Attribute change:Skill17Rating change:Skill17Bonus", function()
    {
        UpdateFixedNonCombatSkill(17);
    });

    on("change:Skill18Attribute change:Skill18Rating change:Skill18Bonus", function()
    {
        UpdateFixedNonCombatSkill(18);
    });

    on("change:Skill19Attribute change:Skill19Rating change:Skill19Bonus", function()
    {
        UpdateFixedNonCombatSkill(19);
    });

    on("change:Skill20Attribute change:Skill20Rating change:Skill20Bonus", function()
    {
        UpdateFixedNonCombatSkill(20);
    });
    
    function updateAllFixedNonCombatSkills() {
        console.log('Updating fixed non-combat skills');

        // Keep this in sync with the number of fixed skill rows on the sheet
        const fixedSkillSlots = 20;

        for(let row = 1; row <= fixedSkillSlots; row++) {
            UpdateFixedNonCombatSkill(row);
        }
    }

    function UpdateFixedNonCombatSkill(row) {
        let skillNameName = `Skill${row}Name`;
        let skillAttributeName = `Skill${row}Attribute`;
        let skillRatingName = `Skill${row}Rating`;
        let skillBonusName = `Skill${row}Bonus`;
        let skillTotalName = `Skill${row}Total`;
        let skillDiceName = `Skill${row}Dice`;
        let skillConditionModName = `Skill${row}ConditionMod`;

        UpdateSkill(skillNameName, skillAttributeName, skillRatingName, skillBonusName, skillTotalName, skillDiceName, skillConditionModName);    
    }

    function UpdateAllAdditionalNonCombatSkills() {
        console.log('Updating all additional skills');
    
        getSectionIDs("NonCombatSkills", function(ids) {
            var details = '';
    
            for(var i=0; i < ids.length; i++) {
                var rowId = ids[i];
                
                UpdateAdditionalNonCombatSkill(rowId);
    
                var skillsRowName = `repeating_NonCombatSkills_${rowId}_`;
                if(details !== '') {
                    details += ', \r\n';
                }
                details += skillsRowName;
            }
    
            setAttrs({RepeatedSkillFieldIds: details});
        });
    }
    
    function UpdateAdditionalNonCombatSkill(repeatingRowId) {
        var skillsRowName = `repeating_NonCombatSkills_${repeatingRowId}`;
        if(repeatingRowId !== '') {
            skillsRowName = skillsRowName + '_';
        }
    
        var skillNameName = `${skillsRowName}SkillName`;
        var skillAttributeName = `${skillsRowName}SkillAttribute`;
        var skillRatingName = `${skillsRowName}SkillRating`;
        var skillBonusName = `${skillsRowName}SkillBonus`;
        let skillTotalName = `${skillsRowName}SkillTotal`;
        let skillDiceName = `${skillsRowName}SkillDice`;
        let skillConditionModName = `${skillsRowName}SkillConditionMod`;

        UpdateSkill(skillNameName, skillAttributeName, skillRatingName, skillBonusName, skillTotalName, skillDiceName, skillConditionModName);
    }

    function UpdateSkill(skillNameName, skillAttributeName, skillRatingName, skillBonusName, skillTotalName, skillDiceName, skillConditionModName) {
        getAttrs(
            ['StrRank',
            'DexRank',
            'BdyRank',
            'PrcRank',
            'IntRank',
            'WilRank',
            'ChrRank',
            'AllureRank',
            'PhysMod',
            'MenMod',
            skillNameName,
            skillAttributeName,
            skillRatingName,
            skillBonusName],
            function(values) {

            var skillName = values[skillNameName];
            var skillAttribute = values[skillAttributeName];
            var skillRating = Number(values[skillRatingName]);
            var skillBonus = Number(values[skillBonusName]);
    
            console.log(`Updating skill: ${skillName}`);

            var calculatedAttributes = {};

            // If no attribute is set, we can't calculate anything. It's probably a blank row anyway.
            if(skillAttribute == '-') {
                calculatedAttributes[skillTotalName] = '-';
                calculatedAttributes[skillDiceName] = '';
                calculatedAttributes[skillConditionModName] = 0;

                setAttrs(calculatedAttributes);
                return;
            }

            var attributeBonus = GetAttributeBonus(
                skillAttribute,
                values.StrRank,
                values.DexRank,
                values.BdyRank,
                values.PrcRank,
                values.IntRank,
                values.WilRank,
                values.ChrRank,
                values.AllureRank
            );
    
            var conditionMod = GetConditionModifier(skillAttribute, values.PhysMod, values.MenMod);
            
            var total = "-";
            if(skillRating > 0)
            {
                total = attributeBonus + skillRating + skillBonus;
            }
    
            calculatedAttributes[skillTotalName] = total;
            calculatedAttributes[skillDiceName] = GetDice(total);
            calculatedAttributes[skillConditionModName] = conditionMod;
    
            setAttrs(calculatedAttributes);
        });        
    }    

    on("sheet:opened", function()
    {
        updateAllSkills();
        convertOldAttributes();
    });

    // We can probably get rid of this
    function convertOldAttributes() {
        const converted = "converted";
        const conversionNotNeeded = "conversion not needed";

        getAttrs(["HpConverted", "CurHP", "CurHP_max", "MaxHP", "MaxHP_max", "CurMana", "CurMana_max", "MaxMana", "MaxMana_max", "CurChi", "CurChi_max", "MaxChi", "MaxChi_max",
        "hit_points", "hit_points_max", "intelligence_mana", "intelligence_mana_max", "body_chi", "body_chi_max"],
        function(values)
        {
            // If we're already converted, we don't need to do anything
            var hpConverted = values.HpConverted;
            if (hpConverted === converted || hpConverted === conversionNotNeeded) {
                return;
            }

            // If HP isn't set, this is a new sheet and doesn't need converting
            if(values.CurHP <= 1 && values.MaxChi <= 1 && values.hit_points <= 1 && values.hit_points_max <= 1) {
                setAttrs({
                    HpConverted: conversionNotNeeded
                });

                console.log('Did not need to convert HP, mana and chi');
                return;
            }
    
            // Work out whether to use the current or max values of each "max" attribute
            var curHP = Math.max(numberOrZero(values.CurHP), numberOrZero(values.hit_points));
            var maxHP = Math.max(numberOrZero(values.MaxHP), numberOrZero(values.MaxHP_max), numberOrZero(values.CurHP_max), numberOrZero(values.hit_points_max));
            var curMana = Math.max(numberOrZero(values.CurMana), numberOrZero(values.intelligence_mana));
            var maxMana = Math.max(numberOrZero(values.CurMana_max), numberOrZero(values.MaxMana), numberOrZero(values.MaxMana_max), numberOrZero(values.intelligence_mana_max));
            var curChi = Math.max(numberOrZero(values.CurChi), numberOrZero(values.body_chi));
            var maxChi = Math.max(numberOrZero(values.CurChi_max), numberOrZero(values.MaxChi), numberOrZero(values.MaxChi_max), numberOrZero(values.body_chi_max));

            setAttrs({
                HP: curHP,
                HP_max: maxHP,
                Mana: curMana,
                Mana_max: maxMana,
                Chi: curChi,
                Chi_max: maxChi,
                HpConverted: converted
            });

            console.log('Converted HP, mana and chi');
        });
    }

    function numberOrZero(input) {
        return isNaN(input) ? 0 : Number(input);
    }

</script>





<div class="sheet-demon-gate-charsheet">

    <div class="sheet-background-flex-layout">
        <div class="sheet-background-column-fixed-left"></div>

        <div class="sheet-background-column-grow">

            <input type="radio" class="sheet-tab sheet-tab1" name="attr_core-tab" value="1" title="Attributes" checked="checked" />
            <span class="sheet-tab sheet-tab1">Attributes</span>
            <input type="radio" class="sheet-tab sheet-tab2" name="attr_core-tab" value="2" title="Skills" />
            <span class="sheet-tab sheet-tab2">Skills</span>
            <input type="radio" class="sheet-tab sheet-tab3" name="attr_core-tab" value="3" title="Combat" />
            <span class="sheet-tab sheet-tab3">Combat</span>
            <input type="radio" class="sheet-tab sheet-tab4" name="attr_core-tab" value="4" title="Gear" />
            <span class="sheet-tab sheet-tab4">Gear</span>
            <input type="radio" class="sheet-tab sheet-tab5" name="attr_core-tab" value="5" title="Mystic" />
            <span class="sheet-tab sheet-tab5">Mystic</span>
            <input type="radio" class="sheet-tab sheet-tab6" name="attr_core-tab" value="6" title="Abilities" />
            <span class="sheet-tab sheet-tab6">Abilities</span>
            <input type="radio" class="sheet-tab sheet-tab7" name="attr_core-tab" value="7" title="Reputation" />
            <span class="sheet-tab sheet-tab7">Reputation</span>
            <input type="radio" class="sheet-tab sheet-tab8" name="attr_core-tab" value="8" title="Notes" />
            <span class="sheet-tab sheet-tab8">Notes</span>
            <input type="radio" class="sheet-tab sheet-tab9" name="attr_core-tab" value="9" title="Full Skills List (old)" />
            <span class="sheet-tab sheet-tab9">Skills (Old)</span>


            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
            ----------------------------------------------------------------------  Core Tab  -----------------------------------------------------------------------
            ------------------------------------------------------------------------------------------------------------------------------------------------------ -->
            <div class="sheet-section-core">
                <div class="sheet-flex-section">
                    <div class="sheet-column-fixed">
                        <img class="sheet-demon-gate-logo" src="https://raw.githubusercontent.com/Roll20/roll20-character-sheets/master/Demon%20Gate/DemonGateLogo.png">
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th>Character Name:</th>
                                <td class="sheet-table-column-fullwidth">
                                    <input type="text" class="sheet-input-wide sheet-input-full" name="attr_character_name" />
                                </td>
                            </tr>
                            <tr>
                                <th>Title or Alias:</th>
                                <td class="sheet-table-column-fullwidth">
                                    <input type="text" class="sheet-input-wide sheet-input-full" name="attr_Title" />
                                </td>
                            </tr>
                            <tr>
                                <th>Player Name:</th>
                                <td class="sheet-table-column-fullwidth">
                                    <input type="text" class="sheet-input-wide sheet-input-full" name="attr_Player" />
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th rowspan="2">Class: </th>
                                <td class="sheet-table-column-fullwidth">
                                    <select name="attr_Class" class="sheet-input-wide sheet-input-full">
                                        <option value="x">---</option>
                                        <option value="alchemist">Alchemist</option>
                                        <option value="assassin">Assassin</option>
                                        <option value="barbarian">Barbarian</option>
                                        <option value="bard">Bard</option>
                                        <option value="bowmaster">Bow Master</option>
                                        <option value="chaplain">Chaplain</option>
                                        <option value="demonhunter">Demon Hunter</option>
                                        <option value="emissary">Emissary</option>
                                        <option value="enchanter">Enchanter</option>
                                        <option value="knighterrant">Knight Errant</option>
                                        <option value="mage">Mage</option>
                                        <option value="merchant">Merchant</option>
                                        <option value="monk">Monk</option>
                                        <option value="mudai">Mu Dai</option>
                                        <option value="pirate">Pirate</option>
                                        <option value="priest">Priest</option>
                                        <option value="prostitute">Prostitute</option>
                                        <option value="ranger">Ranger</option>
                                        <option value="scout">Scout</option>
                                        <option value="shaman">Shaman</option>
                                        <option value="skaldberserker">Skald Berserker</option>
                                        <option value="slave">Slave</option>
                                        <option value="summoner">Summoner</option>
                                        <option value="swordmaster">Sword Master</option>
                                        <option value="templar">Templar</option>
                                        <option value="thief">Thief</option>
                                        <option value="warrior">Warrior</option>
                                        <option value="zealot">Zealot</option>
                                    </select>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-table-column-fullwidth">
                                    <input type="text" class="sheet-input-wide sheet-input-full" name="attr_AltClass" />
                                </td>
                            </tr>
                            <tr>
                                <th rowspan="2">Race: </th>
                                <td>
                                    <select name="attr_Race" class="sheet-input-wide sheet-input-full">
                                        <option value="x">---</option>
                                        <option value="ogre">Bogkroll (Ogre)</option>
                                        <option value="troll">Bogkroll (Troll)</option>
                                        <option value="highelf">Eldrynn (High)</option>
                                        <option value="halfelf">Eldrynn (Half-Elf)</option>
                                        <option value="shadow">Eldrynn (Shadow)</option>
                                        <option value="dungoblin">Goblin (Dungoblin)</option>
                                        <option value="knocker">Goblin (Knocker)</option>
                                        <option value="mungreel">Goblin (Mungreel)</option>
                                        <option value="dark">Kai Eldrynn (Dark)</option>
                                        <option value="halfdark">Kai Eldrynn (Half-Dark-Elf)</option>
                                        <option value="kuthalan">Kuthalan (Reaver)</option>
                                        <option value="mhentep">Mhen Tep (Grimalkin)</option>
                                        <option value="minotaur">Minotaur (Broman)</option>
                                        <option value="highdwarf">Mongru (High Dwarf)</option>
                                        <option value="paledwarf">Mongru (Pale Dwarf)</option>
                                        <option value="stonedwarf">Mongru (Stone Dwarf)</option>
                                        <option value="nephilim">Nephilim (Watcher)</option>
                                        <option value="darkorc">Org (Dark Orc)</option>
                                        <option value="halforc">Org (Half-Orc)</option>
                                        <option value="orc">Org (Orc)</option>
                                        <option value="sharpheen">Sharpheen (Lizard Kin)</option>
                                        <option value="mulpheen">Sharpheen (Mulpheen)</option>
                                        <option value="skog">Skog (Beastkin)</option>
                                        <option value="halfskog">Skog (Half-Brute)</option>
                                        <option value="tarkanys">Tarkanys (Ratkin)</option>
                                        <option value="bloodtark">Tarkanys (Blood Tark)</option>
                                        <option value="human">Terran (Human)</option>
                                        <option value="mutant">Vatagi (Mutant)</option>
                                    </select>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" class="sheet-input-wide sheet-input-full" name="attr_AltRace" />
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-fixed">
                        <table>
                            <tr>
                                <th>Saved Saga Points: </th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" class="sheet-input-narrow" name="attr_SavedSaga" value="0" min="0" />
                                </td>
                            </tr>
                            <tr>
                                <th>Total Saga Points: </th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" class="sheet-input-narrow" name="attr_MaxSaga" value="0" min="0" />
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-prominent-label">Level: </th>
                                <td>
                                    <input type="number" class="sheet-prominent-field sheet-input-narrow" name="attr_Level" min="1" value="1" readonly />
                                </td>
                            </tr>
                            <tr>
                                <th>Saga Points for Next Level: </th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" class="sheet-input-narrow" name="attr_NextLevelSaga" value="0" min="0" readonly />
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>

                <div class="sheet-flex-section-no-margin">
                    <div class="sheet-column-grow">

                        <div class="sheet-flex-section-centre">
                            <div class="sheet-column-prominent-stat">
                                <!-- Hidden attribute to check whether stats have been converted or not -->
                                <input type="hidden" name="attr_HpConverted" value="" />

                                <table>
                                    <tr>
                                        <th colspan="2">
                                            <h2>Hit Points</h2>
                                        </th>
                                    </tr>
                                    <tr>
                                        <td colspan="2">
                                            <input type="number" class="sheet-extra-prominent-field" name="attr_HP" min="1" value="1" />
                                            <input type="hidden" name="attr_CurHP" min="0" value="0" />
                                        </td>
                                    </tr>
                                    <tr>
                                        <th>Max</th>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_HP_max" class="sheet-input-full" min="1" value="1" />
                                            <input type="hidden" name="attr_MaxHP" min="0" value="0" />
                                        </td>
                                    </tr>
                                </table>
                            </div>

                            <div class="sheet-column-prominent-stat">
                                <table>
                                    <tr>
                                        <th colspan="2">
                                            <h2>Mana Pool</h2>
                                        </th>
                                    </tr>
                                    <tr>
                                        <td colspan="2">
                                            <input type="number" class="sheet-extra-prominent-field" name="attr_Mana" value="0" min="0" max="@{MaxMana}" />
                                            <input type="hidden" name="attr_CurMana" value="0" min="0" />
                                        </td>
                                    </tr>
                                    <tr>
                                        <th>Max</th>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_Mana_max" class="sheet-input-full" value="0" min="0" />
                                            <input type="hidden" name="attr_MaxMana" value="0" min="0" />
                                        </td>
                                    </tr>
                                </table>
                            </div>

                            <div class="sheet-column-prominent-stat">
                                <table>
                                    <tr>
                                        <th colspan="2">
                                            <h2>Chi Pool</h2>
                                        </th>
                                    </tr>
                                    <tr>
                                        <td colspan="2">
                                            <input type="number" class="sheet-extra-prominent-field" name="attr_Chi" value="0" min="0" max="@{MaxChi}" />
                                            <input type="hidden" name="attr_CurChi" value="0" min="0" max="@{MaxChi}" />
                                        </td>
                                    </tr>
                                    <tr>
                                        <th>Max</th>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" class="sheet-input-full" name="attr_Chi_max" value="0" min="0" />
                                            <input type="hidden" name="attr_MaxChi" value="0" min="0" />
                                        </td>
                                    </tr>
                                </table>
                            </div>

                            <div class="sheet-column-prominent-stat">
                                <table>
                                    <tr>
                                        <th colspan="2">
                                            <h2>Frenzy</h2>
                                        </th>
                                    </tr>
                                    <tr>
                                        <td colspan="2">
                                            <input type="number" class="sheet-extra-prominent-field" name="attr_Frenzy" value="0" min="0" />
                                        </td>
                                    </tr>
                                </table>
                            </div>
                        </div>

                        <table class="sheet-vertical-margin-moderate">
                            <tr>
                                <th colspan="7">
                                    <h2>Physical Condition</h2>
                                </th>
                            </tr>
                            <tr>
                                <td class="sheet-small-text sheet-physical-condition-0">
                                    <input type="radio" value="+0" name="attr_PhysMod" checked="true" />
                                </td>
                                <td class="sheet-small-text sheet-physical-condition-1">
                                    <input type="radio" value="-0" name="attr_PhysMod" />
                                </td>
                                <td class="sheet-small-text sheet-physical-condition-2">
                                    <input type="radio" value="-1" name="attr_PhysMod" />
                                </td>
                                <td class="sheet-small-text sheet-physical-condition-3">
                                    <input type="radio" value="-2" name="attr_PhysMod" />
                                </td>
                                <td class="sheet-small-text sheet-physical-condition-4">
                                    <input type="radio" value="-3" name="attr_PhysMod" />
                                </td>
                                <td class="sheet-small-text sheet-physical-condition-5">
                                    <input type="radio" value="-4" name="attr_PhysMod" />
                                </td>
                                <td class="sheet-small-text sheet-physical-condition-6">
                                    <input type="radio" value="-5" name="attr_PhysMod" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-small-text">0%</td>
                                <td class="sheet-small-text">-10%</td>
                                <td class="sheet-small-text">-25%</td>
                                <td class="sheet-small-text">-50%</td>
                                <td class="sheet-small-text">-75%</td>
                                <td class="sheet-small-text">-90%</td>
                                <td class="sheet-small-text">-100%</td>
                            </tr>
                            <tr>
                                <th class="sheet-small-text">Rested</th>
                                <th class="sheet-small-text">Tired</th>
                                <th class="sheet-small-text">Weary</th>
                                <th class="sheet-small-text">Fatigued</th>
                                <th class="sheet-small-text">Exhausted</th>
                                <th class="sheet-small-text">Over-Exhausted</th>
                                <th class="sheet-small-text">Critical</th>
                            </tr>
                            <tr>
                                <td class="sheet-small-text">No Mod</td>
                                <td class="sheet-small-text">No Mod</td>
                                <td class="sheet-small-text">-1 rolls</td>
                                <td class="sheet-small-text">-2 rolls</td>
                                <td class="sheet-small-text">-3 rolls</td>
                                <td class="sheet-small-text">-4 rolls</td>
                                <td class="sheet-small-text">-5 rolls</td>
                            </tr>
                        </table>

                        <table class="sheet-vertical-margin-moderate">
                            <tr>
                                <th colspan="7">
                                    <h2>Mental Condition</h2>
                                </th>
                            </tr>
                            <tr>
                                <td class="sheet-small-text sheet-mental-condition-0">
                                    <input type="radio" value="+0" name="attr_MenMod" checked="true" />
                                </td>
                                <td class="sheet-small-text sheet-mental-condition-1">
                                    <input type="radio" value="-0" name="attr_MenMod" />
                                </td>
                                <td class="sheet-small-text sheet-mental-condition-2">
                                    <input type="radio" value="-1" name="attr_MenMod" />
                                </td>
                                <td class="sheet-small-text sheet-mental-condition-3">
                                    <input type="radio" value="-2" name="attr_MenMod" />
                                </td>
                                <td class="sheet-small-text sheet-mental-condition-4">
                                    <input type="radio" value="-3" name="attr_MenMod" />
                                </td>
                                <td class="sheet-small-text sheet-mental-condition-5">
                                    <input type="radio" value="-4" name="attr_MenMod" />
                                </td>
                                <td class="sheet-small-text sheet-mental-condition-6">
                                    <input type="radio" value="-5" name="attr_MenMod" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-small-text">0%</td>
                                <td class="sheet-small-text">-10%</td>
                                <td class="sheet-small-text">-25%</td>
                                <td class="sheet-small-text">-50%</td>
                                <td class="sheet-small-text">-75%</td>
                                <td class="sheet-small-text">-90%</td>
                                <td class="sheet-small-text">-100%</td>
                            </tr>
                            <tr>
                                <th class="sheet-small-text">Content</th>
                                <th class="sheet-small-text">Agitated</th>
                                <th class="sheet-small-text">Distraught</th>
                                <th class="sheet-small-text">Irrational</th>
                                <th class="sheet-small-text">Unstable</th>
                                <th class="sheet-small-text">Maniacal</th>
                                <th class="sheet-small-text">Senseless</th>
                            </tr>
                            <tr>
                                <td class="sheet-small-text">No Mod</td>
                                <td class="sheet-small-text">No Mod</td>
                                <td class="sheet-small-text">-1 rolls</td>
                                <td class="sheet-small-text">-2 rolls</td>
                                <td class="sheet-small-text">-3 rolls</td>
                                <td class="sheet-small-text">-4 rolls</td>
                                <td class="sheet-small-text">-5 rolls</td>
                            </tr>
                        </table>
                    </div>


                    <!-------------->
                    <!--Attributes-->
                    <!-------------->

                    <div class="sheet-column-grow">
                        <h1 class="sheet-vertical-margin">Attributes</h1>

                        <!--Strength-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Strength</h3>
                                </th>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_StrBase" value="0" min="0" max="100" /></td>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_StrBonus" value="0" min="-100" max="100" /></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_StrRace" value="0" />
                                    <input type="number" name="attr_StrTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_StrRank" value="0" readonly />
                                </td>
                                <td>
                                    <input type="text" name="attr_StrDice" value="d1" readonly class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Strength Check}} {{roll=[[@{StrDice}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Damage Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_DmgModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_DmgModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_DmgModTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Weight Allowance:</th>
                                <td colspan="2"></td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" class="sheet-text-centred" name="attr_WtAllow" value="vl" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>

                        <!--Dexterity-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Dexterity</h3>
                                </th>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_DexBase" value="0" min="0" max="100" /></td>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_DexBonus" value="0" min="-100" max="100" /></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_DexRace" value="0" />
                                    <input type="number" name="attr_DexTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_DexRank" value="0" readonly />
                                </td>
                                <td>
                                    <input type="text" name="attr_DexDice" value="d1" readonly class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Dexterity Check}} {{roll=[[@{DexDice}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Defense Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_DefModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_DefModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_DefModTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Initiative Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_InitModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_InitModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_InitModTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Movement:</th>
                                <td class="sheet-cell-numeric"></td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_MvmtBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_RaceMvmt" value="0" />
                                    <input type="number" name="attr_Mvmt" value="0" readonly class="sheet-input-split" />
                                    <span class="sheet-input-spacer">/</span>
                                    <input type="number" name="attr_RunMvmt" value="0" readonly class="sheet-input-split" />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>

                        <!--Body-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Body</h3>
                                </th>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_BdyBase" value="0" min="0" max="100" /></td>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_BdyBonus" value="0" min="-100" max="100" /></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_BdyRace" value="0" />
                                    <input type="number" name="attr_BdyTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_BdyRank" value="0" readonly />
                                </td>
                                <td>
                                    <input type="text" name="attr_BdyDice" value="d1" readonly class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Body Check}} {{roll=[[@{BdyDice}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Toughness:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_ToughBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ToughBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_ToughTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Body Save:</th>
                                <td colspan="2"></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_HPAdj" value="0" />
                                    <input type="number" name="attr_BdySave" value="0" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:percentile} [[ ([[1d20 + ?{Modifier|0}]] - @{BdySave}) * -1]] ]] {{name=Body Save}} {{roll=$[[0]]}} {{target=@{BdySave}}} {{difference=$[[1]]}}">
                                    </button>
                                </td>
                                <td colspan="2"></td>
                            </tr>
                        </table>

                        <!--Perception-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Perception</h3>
                                </th>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_PrcBase" value="0" min="0" max="100" /></td>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_PrcBonus" value="0" min="-100" max="100" /></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_PrcRace" value="0" />
                                    <input type="number" name="attr_PrcTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_PrcRank" value="0" readonly />
                                </td>
                                <td>
                                    <input type="text" name="attr_PrcDice" value="d1" readonly class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Perception Check}} {{roll=[[@{PrcDice}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Shot Damage Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_ShotDmgModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ShotDmgModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_ShotDmgModTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Range Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_RgBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_RgBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_RgTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>

                        <!--Intelligence-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Intelligence</h3>
                                </th>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_IntBase" value="0" min="0" max="100" /></td>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_IntBonus" value="0" min="-100" max="100" /></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_IntRace" value="0" />
                                    <input type="number" name="attr_IntTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_IntRank" value="0" readonly />
                                </td>
                                <td>
                                    <input type="text" name="attr_IntDice" value="d1" readonly class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Intelligence Check}} {{roll=[[@{IntDice}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Spell Effect:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_SpEffBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_SpEffBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_SpEffTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Spell Time:</th>
                                <td></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="text" name="attr_SpellTime" readonly class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="text" name="attr_SpText" readonly class="sheet-text-centred" />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Languages:</th>
                                <td colspan="2"></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_Langs" value="0" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>

                        <!--Willpower-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Willpower</h3>
                                </th>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_WilBase" value="0" min="0" max="100" /></td>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_WilBonus" value="0" min="-100" max="100" /></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_WilRace" value="0" />
                                    <input type="number" name="attr_WilTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_WilRank" value="0" readonly />
                                </td>
                                <td>
                                    <input type="text" name="attr_WilDice" value="d1" readonly class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Willpower Check}} {{roll=[[@{WilDice}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Mental Defense:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_ManaAdj" value="0" />
                                    <input type="number" name="attr_MenDefBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_MenDefBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_MenDefTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Fortitude:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_FortBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_FortBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_FortTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>

                        <!--Charisma-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Charisma</h3>
                                </th>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_ChrBase" value="0" min="0" max="100" /></td>
                                <td class="sheet-cell-numeric"><input type="number" name="attr_ChrBonus" value="0" min="-100" max="100" /></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_ChrRace" value="0" />
                                    <input type="number" name="attr_ChrTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_ChrRank" value="0" readonly />
                                </td>
                                <td>
                                    <input type="text" name="attr_ChrDice" value="d1" readonly class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Charisma Check}} {{roll=[[@{ChrDice}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Social Pool:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_SocialBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_SocialBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_SocialPool" value="0" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Reputation Bonus:</th>
                                <td colspan="2"></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_RepBonus" value="0" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>

                        <!--Beauty-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Beauty</h3>
                                </th>
                                <td class="sheet-cell-numeric">
                                    <input type="hidden" name="attr_BtyRace" value="0" />
                                    <input type="number" name="attr_BtyBase" value="0" min="0" max="100" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BtyBonus" value="0" min="-100" max="100" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_BtyTotal" value="0" class="sheet-totalfield" readonly />
                                </td>
                                <td class="sheet-beauty-table-spacer-cell"></td>
                            </tr>
                        </table>
                    </div>
                </div>
            </div>



            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
            ---------------------------------------------------------------------  Skills Tab  ----------------------------------------------------------------------
            ------------------------------------------------------------------------------------------------------------------------------------------------------ -->
            <div class="sheet-section-skills">

                <div class="sheet-flex-section">

                    <div class="sheet-column-fixed">                     
                        <h1>Combat Skills</h1>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Melee</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedMelee" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Unarmed</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Unarmed">
                                                    <option value="0">Basic</option>
                                                    <option value="1">Fighter (+1)</option>
                                                    <option value="2">Brawler (+2)</option>
                                                    <option value="3">Martial Arts (+3)</option>
                                                    <option value="4">Martial Arts (+4)</option>
                                                    <option value="5">Martial Arts (+5)</option>
                                                    <option value="6">Champion (+6)</option>
                                                    <option value="7">Champion (+7)</option>
                                                    <option value="8">Master (+8)</option>
                                                    <option value="9">Master (+9)</option>
                                                    <option value="10">Grand Master (+10)</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Alchemy</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Alchemy">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Axes</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Axes">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Flails</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Flails">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Grenades</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Grenades">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Hammers</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Hammers">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Javelins</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Javelins">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Knives</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Knives">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Maces</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Maces">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Polearms</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Polearms">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Shurikens</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Shurikens">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Staves</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Staves">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Swords</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Swords">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Whips</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Whips">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Blind Fighting</td>
                                            <td class="sheet-cell-numeric-readonly">2</td>
                                            <td><select name="attr_BlindFighting">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Dual Melee</td>
                                            <td class="sheet-cell-numeric-readonly">3</td>
                                            <td><select name="attr_DualMelee">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Throwing</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td><select name="attr_Throwing">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td colspan="3">* = As Rating</td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Shooting</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedShooting" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Black Powder</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td><select name="attr_BlackPowder">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Lances</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Lances">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Pistols</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Pistols">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Rifles</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Rifles">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Shotguns</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Shotguns">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Blind Shooting</td>
                                            <td class="sheet-cell-numeric-readonly">2</td>
                                            <td><select name="attr_BlindShooting">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Dual Shooting</td>
                                            <td class="sheet-cell-numeric-readonly">3</td>
                                            <td><select name="attr_DualShooting">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Projectiles</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td><select name="attr_Projectiles">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Blow Guns</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_BlowGuns">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Bows</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Bows">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Crossbows</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Crossbows">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Hand Bows</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_HandBows">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Slings</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Slings">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Siege Weapons</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td><select name="attr_Siege">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Ballistae</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Ballistae">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Cannons</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Cannons">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Catapults</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Catapults">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Trebuchets</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Trebuchets">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Magic</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedMagic" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Black Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_BlackMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Blue Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_BlueMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Brown Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_BrownMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Gold Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_GoldMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Gray Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_GrayMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Green Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_GreenMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Red Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_RedMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">White Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_WhiteMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Armor</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedArmor" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Light Armor</td>
                                            <td class="sheet-cell-numeric-readonly">2</td>
                                            <td><select name="attr_LightArmor">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Medium Armor</td>
                                            <td class="sheet-cell-numeric-readonly">2</td>
                                            <td><select name="attr_MedArmor">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Heavy Armor</td>
                                            <td class="sheet-cell-numeric-readonly">2</td>
                                            <td><select name="attr_HeavyArmor">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Body Armor</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_BodyArmor">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Bracers</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Bracers">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Greaves</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Greaves">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Helmet</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Helmet">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Pauldron</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td><select name="attr_Pauldron">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                </select></td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Shields</td>
                                            <td class="sheet-cell-numeric-readonly">3</td>
                                            <td><select name="attr_Shields">
                                                    <option value="0">---</option>
                                                    <option value="1">+1 cover</option>
                                                </select></td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Combat Specializations</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedCombatSpecs" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                        </tr>
                                        <tr>
                                            <td colspan="2">
                                                <fieldset class="repeating_wpnspecs">
                                                    <div class="sheet-repeating-section">
                                                        <table>
                                                            <tr>
                                                                <td>
                                                                    <input type="text" name="attr_WpnSpecName" value="" />
                                                                </td>
                                                                <td class="sheet-cell-numeric">
                                                                    <input type="number" name="attr_WpnSpecRating" value="" />
                                                                </td>
                                                            </tr>
                                                        </table>
                                                    </div>
                                                </fieldset>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <h1 class="sheet-spacer-top-margin">Languages</h1>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Fluent Languages</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedFluentLanguages" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <fieldset class="repeating_languages">
                                        <div class="sheet-repeating-section">
                                            <table>
                                                <tr>
                                                    <td>
                                                        <input type="text" name="attr_LearnedLang" value="" />
                                                    </td>
                                                </tr>
                                            </table>
                                        </div>
                                    </fieldset>
                                </div>
                            </div>
                        </div>                        
                    </div>

                    <div class="sheet-column-grow">
                        <div>
                            <h1>Non-Combat Skills</h1>
                        </div>

                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Cost</th>
                                <th class="sheet-small-table-header">Attr</th>
                                <th class="sheet-small-table-header">Rating</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Tier</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header">Roll</th>
                            </tr>

                            <!-- Non-Combat Skill 1 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill1Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill1Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill1Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill1Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill1Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill1Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill1Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill1Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill1ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill1Name} Check}} {{text=Roll: [[@{Skill1Dice}@{Skill1Tier}@{Skill1ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 2 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill2Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill2Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill2Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill2Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill2Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill2Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill2Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill2Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill2ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill2Name} Check}} {{text=Roll: [[@{Skill2Dice}@{Skill2Tier}@{Skill2ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 3 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill3Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill3Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill3Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill3Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill3Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill3Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill3Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill3Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill3ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill3Name} Check}} {{text=Roll: [[@{Skill3Dice}@{Skill3Tier}@{Skill3ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 4 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill4Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill4Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill4Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill4Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill4Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill4Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill4Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill4Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill4ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill4Name} Check}} {{text=Roll: [[@{Skill4Dice}@{Skill4Tier}@{Skill4ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 5 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill5Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill5Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill5Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill5Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill5Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill5Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill5Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill5Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill5ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill5Name} Check}} {{text=Roll: [[@{Skill5Dice}@{Skill5Tier}@{Skill5ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 6 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill6Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill6Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill6Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill6Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill6Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill6Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill6Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill6Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill6ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill6Name} Check}} {{text=Roll: [[@{Skill6Dice}@{Skill6Tier}@{Skill6ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 7 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill7Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill7Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill7Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill7Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill7Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill7Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill7Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill7Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill7ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill7Name} Check}} {{text=Roll: [[@{Skill7Dice}@{Skill7Tier}@{Skill7ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 8 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill8Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill8Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill8Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill8Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill8Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill8Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill8Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill8Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill8ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill8Name} Check}} {{text=Roll: [[@{Skill8Dice}@{Skill8Tier}@{Skill8ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 9 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill9Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill9Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill9Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill9Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill9Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill9Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill9Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill9Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill9ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill9Name} Check}} {{text=Roll: [[@{Skill9Dice}@{Skill9Tier}@{Skill9ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 10 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill10Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill10Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill10Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill10Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill10Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill10Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill10Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill10Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill10ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill10Name} Check}} {{text=Roll: [[@{Skill10Dice}@{Skill10Tier}@{Skill10ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>


                            <!-- Non-Combat Skill 11 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill11Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill11Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill11Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill11Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill11Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill11Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill11Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill11Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill11ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill11Name} Check}} {{text=Roll: [[@{Skill11Dice}@{Skill11Tier}@{Skill11ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 12 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill12Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill12Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill12Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill12Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill12Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill12Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill12Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill12Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill12ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill12Name} Check}} {{text=Roll: [[@{Skill12Dice}@{Skill12Tier}@{Skill12ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 13 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill13Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill13Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill13Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill13Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill13Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill13Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill13Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill13Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill13ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill13Name} Check}} {{text=Roll: [[@{Skill13Dice}@{Skill13Tier}@{Skill13ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 14 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill14Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill14Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill14Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill14Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill14Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill14Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill14Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill14Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill14ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill14Name} Check}} {{text=Roll: [[@{Skill14Dice}@{Skill14Tier}@{Skill14ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 15 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill15Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill15Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill15Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill15Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill15Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill15Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill15Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill15Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill15ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill15Name} Check}} {{text=Roll: [[@{Skill15Dice}@{Skill15Tier}@{Skill15ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 16 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill16Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill16Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill16Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill16Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill16Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill16Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill16Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill16Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill16ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill16Name} Check}} {{text=Roll: [[@{Skill16Dice}@{Skill16Tier}@{Skill16ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 17 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill17Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill17Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill17Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill17Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill17Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill17Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill17Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill17Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill17ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill17Name} Check}} {{text=Roll: [[@{Skill17Dice}@{Skill17Tier}@{Skill17ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 18 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill18Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill18Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill18Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill18Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill18Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill18Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill18Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill18Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill18ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill18Name} Check}} {{text=Roll: [[@{Skill18Dice}@{Skill18Tier}@{Skill18ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 19 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill19Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill19Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill19Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill19Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill19Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill19Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill19Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill19Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill19ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill19Name} Check}} {{text=Roll: [[@{Skill19Dice}@{Skill19Tier}@{Skill19ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 20 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill20Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill20Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill20Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill20Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill20Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Skill20Total" value="-" readonly class="sheet-totalfield" />
                                </td>
                                <td>
                                    <select name="attr_Skill20Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input type="text" name="attr_Skill20Dice" value="" readonly class="sheet-dice-field" />
                                    <input type="hidden" name="attr_Skill20ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill20Name} Check}} {{text=Roll: [[@{Skill20Dice}@{Skill20Tier}@{Skill20ConditionMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>
                                                                                                                
                        </table>

                        <div class="sheet-collapse-wrapper sheet-vertical-margin-moderate">
                            <h2 class="sheet-standalone-header">Additional Skills</h2>

                            <fieldset class="repeating_NonCombatSkills">
                                <table class="sheet-repeating-section">
                                    <tr>
                                        <th class="sheet-small-table-header">Name</th>
                                        <th class="sheet-small-table-header">Cost</th>
                                        <th class="sheet-small-table-header">Attr</th>
                                        <th class="sheet-small-table-header">Rating</th>
                                        <th class="sheet-small-table-header">Bonus</th>
                                        <th class="sheet-small-table-header">Total</th>
                                        <th class="sheet-small-table-header">Tier</th>
                                        <th class="sheet-small-table-header">Dice</th>
                                        <th class="sheet-small-table-header">Roll</th>
                                    </tr>
                                    <tr>
                                        <td class="sheet-skillname-input-cell">
                                            <input type="text" name="attr_SkillName" value="" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_SkillCost" value="1" />
                                        </td>
                                        <td>
                                            <select name="attr_SkillAttribute" class="sheet-skill-attribute">
                                                <option value="str">Str</option>
                                                <option value="dex">Dex</option>
                                                <option value="bdy">Bod</option>
                                                <option value="prc">Per</option>
                                                <option value="int">Int</option>
                                                <option value="wil">Wil</option>
                                                <option value="chr">Chr</option>
                                                <option value="alu">Alu</option>
                                            </select>
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_SkillRating" value="0" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_SkillBonus" value="0" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="text" name="attr_SkillTotal" value="-" readonly class="sheet-totalfield" />
                                        </td>
                                        <td>
                                            <select name="attr_SkillTier">
                                                <option value="+0">Basic</option>
                                                <option value="+1">Expert</option>
                                                <option value="+2">Master</option>
                                            </select>
                                        </td>
                                        <td>
                                            <input type="text" name="attr_SkillDice" value="" readonly class="sheet-dice-field" />
                                            <input type="hidden" name="attr_SkillConditionMod" value="0" />
                                        </td>
                                        <td class="sheet-button-cell">
                                            <button type="roll"
                                                value="&{template:simple} {{character=@{character_name}}}{{name=@{SkillName} Check}} {{text=Roll: [[@{SkillDice}@{SkillTier}@{SkillConditionMod}+?{Modifier|0}]]}}">
                                            </button>
                                        </td>
                                    </tr>
                                </table>
                            </fieldset>    
                        </div>
                    </div>

                </div>
            </div>



            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
            ---------------------------------------------------------------------  Combat Tab  ----------------------------------------------------------------------
            ------------------------------------------------------------------------------------------------------------------------------------------------------ -->
            <div class="sheet-section-combat">

                <div class="sheet-flex-section">
                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="3">
                                    <h2>Physical Attacks</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                <th class="sheet-small-table-header">Damage</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon1Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon1Name}}} {{roll=[[d20+@{Weapon1Hit}@{PhysMod}+@{Weapon1HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon1Name}}} {{damage=[[(@{Weapon1Dmg}+@{Weapon1DmgBonus}+@{W1DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon2Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon2Name}}} {{roll=[[d20+@{Weapon2Hit}@{PhysMod}+@{Weapon2HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon2Name}}} {{damage=[[(@{Weapon2Dmg}+@{Weapon2DmgBonus}+@{W2DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon3Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon3Name}}} {{roll=[[d20+@{Weapon3Hit}@{PhysMod}+@{Weapon3HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon3Name}}} {{damage=[[(@{Weapon3Dmg}+@{Weapon3DmgBonus}+@{W3DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon4Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon4Name}}} {{roll=[[d20+@{Weapon4Hit}@{PhysMod}+@{Weapon4HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon4Name}}} {{damage=[[(@{Weapon4Dmg}+@{Weapon4DmgBonus}+@{W4DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon5Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon5Name}}} {{roll=[[d20+@{Weapon5Hit}@{PhysMod}+@{Weapon5HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon5Name}}} {{damage=[[(@{Weapon5Dmg}+@{Weapon5DmgBonus}+@{W5DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon6Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon6Name}}} {{roll=[[d20+@{Weapon6Hit}@{PhysMod}+@{Weapon6HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon6Name}}} {{damage=[[(@{Weapon6Dmg}+@{Weapon6DmgBonus}+@{W6DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_u1" value="Basic Unarmed" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=Unarmed}} {{roll=[[d20+@{UnarmedHit}@{PhysMod}+@{UnarmedHitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=Unarmed}} {{damage=[[(@{UnarmedDmg}+@{UnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_AltUnarmedName" value="Alternate Unarmed" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{AltUnarmedName}}} {{roll=[[d20+@{AltUnarmedHit}@{PhysMod}+@{AltUnarmedHitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{AltUnarmedName}}} {{damage=[[(@{AltUnarmedDmg}+@{AltUnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="3">
                                    <h2>Spells</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                <th class="sheet-small-table-header">Damage</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell1Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell1Name}}} {{character=@{character_name}}} {{area=@{Spell1Area}}} {{duration=@{Spell1Dur}}} {{actions=@{Spell1Act}}} {{drain=@{Spell1Drain}}} {{roll=[[d20+@{Spell1HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell1Name}}} {{character=@{character_name}}} {{protection=@{Spell1Prot}}} {{roll=[[(@{Spell1Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell2Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell2Name}}} {{character=@{character_name}}} {{area=@{Spell2Area}}} {{duration=@{Spell2Dur}}} {{actions=@{Spell2Act}}} {{drain=@{Spell2Drain}}} {{roll=[[d20+@{Spell2HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell2Name}}} {{character=@{character_name}}} {{protection=@{Spell2Prot}}} {{roll=[[(@{Spell2Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell3Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell3Name}}} {{character=@{character_name}}} {{area=@{Spell3Area}}} {{duration=@{Spell3Dur}}} {{actions=@{Spell3Act}}} {{drain=@{Spell3Drain}}} {{roll=[[d20+@{Spell3HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell3Name}}} {{character=@{character_name}}} {{protection=@{Spell3Prot}}} {{roll=[[(@{Spell3Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell4Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell4Name}}} {{character=@{character_name}}} {{area=@{Spell4Area}}} {{duration=@{Spell4Dur}}} {{actions=@{Spell4Act}}} {{drain=@{Spell4Drain}}} {{roll=[[d20+@{Spell4HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell4Name}}} {{character=@{character_name}}} {{protection=@{Spell4Prot}}} {{roll=[[(@{Spell4Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell5Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell5Name}}} {{character=@{character_name}}} {{area=@{Spell5Area}}} {{duration=@{Spell5Dur}}} {{actions=@{Spell5Act}}} {{drain=@{Spell5Drain}}} {{roll=[[d20+@{Spell5HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell5Name}}} {{character=@{character_name}}} {{protection=@{Spell5Prot}}} {{roll=[[(@{Spell5Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell6Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell6Name}}} {{character=@{character_name}}} {{area=@{Spell6Area}}} {{duration=@{Spell6Dur}}} {{actions=@{Spell6Act}}} {{drain=@{Spell6Drain}}} {{roll=[[d20+@{Spell6HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell6Name}}} {{character=@{character_name}}} {{protection=@{Spell6Prot}}} {{roll=[[(@{Spell6Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell7Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell7Name}}} {{character=@{character_name}}} {{area=@{Spell7Area}}} {{duration=@{Spell7Dur}}} {{actions=@{Spell7Act}}} {{drain=@{Spell7Drain}}} {{roll=[[d20+@{Spell7HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell7Name}}} {{character=@{character_name}}} {{protection=@{Spell7Prot}}} {{roll=[[(@{Spell7Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell8Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell8Name}}} {{character=@{character_name}}} {{area=@{Spell8Area}}} {{duration=@{Spell8Dur}}} {{actions=@{Spell8Act}}} {{drain=@{Spell8Drain}}} {{roll=[[d20+@{Spell8HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell8Name}}} {{character=@{character_name}}} {{protection=@{Spell8Prot}}} {{roll=[[(@{Spell8Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell9Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell9Name}}} {{character=@{character_name}}} {{area=@{Spell9Area}}} {{duration=@{Spell9Dur}}} {{actions=@{Spell9Act}}} {{drain=@{Spell9Drain}}} {{roll=[[d20+@{Spell9HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell9Name}}} {{character=@{character_name}}} {{protection=@{Spell9Prot}}} {{roll=[[(@{Spell9Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell10Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell10Name}}} {{character=@{character_name}}} {{area=@{Spell10Area}}} {{duration=@{Spell10Dur}}} {{actions=@{Spell10Act}}} {{drain=@{Spell10Drain}}} {{roll=[[d20+@{Spell10HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell10Name}}} {{character=@{character_name}}} {{protection=@{Spell10Prot}}} {{roll=[[(@{Spell10Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                    </button>
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="2">
                                    <h2>Actions</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Type</th>
                                <th class="sheet-small-table-header">Amt</th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Unarmed</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_UnarmedActions" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Melee</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_MeleeActions" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Projectile</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ProjActions" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Magic</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_MagicActions" value="0" />
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="3">
                                    <h2>Defense</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Type</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Roll</th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Dodge</td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" class="sheet-desctotalfield" name="attr_DefModTotal" value="0" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll" value="&{template:roll} {{character=@{character_name}}} {{name=Dodge Roll}} {{roll=[[d20+@{DefModTotal}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Parry</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ParryBonus" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Parry Roll}} {{roll=[[d20+@{DefModTotal}+@{ParryBonus}-1+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Block w/ Melee</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BlockBonus" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Block Roll}} {{roll=[[d20+@{DefModTotal}+@{BlockBonus}+1+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Block w/ Shield</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ShieldBlockBonus" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Shield Block Roll}} {{roll=[[d20+@{DefModTotal}+@{ShieldBlockBonus}+@{ShieldCover}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Mental Defense</td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" class="sheet-desctotalfield" name="attr_MenDefTotal" value="0" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Mental Defense Roll}} {{roll=[[d20+@{MenDefTotal}+?{Modifier|0}]]}}">
                                    </button>
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="3">
                                    <h2>Initiative</h2>
                                </th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Initiative</td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Initiative Roll}} {{roll=[[1d10!+@{InitModTotal}+?{Modifier|0}&{tracker}]]}}">
                                    </button>
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="2">
                                    <h2>Soak</h2>
                                </th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Total Armor Value</td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" class="sheet-desctotalfield" name="attr_TotalAR" value="0" readonly />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Toughness</td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" class="sheet-desctotalfield" name="attr_ToughTotal" value="0" readonly />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Fortitude</td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" class="sheet-desctotalfield" name="attr_FortTotal" value="0" readonly />
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="2">
                                    <h2>Resistances</h2>
                                </th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Fire</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_FireRes" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Cold</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ColdRes" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Toxic</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ToxicRes" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Electrical</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ElecRes" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Sonic</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_SonicRes" value="0" />
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>
            </div>



            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
            ----------------------------------------------------------------------  Gear Tab  -----------------------------------------------------------------------
            ------------------------------------------------------------------------------------------------------------------------------------------------------ -->
            <div class="sheet-section-gear">

                <div class="sheet-flex-section">

                    <div class="sheet-column-grow">

                        <h1>Weapons</h1>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Unarmed</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td class="sheet-read-only-field sheet-skillname">Basic Unarmed</td>
                                <td>
                                    <input type="number" name="attr_UnarmedHitBonus" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td>
                                    <input type="number" name="attr_UnarmedHit" value="0" readonly class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=Unarmed}} {{roll=[[d20+@{UnarmedHit}@{PhysMod}+@{UnarmedHitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Accessory</th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_UnarmedAccessory" value="" />
                                </td>
                                <td>
                                    <input type="text" name="attr_UnarmedDmgBonus" value="0" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-read-only-field">
                                    <input type="hidden" name="attr_UnarmedRank" value="0" />
                                    <input type="hidden" name="attr_RaceUnarmedRank" value="3" />
                                    <input type="text" name="attr_UnarmedDmg" value="d6!" readonly class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Unarmed}}} {{damage=[[(@{UnarmedDmg}+@{UnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_AltUnarmedName" value="Alternate Unarmed" />
                                </td>
                                <td>
                                    <input type="number" name="attr_AltUnarmedHitBonus" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td>
                                    <input type="number" name="attr_AltUnarmedHit" value="0" readonly class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{AltUnarmedName}}} {{roll=[[d20+@{AltUnarmedHit}@{PhysMod}+@{AltUnarmedHitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Accessory</th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_AltUnarmedAccessory" value="" />
                                </td>
                                <td>
                                    <input type="text" name="attr_AltUnarmedDmgBonus" value="0" class="sheet-text-centred" />
                                </td>
                                <td>
                                    <input type="text" name="attr_AltUnarmedDmg" value="d6!" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{AltUnarmedName}}} {{damage=[[(@{AltUnarmedDmg}+@{AltUnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                        </table>

                        <!--WEAPONS-->
                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Primary Weapon</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon1Name" value="" />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon1HitBonus" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon1Hit" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon1Name}}} {{roll=[[d20+@{Weapon1Hit}@{PhysMod}+@{Weapon1HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header"></th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <th>Damage:</th>
                                <td>
                                    <input type="text" name="attr_Weapon1DmgBonus" value="0" class="sheet-text-centred" />
                                </td>
                                <td>
                                    <input type="text" name="attr_Weapon1Dmg" value="0" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon1Name}}} {{damage=[[(@{Weapon1Dmg}+@{Weapon1DmgBonus}+@{W1DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th>Accessory:</th>
                                <td colspan="2">
                                    <input type="text" name="attr_Weapon1Acc" value="" />
                                </td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Type:</th>
                                <td><select name="attr_W1Type">
                                        <option value="m">Melee</option>
                                        <option value="r">Shooting</option>
                                        <option value="o">Other</option>
                                    </select>
                                </td>
                                <td><input type="hidden" name="attr_W1DmgMod" value="0" /></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Durability:</th>
                                <td>
                                    <input type="text" name="attr_Weapon1Dur" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Weight:</th>
                                <td>
                                    <input type="text" name="attr_Weapon1Wgt" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Ammo:</th>
                                <td>
                                    <input type="number" name="attr_Weapon1Ammo" value="" class="sheet-numeric-wide" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                        </table>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Secondary Weapon</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon2Name" value="" />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon2HitBonus" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon2Hit" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon2Name}}} {{roll=[[d20+@{Weapon2Hit}@{PhysMod}+@{Weapon2HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header"></th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <th>Damage:</th>
                                <td>
                                    <input type="text" name="attr_Weapon2DmgBonus" value="0" class="sheet-text-centred" />
                                </td>
                                <td>
                                    <input type="text" name="attr_Weapon2Dmg" value="0" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon2Name}}} {{damage=[[(@{Weapon2Dmg}+@{Weapon2DmgBonus}+@{W2DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th>Accessory:</th>
                                <td colspan="2">
                                    <input type="text" name="attr_Weapon2Acc" value="" />
                                </td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Type:</th>
                                <td><select name="attr_W2Type">
                                        <option value="m">Melee</option>
                                        <option value="r">Shooting</option>
                                        <option value="o">Other</option>
                                    </select>
                                </td>
                                <td><input type="hidden" name="attr_W2DmgMod" value="0" /></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Durability:</th>
                                <td>
                                    <input type="text" name="attr_Weapon2Dur" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Weight:</th>
                                <td>
                                    <input type="text" name="attr_Weapon2Wgt" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Ammo:</th>
                                <td>
                                    <input type="number" name="attr_Weapon2Ammo" value="" class="sheet-numeric-wide" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                        </table>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Third Weapon</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon3Name" value="" />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon3HitBonus" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon3Hit" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon3Name}}} {{roll=[[d20+@{Weapon3Hit}@{PhysMod}+@{Weapon3HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header"></th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <th>Damage:</th>
                                <td>
                                    <input type="text" name="attr_Weapon3DmgBonus" value="0" class="sheet-text-centred" />
                                </td>
                                <td>
                                    <input type="text" name="attr_Weapon3Dmg" value="0" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon3Name}}} {{damage=[[(@{Weapon3Dmg}+@{Weapon3DmgBonus}+@{W3DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th>Accessory:</th>
                                <td colspan="2">
                                    <input type="text" name="attr_Weapon3Acc" value="" />
                                </td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Type:</th>
                                <td><select name="attr_W3Type">
                                        <option value="m">Melee</option>
                                        <option value="r">Shooting</option>
                                        <option value="o">Other</option>
                                    </select>
                                </td>
                                <td><input type="hidden" name="attr_W3DmgMod" value="0" /></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Durability:</th>
                                <td>
                                    <input type="text" name="attr_Weapon3Dur" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Weight:</th>
                                <td>
                                    <input type="text" name="attr_Weapon3Wgt" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Ammo:</th>
                                <td>
                                    <input type="number" name="attr_Weapon3Ammo" value="" class="sheet-numeric-wide" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                        </table>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Fourth Weapon</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon4Name" value="" />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon4HitBonus" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon4Hit" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon4Name}}} {{roll=[[d20+@{Weapon4Hit}@{PhysMod}+@{Weapon4HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header"></th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <th>Damage:</th>
                                <td>
                                    <input type="text" name="attr_Weapon4DmgBonus" value="0" class="sheet-text-centred" />
                                </td>
                                <td>
                                    <input type="text" name="attr_Weapon4Dmg" value="0" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon4Name}}} {{damage=[[(@{Weapon4Dmg}+@{Weapon4DmgBonus}+@{W4DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th>Accessory:</th>
                                <td colspan="2">
                                    <input type="text" name="attr_Weapon4Acc" value="" />
                                </td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Type:</th>
                                <td><select name="attr_W4Type">
                                        <option value="m">Melee</option>
                                        <option value="r">Shooting</option>
                                        <option value="o">Other</option>
                                    </select>
                                </td>
                                <td><input type="hidden" name="attr_W4DmgMod" value="0" /></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Durability:</th>
                                <td>
                                    <input type="text" name="attr_Weapon4Dur" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Weight:</th>
                                <td>
                                    <input type="text" name="attr_Weapon4Wgt" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Ammo:</th>
                                <td>
                                    <input type="number" name="attr_Weapon4Ammo" value="" class="sheet-numeric-wide" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                        </table>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Fifth Weapon</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon5Name" value="" />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon5HitBonus" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon5Hit" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon5Name}}} {{roll=[[d20+@{Weapon5Hit}@{PhysMod}+@{Weapon5HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header"></th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <th>Damage:</th>
                                <td>
                                    <input type="text" name="attr_Weapon5DmgBonus" value="0" class="sheet-text-centred" />
                                </td>
                                <td>
                                    <input type="text" name="attr_Weapon5Dmg" value="0" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon5Name}}} {{damage=[[(@{Weapon5Dmg}+@{Weapon5DmgBonus}+@{W5DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th>Accessory:</th>
                                <td colspan="2">
                                    <input type="text" name="attr_Weapon5Acc" value="" />
                                </td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Type:</th>
                                <td><select name="attr_W5Type">
                                        <option value="m">Melee</option>
                                        <option value="r">Shooting</option>
                                        <option value="o">Other</option>
                                    </select>
                                </td>
                                <td><input type="hidden" name="attr_W5DmgMod" value="0" /></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Durability:</th>
                                <td>
                                    <input type="text" name="attr_Weapon5Dur" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Weight:</th>
                                <td>
                                    <input type="text" name="attr_Weapon5Wgt" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Ammo:</th>
                                <td>
                                    <input type="number" name="attr_Weapon5Ammo" value="" class="sheet-numeric-wide" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                        </table>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Sixth Weapon</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon6Name" value="" />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon6HitBonus" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon6Hit" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon6Name}}} {{roll=[[d20+@{Weapon6Hit}@{PhysMod}+@{Weapon6HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header"></th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <th>Damage:</th>
                                <td>
                                    <input type="text" name="attr_Weapon6DmgBonus" value="0" class="sheet-text-centred" />
                                </td>
                                <td>
                                    <input type="text" name="attr_Weapon6Dmg" value="0" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon6Name}}} {{damage=[[(@{Weapon6Dmg}+@{Weapon6DmgBonus}+@{W6DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}">
                                    </button>
                                </td>
                            </tr>
                            <tr>
                                <th>Accessory:</th>
                                <td colspan="2">
                                    <input type="text" name="attr_Weapon6Acc" value="" />
                                </td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Type:</th>
                                <td><select name="attr_W6Type">
                                        <option value="m">Melee</option>
                                        <option value="r">Shooting</option>
                                        <option value="o">Other</option>
                                    </select>
                                </td>
                                <td><input type="hidden" name="attr_W6DmgMod" value="0" /></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Durability:</th>
                                <td>
                                    <input type="text" name="attr_Weapon6Dur" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Weight:</th>
                                <td>
                                    <input type="text" name="attr_Weapon6Wgt" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Ammo:</th>
                                <td>
                                    <input type="number" name="attr_Weapon6Ammo" value="" class="sheet-numeric-wide" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Armor</h1>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Shield</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Slot</th>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">SHP</th>
                                <th class="sheet-small-table-header">Cover</th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Shield</td>
                                <td>
                                    <input type="text" name="attr_ShieldName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ShieldDur" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ShieldCover" value="0" />
                                </td>
                            </tr>
                        </table>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Armor</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Slot</th>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Durability</th>
                                <th class="sheet-small-table-header">Armor Rating</th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Helmet</td>
                                <td>
                                    <input type="text" name="attr_HelmetName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_HelmetDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_HelmetAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Amulet</td>
                                <td>
                                    <input type="text" name="attr_AmuletName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_AmuletDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_AmuletAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Cloak</td>
                                <td>
                                    <input type="text" name="attr_CloakName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_CloakDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_CloakAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Pauldrons</td>
                                <td>
                                    <input type="text" name="attr_PauldronsName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_PauldronsDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_PauldronsAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Clothing</td>
                                <td>
                                    <input type="text" name="attr_ClothingName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_ClothingDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ClothingAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Torso</td>
                                <td>
                                    <input type="text" name="attr_TorsoName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_TorsoDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_TorsoAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Bracers</td>
                                <td>
                                    <input type="text" name="attr_BracersName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_BracersDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BracersAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Gloves</td>
                                <td>
                                    <input type="text" name="attr_GlovesName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_GlovesDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_GlovesAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Belt</td>
                                <td>
                                    <input type="text" name="attr_BeltName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_BeltDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BeltAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Greaves</td>
                                <td>
                                    <input type="text" name="attr_GreavesName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_GreavesDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_GreavesAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Boots</td>
                                <td>
                                    <input type="text" name="attr_BootsName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_BootsDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BootsAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Ring</td>
                                <td>
                                    <input type="text" name="attr_RingName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_RingDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_RingAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Ring</td>
                                <td>
                                    <input type="text" name="attr_Ring2Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Ring2Dur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Ring2AR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Other</td>
                                <td>
                                    <input type="text" name="attr_OtherName" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_OtherDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_OtherAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Other</td>
                                <td>
                                    <input type="text" name="attr_Other2Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Other2Dur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Other2AR" value="0" />
                                </td>
                            </tr>
                        </table>

                        <h1 class="sheet-spacer-top-margin">Valuables</h1>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="3">
                                    <h2>Money</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Type</th>
                                <th class="sheet-small-table-header">Amount</th>
                                <th class="sheet-small-table-header">Worth</th>
                            </tr>
                            <tr>
                                <th>Mertacullum (m)</th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Mertacullum" value="0" />
                                </td>
                                <td class="sheet-text-centred">1m = 20g</td>
                            </tr>
                            <tr>
                                <th>Valcrium (v)</th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Mertacullum" value="0" />
                                </td>
                                <td class="sheet-text-centred">1v = 12g</td>
                            </tr>
                            <tr>
                                <th>Gold (g)</th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Gold" value="0" />
                                </td>
                                <td class="sheet-text-centred">1g = 4s</td>
                            </tr>
                            <tr>
                                <th>Silver (s)</th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Silver" value="0" />
                                </td>
                                <td class="sheet-text-centred">1s = 5c</td>
                            </tr>
                            <tr>
                                <th>Copper (c)</th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Copper" value="0" />
                                </td>
                                <td class="sheet-text-centred">1c = 5b</td>
                            </tr>
                            <tr>
                                <th>Bones (b or p)</th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Bones" value="0" />
                                </td>
                                <td></td>
                            </tr>
                        </table>

                        <textarea name="attr_MiscMoney" placeholder="Other (e.g. gems)" class="sheet-textarea-gems"></textarea>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Equipment</h1>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="2">
                                    <h2>Equipment (Belt)</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Amount</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt1Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt1Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt2Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt2Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt3Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt3Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt4Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt4Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt5Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt5Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt6Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt6Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt7Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt7Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt8Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt8Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt9Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt9Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt10Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt10Amt" value="0" />
                                </td>
                            </tr>
                        </table>


                        <h2 class="sheet-spacer-top-margin">Equipment (Backpack)</h2>

                        <fieldset class="repeating_equip">
                            <table class="sheet-repeating-section">
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header">Amount</th>
                                    <th class="sheet-small-table-header">Weight</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_EquipName" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_EquipAmt" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric-readonly">
                                        <input type="text" name="attr_EquipWgt" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header" colspan="3">Notes</th>
                                </tr>
                                <tr>
                                    <td colspan="3">
                                        <input type="text" name="attr_EquipNotes" value="" />
                                    </td>
                                </tr>
                            </table>
                        </fieldset>

                        <textarea name="attr_MiscEquipment" placeholder="Other (e.g. stored)" class="sheet-textarea-equipment"></textarea>


                        <h2 class="sheet-spacer-top-margin">Transportation</h2>

                        <fieldset class="repeating_trans">
                            <table class="sheet-repeating-section">
                                <tr>
                                    <th class="sheet-small-table-header">Type</th>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header">Speed</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_TransType" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_TransName" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_TransSpd" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header" colspan="3">Accessories</th>
                                </tr>
                                <tr>
                                    <td valign="center" colspan="3">
                                        <textarea class="sheet-text-area-full" name="attr_TransAcc" value=""></textarea>
                                    </td>
                                </tr>
                            </table>
                        </fieldset>

                        <h1 class="sheet-spacer-top-margin">Other</h1>

                        <h2 class="sheet-spacer-top-margin">Hideouts</h2>

                        <fieldset class="repeating_hideouts">
                            <table class="sheet-repeating-section">
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header">Income</th>
                                    <th class="sheet-small-table-header">Upkeep</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_HideoutName" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_HideoutIncome" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_HideoutUpkeep" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header" colspan="3">Notes</th>
                                </tr>
                                <tr>
                                    <td valign="center" colspan="3">
                                        <textarea class="sheet-text-area-full" name="attr_HideoutNotes" value=""></textarea>
                                    </td>
                                </tr>
                            </table>
                        </fieldset>
                    </div>
                </div>
            </div>



            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
            ---------------------------------------------------------------------  Mystic Tab  ----------------------------------------------------------------------
            ------------------------------------------------------------------------------------------------------------------------------------------------------ -->
            <div class="sheet-section-mystic">

                <h1 class="sheet-spacer-top-margin">Religion</h1>

                <div class="sheet-flex-section">

                    <div class="sheet-column-grow">

                        <div class="sheet-religion-table">
                            <h2>Details</h2>

                            <table>
                                <tr>
                                    <td class="sheet-skillname">Soul Points</td>
                                    <td>
                                        <input type="number" name="attr_SoulPoints" value="0" class="sheet-numeric-wide" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-skillname">Path</td>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_ReligionPath" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-skillname" rowspan="3">Gods</td>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_Gods1" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_Gods2" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_Gods3" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-skillname">Spirit Animal</td>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_SpiritAnimal" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-skillname">Astrological Sign</td>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_AstSign" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-skillname">Fate Power</td>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_FatePower" value="" />
                                    </td>
                                </tr>
                            </table>
                        </div>
                    </div>

                    <div class="sheet-column-grow">
                        <h2 class="sheet-spiritual-influence-header">Spiritual Influence</h2>

                        <div class="sheet-centred-section">
                            <div class="sheet-spiritual-influence-image">
                                <input type="hidden" name="attr_ClassSI" value="2" />
                                <input type="number" class="sheet-spiritual-influence" name="attr_SpiritInf" value="2" />
                            </div>

                            <button type="roll"
                                value="&{template:percentile} [[ [[1d100 + ?{Modifier|0}]] - @{SpiritInf}]] ]] {{name=Spiritual Influence Check}} {{roll=$[[0]]}} {{target=@{SpiritInf}}} {{difference=$[[1]]}}">
                                Roll Spiritual Influence
                            </button>
                        </div>
                    </div>
                </div>


                <h1 class="sheet-spacer-top-margin">Spells</h1>

                <div class="sheet-collapse-wrapper">
                    <h2 class="sheet-table-header-collapse">Attack Spells</h2>
                    <div class="sheet-collapse-section">
                        <input type="checkbox" name="attr_AttackSpellsExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                        <span class="sheet-expand-collapse-symbol"></span>
                        <div class="sheet-collapsible">

                            <table>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell1Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell1Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell1Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell1Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell1Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_Spell1Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell1Name}}} {{area=@{Spell1Area}}} {{duration=@{Spell1Dur}}} {{protection=@{Spell1Prot}}} {{actions=@{Spell1Act}}} {{drain=@{Spell1Drain}}} {{description=@{Spell1Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell1Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell1HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell1Name}}} {{character=@{character_name}}} {{area=@{Spell1Area}}} {{duration=@{Spell1Dur}}} {{actions=@{Spell1Act}}} {{drain=@{Spell1Drain}}} {{roll=[[d20+@{Spell1HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell1Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell1Name}}} {{character=@{character_name}}} {{protection=@{Spell1Prot}}} {{roll=[[(@{Spell1Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell2Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell2Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell2Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell2Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell2Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_Spell2Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell2Name}}} {{area=@{Spell2Area}}} {{duration=@{Spell2Dur}}} {{protection=@{Spell2Prot}}} {{actions=@{Spell2Act}}} {{drain=@{Spell2Drain}}} {{description=@{Spell2Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell2Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell2HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell2Name}}} {{character=@{character_name}}} {{area=@{Spell2Area}}} {{duration=@{Spell2Dur}}} {{actions=@{Spell2Act}}} {{drain=@{Spell2Drain}}} {{roll=[[d20+@{Spell2HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell2Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell2Name}}} {{character=@{character_name}}} {{protection=@{Spell2Prot}}} {{roll=[[(@{Spell2Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell3Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell3Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell3Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell3Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell3Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_Spell3Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell3Name}}} {{area=@{Spell3Area}}} {{duration=@{Spell3Dur}}} {{protection=@{Spell3Prot}}} {{actions=@{Spell3Act}}} {{drain=@{Spell3Drain}}} {{description=@{Spell3Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell3Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell3HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell3Name}}} {{character=@{character_name}}} {{area=@{Spell3Area}}} {{duration=@{Spell3Dur}}} {{actions=@{Spell3Act}}} {{drain=@{Spell3Drain}}} {{roll=[[d20+@{Spell3HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell3Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell3Name}}} {{character=@{character_name}}} {{protection=@{Spell3Prot}}} {{roll=[[(@{Spell3Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell4Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell4Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell4Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell4Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell4Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_Spell4Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell4Name}}} {{area=@{Spell4Area}}} {{duration=@{Spell4Dur}}} {{protection=@{Spell4Prot}}} {{actions=@{Spell4Act}}} {{drain=@{Spell4Drain}}} {{description=@{Spell4Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell4Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell4HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell4Name}}} {{character=@{character_name}}} {{area=@{Spell4Area}}} {{duration=@{Spell4Dur}}} {{actions=@{Spell4Act}}} {{drain=@{Spell4Drain}}} {{roll=[[d20+@{Spell4HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell4Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell4Name}}} {{character=@{character_name}}} {{protection=@{Spell4Prot}}} {{roll=[[(@{Spell4Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell5Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell5Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell5Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell5Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell5Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_Spell5Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell5Name}}} {{area=@{Spell5Area}}} {{duration=@{Spell5Dur}}} {{protection=@{Spell5Prot}}} {{actions=@{Spell5Act}}} {{drain=@{Spell5Drain}}} {{description=@{Spell5Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell5Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell5HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell5Name}}} {{character=@{character_name}}} {{area=@{Spell5Area}}} {{duration=@{Spell5Dur}}} {{actions=@{Spell5Act}}} {{drain=@{Spell5Drain}}} {{roll=[[d20+@{Spell5HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell5Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell5Name}}} {{character=@{character_name}}} {{protection=@{Spell5Prot}}} {{roll=[[(@{Spell5Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell6Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell6Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell6Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell6Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell6Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_Spell6Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell6Name}}} {{area=@{Spell6Area}}} {{duration=@{Spell6Dur}}} {{protection=@{Spell6Prot}}} {{actions=@{Spell6Act}}} {{drain=@{Spell6Drain}}} {{description=@{Spell6Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell6Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell6HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell6Name}}} {{character=@{character_name}}} {{area=@{Spell6Area}}} {{duration=@{Spell6Dur}}} {{actions=@{Spell6Act}}} {{drain=@{Spell6Drain}}} {{roll=[[d20+@{Spell6HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell6Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell6Name}}} {{character=@{character_name}}} {{protection=@{Spell6Prot}}} {{roll=[[(@{Spell6Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell7Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell7Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell7Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell7Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell7Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_Spell7Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell7Name}}} {{area=@{Spell7Area}}} {{duration=@{Spell7Dur}}} {{protection=@{Spell7Prot}}} {{actions=@{Spell7Act}}} {{drain=@{Spell7Drain}}} {{description=@{Spell7Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell7Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell7HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell7Name}}} {{character=@{character_name}}} {{area=@{Spell7Area}}} {{duration=@{Spell7Dur}}} {{actions=@{Spell7Act}}} {{drain=@{Spell7Drain}}} {{roll=[[d20+@{Spell7HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell7Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell7Name}}} {{character=@{character_name}}} {{protection=@{Spell7Prot}}} {{roll=[[(@{Spell7Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell8Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell8Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell8Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell8Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell8Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_Spell8Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell8Name}}} {{area=@{Spell8Area}}} {{duration=@{Spell8Dur}}} {{protection=@{Spell8Prot}}} {{actions=@{Spell8Act}}} {{drain=@{Spell8Drain}}} {{description=@{Spell8Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell8Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell8HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell8Name}}} {{character=@{character_name}}} {{area=@{Spell8Area}}} {{duration=@{Spell8Dur}}} {{actions=@{Spell8Act}}} {{drain=@{Spell8Drain}}} {{roll=[[d20+@{Spell8HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell8Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell8Name}}} {{character=@{character_name}}} {{protection=@{Spell8Prot}}} {{roll=[[(@{Spell8Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell9Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell9Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell9Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell9Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell9Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_Spell9Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell9Name}}} {{area=@{Spell9Area}}} {{duration=@{Spell9Dur}}} {{protection=@{Spell9Prot}}} {{actions=@{Spell9Act}}} {{drain=@{Spell9Drain}}} {{description=@{Spell9Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell9Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell9HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell9Name}}} {{character=@{character_name}}} {{area=@{Spell9Area}}} {{duration=@{Spell9Dur}}} {{actions=@{Spell9Act}}} {{drain=@{Spell9Drain}}} {{roll=[[d20+@{Spell9HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell9Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell9Name}}} {{character=@{character_name}}} {{protection=@{Spell9Prot}}} {{roll=[[(@{Spell9Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell10Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell10Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell10Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell10Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell10Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_Spell10Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell10Name}}} {{area=@{Spell10Area}}} {{duration=@{Spell10Dur}}} {{protection=@{Spell10Prot}}} {{actions=@{Spell10Act}}} {{drain=@{Spell10Drain}}} {{description=@{Spell10Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell10Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell10HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell10Name}}} {{character=@{character_name}}} {{area=@{Spell10Area}}} {{duration=@{Spell10Dur}}} {{actions=@{Spell10Act}}} {{drain=@{Spell10Drain}}} {{roll=[[d20+@{Spell10HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell10Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell10Name}}} {{character=@{character_name}}} {{protection=@{Spell10Prot}}} {{roll=[[(@{Spell10Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                            </table>
                        </div>
                    </div>
                </div>

                <div class="sheet-collapse-wrapper">
                    <h2 class="sheet-table-header-collapse">Non-Combat Spells</h2>
                    <div class="sheet-collapse-section">
                        <input type="checkbox" name="attr_NonCombatSpellsExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                        <span class="sheet-expand-collapse-symbol"></span>
                        <div class="sheet-collapsible">

                            <table>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell1Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell1Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell1Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell1Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell1Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_NCSpell1Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell1Name}}} {{area=@{NCSpell1Area}}} {{duration=@{NCSpell1Dur}}} {{protection=@{NCSpell1Prot}}} {{actions=@{NCSpell1Act}}} {{drain=@{NCSpell1Drain}}} {{description=@{NCSpell1Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell1Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell1HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell1Name}}} {{character=@{character_name}}} {{area=@{NCSpell1Area}}} {{duration=@{NCSpell1Dur}}} {{actions=@{NCSpell1Act}}} {{drain=@{NCSpell1Drain}}} {{roll=[[d20+@{NCSpell1HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell1Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell1Name}}} {{character=@{character_name}}} {{protection=@{NCSpell1Prot}}} {{roll=[[(@{NCSpell1Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell2Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell2Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell2Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell2Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell2Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_NCSpell2Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell2Name}}} {{area=@{NCSpell2Area}}} {{duration=@{NCSpell2Dur}}} {{protection=@{NCSpell2Prot}}} {{actions=@{NCSpell2Act}}} {{drain=@{NCSpell2Drain}}} {{description=@{NCSpell2Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell2Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell2HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell2Name}}} {{character=@{character_name}}} {{area=@{NCSpell2Area}}} {{duration=@{NCSpell2Dur}}} {{actions=@{NCSpell2Act}}} {{drain=@{NCSpell2Drain}}} {{roll=[[d20+@{NCSpell2HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell2Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell2Name}}} {{character=@{character_name}}} {{protection=@{NCSpell2Prot}}} {{roll=[[(@{NCSpell2Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell3Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell3Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell3Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell3Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell3Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_NCSpell3Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell3Name}}} {{area=@{NCSpell3Area}}} {{duration=@{NCSpell3Dur}}} {{protection=@{NCSpell3Prot}}} {{actions=@{NCSpell3Act}}} {{drain=@{NCSpell3Drain}}} {{description=@{NCSpell3Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell3Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell3HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell3Name}}} {{character=@{character_name}}} {{area=@{NCSpell3Area}}} {{duration=@{NCSpell3Dur}}} {{actions=@{NCSpell3Act}}} {{drain=@{NCSpell3Drain}}} {{roll=[[d20+@{NCSpell3HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell3Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell3Name}}} {{character=@{character_name}}} {{protection=@{NCSpell3Prot}}} {{roll=[[(@{NCSpell3Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell4Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell4Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell4Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell4Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell4Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_NCSpell4Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell4Name}}} {{area=@{NCSpell4Area}}} {{duration=@{NCSpell4Dur}}} {{protection=@{NCSpell4Prot}}} {{actions=@{NCSpell4Act}}} {{drain=@{NCSpell4Drain}}} {{description=@{NCSpell4Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell4Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell4HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell4Name}}} {{character=@{character_name}}} {{area=@{NCSpell4Area}}} {{duration=@{NCSpell4Dur}}} {{actions=@{NCSpell4Act}}} {{drain=@{NCSpell4Drain}}} {{roll=[[d20+@{NCSpell4HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell4Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell4Name}}} {{character=@{character_name}}} {{protection=@{NCSpell4Prot}}} {{roll=[[(@{NCSpell4Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell5Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell5Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell5Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell5Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell5Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_NCSpell5Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell5Name}}} {{area=@{NCSpell5Area}}} {{duration=@{NCSpell5Dur}}} {{protection=@{NCSpell5Prot}}} {{actions=@{NCSpell5Act}}} {{drain=@{NCSpell5Drain}}} {{description=@{NCSpell5Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell5Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell5HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell5Name}}} {{character=@{character_name}}} {{area=@{NCSpell5Area}}} {{duration=@{NCSpell5Dur}}} {{actions=@{NCSpell5Act}}} {{drain=@{NCSpell5Drain}}} {{roll=[[d20+@{NCSpell5HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell5Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell5Name}}} {{character=@{character_name}}} {{protection=@{NCSpell5Prot}}} {{roll=[[(@{NCSpell5Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell6Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell6Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell6Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell6Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell6Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_NCSpell6Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell6Name}}} {{area=@{NCSpell6Area}}} {{duration=@{NCSpell6Dur}}} {{protection=@{NCSpell6Prot}}} {{actions=@{NCSpell6Act}}} {{drain=@{NCSpell6Drain}}} {{description=@{NCSpell6Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell6Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell6HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell6Name}}} {{character=@{character_name}}} {{area=@{NCSpell6Area}}} {{duration=@{NCSpell6Dur}}} {{actions=@{NCSpell6Act}}} {{drain=@{NCSpell6Drain}}} {{roll=[[d20+@{NCSpell6HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell6Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell6Name}}} {{character=@{character_name}}} {{protection=@{NCSpell6Prot}}} {{roll=[[(@{NCSpell6Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell7Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell7Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell7Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell7Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell7Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_NCSpell7Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell7Name}}} {{area=@{NCSpell7Area}}} {{duration=@{NCSpell7Dur}}} {{protection=@{NCSpell7Prot}}} {{actions=@{NCSpell7Act}}} {{drain=@{NCSpell7Drain}}} {{description=@{NCSpell7Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell7Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell7HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell7Name}}} {{character=@{character_name}}} {{area=@{NCSpell7Area}}} {{duration=@{NCSpell7Dur}}} {{actions=@{NCSpell7Act}}} {{drain=@{NCSpell7Drain}}} {{roll=[[d20+@{NCSpell7HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell7Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell7Name}}} {{character=@{character_name}}} {{protection=@{NCSpell7Prot}}} {{roll=[[(@{NCSpell7Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell8Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell8Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell8Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell8Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell8Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_NCSpell8Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell8Name}}} {{area=@{NCSpell8Area}}} {{duration=@{NCSpell8Dur}}} {{protection=@{NCSpell8Prot}}} {{actions=@{NCSpell8Act}}} {{drain=@{NCSpell8Drain}}} {{description=@{NCSpell8Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell8Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell8HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell8Name}}} {{character=@{character_name}}} {{area=@{NCSpell8Area}}} {{duration=@{NCSpell8Dur}}} {{actions=@{NCSpell8Act}}} {{drain=@{NCSpell8Drain}}} {{roll=[[d20+@{NCSpell8HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell8Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell8Name}}} {{character=@{character_name}}} {{protection=@{NCSpell8Prot}}} {{roll=[[(@{NCSpell8Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell9Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell9Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell9Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell9Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell9Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_NCSpell9Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell9Name}}} {{area=@{NCSpell9Area}}} {{duration=@{NCSpell9Dur}}} {{protection=@{NCSpell9Prot}}} {{actions=@{NCSpell9Act}}} {{drain=@{NCSpell9Drain}}} {{description=@{NCSpell9Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell9Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell9HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell9Name}}} {{character=@{character_name}}} {{area=@{NCSpell9Area}}} {{duration=@{NCSpell9Dur}}} {{actions=@{NCSpell9Act}}} {{drain=@{NCSpell9Drain}}} {{roll=[[d20+@{NCSpell9HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell9Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell9Name}}} {{character=@{character_name}}} {{protection=@{NCSpell9Prot}}} {{roll=[[(@{NCSpell9Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell10Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell10Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell10Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell10Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell10Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea class="sheet-spell-description" name="attr_NCSpell10Desc" value=""></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button type="roll" class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell10Name}}} {{area=@{NCSpell10Area}}} {{duration=@{NCSpell10Dur}}} {{protection=@{NCSpell10Prot}}} {{actions=@{NCSpell10Act}}} {{drain=@{NCSpell10Drain}}} {{description=@{NCSpell10Desc}}}">
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell10Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell10HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell10Name}}} {{character=@{character_name}}} {{area=@{NCSpell10Area}}} {{duration=@{NCSpell10Dur}}} {{actions=@{NCSpell10Act}}} {{drain=@{NCSpell10Drain}}} {{roll=[[d20+@{NCSpell10HitMod}@{MenMod}+?{Modifier|0}]]}}">
                                        </button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell10Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell10Name}}} {{character=@{character_name}}} {{protection=@{NCSpell10Prot}}} {{roll=[[(@{NCSpell10Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                        </button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                            </table>
                        </div>
                    </div>
                </div>
                
                <div class="sheet-collapse-wrapper">
                    <h2 class="sheet-table-header-collapse">Additional Spells</h2>
                    <div class="sheet-collapse-section">
                        <input type="checkbox" name="attr_AdditionalSpellsExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                        <span class="sheet-expand-collapse-symbol"></span>
                        <div class="sheet-collapsible">

                            <fieldset class="repeating_spells">
                                <table>
                                    <tr>
                                        <th class="sheet-small-table-header">Name</th>
                                        <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                        <th class="sheet-small-table-header" colspan="2">Duration</th>
                                        <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                        <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                        <th class="sheet-small-table-header">Description</th>
                                    </tr>
                                    <tr>
                                        <td>
                                            <input type="text" name="attr_SpellName" value="" />
                                        </td>
                                        <td>
                                            <input type="text" name="attr_SpellArea" value="" />
                                        </td>
                                        <td colspan="2">
                                            <input type="text" name="attr_SpellDur" value="" />
                                        </td>
                                        <td>
                                            <input type="text" name="attr_SpellProt" value="" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_SpellAct" value="0" />
                                        </td>
                                        <td rowspan="4">
                                            <textarea class="sheet-spell-description" name="attr_SpellDesc" value=""></textarea>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td rowspan="3" class="sheet-button-cell">
                                            <button type="roll" class="sheet-display-text-button"
                                                value="&{template:spell-description} {{name=@{SpellName}}} {{area=@{SpellArea}}} {{duration=@{SpellDur}}} {{protection=@{SpellProt}}} {{actions=@{SpellAct}}} {{drain=@{SpellDrain}}} {{description=@{SpellDesc}}}">
                                                Display Info
                                            </button>
                                        </td>
                                        <th class="sheet-small-table-header">Drain</th>
                                        <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                        <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                        <th class="sheet-small-table-header">Effect</th>
                                        <th class="sheet-small-table-header">Roll</th>
                                    </tr>
                                    <tr>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_SpellDrain" value="0" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_SpellHitMod" value="0" />
                                        </td>
                                        <td rowspan="2" class="sheet-button-cell">
                                            <button type="roll"
                                                value="&{template:spell-cast} {{name=@{SpellName}}} {{character=@{character_name}}} {{area=@{SpellArea}}} {{duration=@{SpellDur}}} {{actions=@{SpellAct}}} {{drain=@{SpellDrain}}} {{roll=[[d20+@{SpellHitMod}@{MenMod}+?{Modifier|0}]]}}">
                                            </button>
                                        </td>
                                        <td>
                                            <input type="text" name="attr_SpellDmg" value="" />
                                        </td>
                                        <td rowspan="2" class="sheet-button-cell">
                                            <button type="roll"
                                                value="&{template:spell-effect} {{name=@{SpellName}}} {{character=@{character_name}}} {{protection=@{SpellProt}}} {{roll=[[(@{SpellDmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}">
                                            </button>
                                        </td>
                                    </tr>
                                    <tr class="sheet-spell-padding-row"></tr>
                                    <tr class="sheet-spell-spacer-row">
                                        <td colspan="7"></td>
                                    </tr>
                                </table>
                            </fieldset>
                        </div>
                    </div>
                </div>

                <h1 class="sheet-spacer-top-margin">Chi Abilities</h1>

                <div class="sheet-collapse-wrapper">
                    <h2 class="sheet-table-header-collapse">Abilities</h2>
                    <div class="sheet-collapse-section">
                        <input type="checkbox" name="attr_ChiAbilitiesExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                        <span class="sheet-expand-collapse-symbol"></span>
                        <div class="sheet-collapsible">
                            <fieldset class="repeating_chiabilities">
                                <table>
                                    <tr>
                                        <th class="sheet-small-table-header">Name</th>
                                        <th class="sheet-small-table-header">Rating</th>
                                        <th class="sheet-small-table-header">Drain</th>
                                        <th class="sheet-small-table-header">Description</th>
                                    </tr>
                                    <tr>
                                        <td>
                                            <input type="text" name="attr_ChiAbilityName" value="" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_ChiAbilityRating" value="1" />
                                        </td>
                                        <td>
                                            <input type="text" name="attr_ChiAbilityDrain" value="" />
                                        </td>
                                        <td rowspan="3">
                                            <textarea class="sheet-chi-ability-description" name="attr_ChiAbilityDesc" value=""></textarea>
                                        </td>
                                    </tr>
                                    <tr class="sheet-spell-padding-row"></tr>
                                    <tr class="sheet-spell-padding-row"></tr>
                                    <tr class="sheet-spell-spacer-row">
                                        <td colspan="4"></td>
                                    </tr>
                                </table>
                            </fieldset>
                        </div>
                    </div>
                </div>

                <h1 class="sheet-spacer-top-margin">Alchemical Formulae</h1>

                <div class="sheet-collapse-wrapper">
                    <h2 class="sheet-table-header-collapse">Formulae</h2>
                    <div class="sheet-collapse-section">
                        <input type="checkbox" name="attr_AlchemicalFormulaeExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                        <span class="sheet-expand-collapse-symbol"></span>
                        <div class="sheet-collapsible">
                            <fieldset class="repeating_alchemical">
                                <table>
                                    <tr>
                                        <th class="sheet-small-table-header">Item</th>
                                        <th class="sheet-small-table-header">Ingredients Necessary</th>
                                        <th class="sheet-small-table-header">Units Harvested</th>
                                    </tr>
                                    <tr>
                                        <td>
                                            <input type="text" name="attr_FormulaName" value="" />
                                        </td>
                                        <td>
                                            <input type="text" name="attr_FormulaIngr" value="" />
                                        </td>
                                        <td>
                                            <input type="text" name="attr_FormulaHarv" value="" />
                                        </td>
                                    </tr>
                                </table>
                            </fieldset>
                        </div>
                    </div>
                </div>

            </div>



            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
            --------------------------------------------------------------------  Abilities Tab  --------------------------------------------------------------------
            ------------------------------------------------------------------------------------------------------------------------------------------------------ -->
            <div class="sheet-section-abilities">
                <div class="sheet-flex-section">
                    <div class="sheet-column-grow">
                        <h1>Traits</h1>

                        <fieldset class="repeating_traits">
                            <div class="sheet-repeating-section">
                                <div class="sheet-flex-form-container">
                                    <div class="sheet-flex-form-grow">
                                        <input type="text" name="attr_TraitName" value="" class="sheet-tall-control" placeholder="Name of trait" />
                                    </div>
                                    <div class="sheet-flex-form-fixed sheet-tall-control">
                                        <button type="roll" class="sheet-display-text-button-small" value="&{template:text} {{character=@{character_name}}} {{title=@{TraitName}}} {{text=@{TraitDesc}}}">
                                            Display in Chat
                                        </button>
                                    </div>
                                </div>
                                <div>
                                    <input type="checkbox" name="attr_TraitExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                                    <span class="sheet-expand-collapse-symbol"></span>
                                    <textarea class="sheet-text-area-full sheet-collapsible" name="attr_TraitDesc" value="" placeholder="Description of trait"></textarea>
                                </div>
                            </div>
                        </fieldset>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Racial Abilities</h1>

                        <div class="sheet-repeating-section">
                            <div class="sheet-flex-form-container">
                                <div class="sheet-flex-form-grow">
                                    <div class="sheet-input-wide sheet-tall-control sheet-input-like">Vision</div>
                                </div>
                                <div class="sheet-flex-form-fixed sheet-tall-control">
                                    <button type="roll" class="sheet-display-text-button-small" value="&{template:text} {{character=@{character_name}}} {{title=Vision}} {{text=@{Vision}}}">
                                        Display in Chat
                                    </button>
                                </div>
                            </div>
                            <div>
                                <input type="checkbox" name="attr_VisionExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <textarea class="sheet-text-area-full sheet-collapsible" name="attr_Vision" value=""
                                    placeholder="Description of type of vision"></textarea>
                            </div>
                        </div>

                        <fieldset class="repeating_raceabilities">
                            <div class="sheet-repeating-section">
                                <div class="sheet-flex-form-container">
                                    <div class="sheet-flex-form-grow">
                                        <input type="text" name="attr_RaceAbilName" value="" class="sheet-tall-control" placeholder="Name of racial ability" />
                                    </div>
                                    <div class="sheet-flex-form-fixed sheet-tall-control">
                                        <button type="roll" class="sheet-display-text-button-small"
                                            value="&{template:text} {{character=@{character_name}}} {{title=@{RaceAbilName}}} {{text=@{RaceAbilDesc}}}">
                                            Display in Chat
                                        </button>
                                    </div>
                                </div>
                                <div>
                                    <input type="checkbox" name="attr_RaceAbilExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                                    <span class="sheet-expand-collapse-symbol"></span>
                                    <textarea class="sheet-text-area-full sheet-collapsible" name="attr_RaceAbilDesc" value=""
                                        placeholder="Description of racial ability"></textarea>
                                </div>
                            </div>
                        </fieldset>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Talents</h1>
                        <fieldset class="repeating_talents">
                            <div class="sheet-repeating-section">
                                <div class="sheet-flex-form-container">
                                    <div class="sheet-flex-form-grow">
                                        <input type="text" name="attr_TalentName" value="" class="sheet-tall-control" placeholder="Name of talent" />
                                    </div>
                                    <div class="sheet-flex-form-fixed sheet-tall-control">
                                        <button type="roll" class="sheet-display-text-button-small"
                                            value="&{template:text} {{character=@{character_name}}} {{title=@{TalentName}}} {{text=@{TalentDesc}}}">
                                            Display in Chat
                                        </button>
                                    </div>
                                </div>
                                <div>
                                    <input type="checkbox" name="attr_TalentExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                                    <span class="sheet-expand-collapse-symbol"></span>
                                    <textarea class="sheet-text-area-full sheet-collapsible" name="attr_TalentDesc" value=""
                                        placeholder="Description of talent"></textarea>
                                </div>
                            </div>
                        </fieldset>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Class Abilities</h1>

                        <fieldset class="repeating_classabilities">
                            <div class="sheet-repeating-section">
                                <div class="sheet-flex-form-container">
                                    <div class="sheet-flex-form-grow">
                                        <input type="text" name="attr_ClassAbilName" value="" class="sheet-tall-control" placeholder="Name of class ability" />
                                    </div>
                                    <div class="sheet-flex-form-fixed sheet-tall-control">
                                        <button type="roll" class="sheet-display-text-button-small"
                                            value="&{template:class-ability-text} {{name=@{ClassAbilName}}} {{character=@{character_name}}} {{rating=@{ClassAbilRating}}} {{maxRating=@{ClassAbilMaxRating}}} {{power=@{ClassAbilPower}}} {{description=@{ClassAbilDesc}}}">
                                            Display in Chat
                                        </button>
                                    </div>
                                </div>
                                <div>
                                    <input type="checkbox" name="attr_ClassAbilExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                                    <span class="sheet-expand-collapse-symbol"></span>
                                    <div class="sheet-collapsible">
                                        <table class="sheet-embedded-table">
                                            <tr>
                                                <th>Rating</th>
                                                <td class="sheet-cell-numeric">
                                                    <input type="number" name="attr_ClassAbilRating" value="1" />
                                                </td>
                                                <th>Max. Rating</th>
                                                <td class="sheet-cell-numeric">
                                                    <input type="number" name="attr_ClassAbilMaxRating" value="1" />
                                                </td>
                                                <th>Power</th>
                                                <td class="sheet-cell-numeric">
                                                    <input type="number" name="attr_ClassAbilPower" value="1" />
                                                </td>
                                            </tr>
                                        </table>
                                        <textarea name="attr_ClassAbilDesc" value="" class="sheet-text-area-full" placeholder="Description of class ability" />
                                        </div>
                                </div>
                            </div>
                        </fieldset>
                    </div>
                </div>

            </div>



            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
            -------------------------------------------------------------------  Reputation Tab  --------------------------------------------------------------------
            ------------------------------------------------------------------------------------------------------------------------------------------------------ -->
            <div class="sheet-section-reputation">

                <div class="sheet-flex-section">
                    <div class="sheet-column-grow">
                        <h1 class="sheet-remove-margin-bottom">Reputation</h1>

                        <div class="sheet-flex-section">
                            <div class="sheet-column-grow">
                                <h2>Honor (Good Reputation)</h2>
                                <table>
                                    <tr>
                                        <td class="sheet-skillname">Honor</td>
                                        <td>
                                            <input type="number" name="attr_HonorRep" value="0" class="sheet-numeric-wide" />
                                        </td>
                                    </tr>
                                    <tr>
                                        <td class="sheet-skillname">Title</td>
                                        <td class="sheet-read-only-field">
                                            <input type="text" name="attr_HonorTitle" value="Unknown" readonly class="sheet-text-centred" />
                                        </td>
                                    </tr>
                                </table>

                                <div class="sheet-collapse-wrapper">
                                    <h2 class="sheet-table-header-collapse">Good Renown</h2>
                                    <div class="sheet-collapse-section">
                                        <input type="checkbox" name="attr_GoodRenownExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                                        <span class="sheet-expand-collapse-symbol"></span>
                                        <div class="sheet-collapsible">
                                            <fieldset class="repeating_honorrep">
                                                <table>
                                                    <tr>
                                                        <th class="sheet-small-table-header">Location</th>
                                                        <th class="sheet-small-table-header">Amount</th>
                                                    </tr>
                                                    <tr>
                                                        <td>
                                                            <input type="text" name="attr_HonorRepName" value="" />
                                                        </td>
                                                        <td class="sheet-cell-numeric">
                                                            <input type="number" name="attr_HonorRepAmt" value="0" />
                                                        </td>
                                                    </tr>
                                                </table>
                                            </fieldset>
                                        </div>
                                    </div>
                                </div>

                            </div>

                            <div class="sheet-column-grow">
                                <h2>Corruption (Bad Reputation)</h2>
                                <table>
                                    <tr>
                                        <td class="sheet-skillname">Corruption</td>
                                        <td>
                                            <input type="number" name="attr_CorruptRep" value="0" class="sheet-numeric-wide" />
                                        </td>
                                    </tr>
                                    <tr>
                                        <td class="sheet-skillname">Title</td>
                                        <td class="sheet-read-only-field">
                                            <input type="text" name="attr_CorruptionTitle" value="Unknown" readonly class="sheet-text-centred" />
                                        </td>
                                    </tr>
                                </table>

                                <div class="sheet-collapse-wrapper">
                                    <h2 class="sheet-table-header-collapse">Bad Renown</h2>
                                    <div class="sheet-collapse-section">
                                        <input type="checkbox" name="attr_BadRenownExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                                        <span class="sheet-expand-collapse-symbol"></span>
                                        <div class="sheet-collapsible">
                                            <fieldset class="repeating_corruptrep">
                                                <table>
                                                    <tr>
                                                        <th class="sheet-small-table-header">Location</th>
                                                        <th class="sheet-small-table-header">Amount</th>
                                                    </tr>
                                                    <tr>
                                                        <td>
                                                            <input type="text" name="attr_CorruptRepName" value="" />
                                                        </td>
                                                        <td class="sheet-cell-numeric">
                                                            <input type="number" name="attr_CorruptRepAmt" value="0" />
                                                        </td>
                                                    </tr>
                                                </table>
                                            </fieldset>
                                        </div>
                                    </div>
                                </div>
                            </div>

                            <div class="sheet-column-grow">
                                <h2>Total Reputation</h2>
                                <table>
                                    <tr>
                                        <td class="sheet-skillname">Total Reputation</td>
                                        <td class="sheet-read-only-field">
                                            <input type="text" name="attr_TotalReputation" value="0" readonly class="sheet-text-centred" />
                                        </td>
                                    </tr>
                                    <tr>
                                        <td class="sheet-skillname">Next Tier</td>
                                        <td class="sheet-read-only-field">
                                            <input type="text" name="attr_TotalReputationForNextLevel" value="0" readonly class="sheet-text-centred" />
                                        </td>
                                    </tr>
                                    <tr>
                                        <td class="sheet-skillname">Additional Talents</td>
                                        <td class="sheet-cell-numeric-readonly">
                                            <input type="number" name="attr_ReputationTalents" value="0" readonly />
                                        </td>
                                    </tr>
                                    <tr>
                                        <td class="sheet-skillname">Glory</td>
                                        <td class="sheet-cell-numeric-readonly">
                                            <input type="number" name="attr_Glory" value="0" readonly />%
                                        </td>
                                    </tr>
                                </table>

                                <div class="sheet-centred-section sheet-vertical-margin-moderate">
                                    <button type="roll"
                                        value="&{template:percentile} [[ [[1d100 + ?{Modifier|0}]] - @{Glory}]] ]] {{name=Glory Check}} {{roll=$[[0]]}} {{target=@{Glory}}} {{difference=$[[1]]}}">
                                        Roll Glory Check
                                    </button>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Known Characters</h1>

                        <div class="sheet-spacer-top-margin">
                            <fieldset class="repeating_knownchars">
                                <table>
                                    <tr>
                                        <th class="sheet-small-table-header">Name</th>
                                        <th class="sheet-small-table-header">Rank</th>
                                    </tr>
                                    <tr>
                                        <td>
                                            <input type="text" name="attr_KnownCharName" value="" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_KnownCharRank" value="0" />
                                        </td>
                                    </tr>
                                </table>
                            </fieldset>
                        </div>
                    </div>

                </div>
            </div>


            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
            ----------------------------------------------------------------------  Notes Tab  ----------------------------------------------------------------------
            ------------------------------------------------------------------------------------------------------------------------------------------------------ -->
            <div class="sheet-section-notes">
                <div class="sheet-flex-section">

                    <div class="sheet-column-grow">
                        <h1>Notes</h1>
                        <fieldset class="repeating_notes1">
                            <div class="sheet-repeating-section">
                                <div class="sheet-flex-form-container">
                                    <input type="text" name="attr_Note1Title" value="" class="sheet-tall-control" placeholder="Note title" />
                                </div>
                                <div>
                                    <input type="checkbox" name="attr_Note1Expanded" checked="true" class="sheet-expand-collapse-checkbox">
                                    <span class="sheet-expand-collapse-symbol"></span>
                                    <textarea class="sheet-text-area-large sheet-collapsible" name="attr_Note1Content" value="" placeholder="Note"></textarea>
                                    </div>
                                </div>
                        </fieldset>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Notes</h1>
                        <fieldset class="repeating_notes2">
                            <div class="sheet-repeating-section">
                                <div class="sheet-flex-form-container">
                                    <input type="text" name="attr_Note2Title" value="" class="sheet-tall-control" placeholder="Note title" />
                                </div>
                                <div>
                                    <input type="checkbox" name="attr_Note2Expanded" checked="true" class="sheet-expand-collapse-checkbox">
                                    <span class="sheet-expand-collapse-symbol"></span>
                                    <textarea class="sheet-text-area-large sheet-collapsible" name="attr_Note2Content" value="" placeholder="Note"></textarea>
                                </div>
                            </div>
                        </fieldset>
                    </div>
                </div>
            </div>


            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
            ----------------------------------------------------------------  Full Skills List Tab  -----------------------------------------------------------------
            ------------------------------------------------------------------------------------------------------------------------------------------------------ -->
            <div class="sheet-section-old-skills">
                <h1 class="sheet-spacer-top-margin">Old Full List of Skills - Please Do Not Use</h1>

                <h2>This full list of skills is being removed</h2>
                <h2>GMs and players found it hard to see which skills a character actually had ranks in</h2>

                <h2>Please copy your skills out of this tab and into the main skills tab</h2>
                <h2>This tab will be removed soon</h2>

                <hr>

                <div class="sheet-flex-section">
                    <div class="sheet-column-grow">
                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Non-Fluent Languages</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedNonFluentLangs" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Attr</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                            <th class="sheet-small-table-header">Bonus</th>
                                            <th class="sheet-small-table-header">Total</th>
                                            <th class="sheet-small-table-header">Dice</th>
                                            <th class="sheet-small-table-header">Roll</th>
                                        </tr>
                                        <tr>
                                            <td>
                                                <input type="text" class="sheet-input-wide sheet-input-full" name="attr_Lang1Name" value="" />
                                            </td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_Lang1Rating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_Lang1Bonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_Lang1Total" value="-" readonly />
                                            </td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_Lang1Dice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell">
                                                <button type="roll"
                                                    value="&{template:roll} {{character=@{character_name}}} {{name=@{Lang1Name} Check}} {{roll=[[@{Lang1Dice}@{MenMod}+?{Modifier|0}]]}}">
                                                </button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td>
                                                <input type="text" class="sheet-input-wide sheet-input-full" name="attr_Lang2Name" value="" />
                                            </td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_Lang2Rating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_Lang2Bonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_Lang2Total" value="-" readonly />
                                            </td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_Lang2Dice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell">
                                                <button type="roll"
                                                    value="&{template:roll} {{character=@{character_name}}} {{name=@{Lang2Name} Check}} {{roll=[[@{Lang2Dice}@{MenMod}+?{Modifier|0}]]}}">
                                                </button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td>
                                                <input type="text" class="sheet-input-wide sheet-input-full" name="attr_Lang3Name" value="" />
                                            </td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_Lang3Rating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_Lang3Bonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_Lang3Total" value="-" readonly />
                                            </td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_Lang3Dice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell">
                                                <button type="roll"
                                                    value="&{template:roll} {{character=@{character_name}}} {{name=@{Lang3Name} Check}} {{roll=[[@{Lang3Dice}@{MenMod}+?{Modifier|0}]]}}">
                                                </button>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <h1 class="sheet-spacer-top-margin">Character Skills</h1>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Creative</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedCreative" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">

                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Attr</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                            <th class="sheet-small-table-header">Bonus</th>
                                            <th class="sheet-small-table-header">Total</th>
                                            <th class="sheet-small-table-header">Tier</th>
                                            <th class="sheet-small-table-header">Dice</th>
                                            <th class="sheet-small-table-header">Roll</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Acting</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" class="sheet-skillfield sheet-act1" name="attr_ActRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ActBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ActTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ActTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ActDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Acting Check}} {{text=Roll: [[@{ActDice}@{ActTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Art</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ArtRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ArtBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ArtTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ArtTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ArtDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Art Check}} {{text=Roll: [[@{ArtDice}@{ArtTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Gem Cutting</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_GemRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_GemBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_GemTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_GemTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_GemDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Gem Cutting Check}} {{text=Roll: [[@{GemDice}@{GemTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Glass Blowing</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_GlassRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_GlassBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_GlassTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_GlassTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_GlassDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Glass Blowing Check}} {{text=Roll: [[@{GlassDice}@{GlassTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Impersonation</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ImpersonRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ImpersonBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ImpersonTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ImpersonTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ImpersonDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Impersonation Check}} {{text=Roll: [[@{ImpersonDice}@{ImpersonTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Mapping</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_MapRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_MapBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_MapTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_MapTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_MapDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Mapping Check}} {{text=Roll: [[@{MapDice}@{MapTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Music</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_MusicRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_MusicBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_MusicTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_MusicTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_MusicDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Music Check}} {{text=Roll: [[@{MusicDice}@{MusicTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Pottery</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_PotteryRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_PotteryBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_PotteryTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_PotteryTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_PotteryDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Pottery Check}} {{text=Roll: [[@{PotteryDice}@{PotteryTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Sewing</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SewRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SewBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_SewTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_SewTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_SewDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Sewing Check}} {{text=Roll: [[@{SewDice}@{SewTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Singing</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SingRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SingBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_SingTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_SingTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_SingDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Singing Check}} {{text=Roll: [[@{SingDice}@{SingTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Story Telling</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_StoryRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_StoryBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_StoryTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_StoryTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_StoryDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Story Telling Check}} {{text=Roll: [[@{StoryDice}@{StoryTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Weaving</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_WeaveRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_WeaveBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_WeaveTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_WeaveTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_WeaveDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Weaving Check}} {{text=Roll: [[@{WeaveDice}@{WeaveTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Diplomatic</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedDiplomatic" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">

                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Attr</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                            <th class="sheet-small-table-header">Bonus</th>
                                            <th class="sheet-small-table-header">Total</th>
                                            <th class="sheet-small-table-header">Tier</th>
                                            <th class="sheet-small-table-header">Dice</th>
                                            <th class="sheet-small-table-header">Roll</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Animal Kinship</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_AnimalRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_AnimalBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_AnimalTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_AnimalTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_AnimalDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Animal Kinship Check}} {{text=Roll: [[@{AnimalDice}@{AnimalTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Bartering</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_BarterRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_BarterBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_BarterTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_BarterTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_BarterDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Bartering Check}} {{text=Roll: [[@{BarterDice}@{BarterTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Deception</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DeceptRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DeceptBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_DeceptTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_DeceptTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_DeceptDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Deception Check}} {{text=Roll: [[@{DeceptDice}@{DeceptTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Detect Lies</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LiesRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LiesBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_LiesTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_LiesTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_LiesDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Detect Lies Check}} {{text=Roll: [[@{LiesDice}@{LiesTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Interrogation</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_IntrgRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_IntrgBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_IntrgTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_IntrgTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_IntrgDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Interrogation Check}} {{text=Roll: [[@{IntrgDice}@{IntrgTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Leadership</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LeadRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LeadBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_LeadTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_LeadTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_LeadDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Leadership Check}} {{text=Roll: [[@{LeadDice}@{LeadTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Seduction</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SeducRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SeducBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_SeducTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_SeducTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_SeducDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Seduction Check}} {{text=Roll: [[@{SeducDice}@{SeducTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Speech</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SpeechRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SpeechBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_SpeechTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_SpeechTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_SpeechDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Speech Check}} {{text=Roll: [[@{SpeechDice}@{SpeechTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Streetwise</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_StreetRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_StreetBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_StreetTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_StreetTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_StreetDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Streetwise Check}} {{text=Roll: [[@{StreetDice}@{StreetTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Magical</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedMagical" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Attr</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                            <th class="sheet-small-table-header">Bonus</th>
                                            <th class="sheet-small-table-header">Total</th>
                                            <th class="sheet-small-table-header">Tier</th>
                                            <th class="sheet-small-table-header">Dice</th>
                                            <th class="sheet-small-table-header">Roll</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Alchemy</td>
                                            <td class="sheet-cell-numeric-readonly">2</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_AlchRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_AlchBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_AlchTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_AlchTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_AlchDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Alchemy Check}} {{text=Roll: [[@{AlchDice}@{AlchTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Astrology</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_AstroRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_AstroBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_AstroTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_AstroTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_AstroDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Astrology Check}} {{text=Roll: [[@{AstroDice}@{AstroTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Battle Chant</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Wil</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ChantRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ChantBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ChantTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ChantTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ChantDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Battle Chant Check}} {{text=Roll: [[@{ChantDice}@{ChantTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Blood Magic</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Wil</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_BloodRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_BloodBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_BloodTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_BloodTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_BloodDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Blood Magic Check}} {{text=Roll: [[@{BloodDice}@{BloodTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Circle Magic</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_CircleRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_CircleBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_CircleTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_CircleTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_CircleDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Circle Magic Check}} {{text=Roll: [[@{CircleDice}@{CircleTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Conjuring</td>
                                            <td class="sheet-cell-numeric-readonly">2</td>
                                            <td class="sheet-cell-numeric-readonly">Wil</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ConjRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ConjBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ConjTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ConjTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ConjDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Conjuring Check}} {{text=Roll: [[@{ConjDice}@{ConjTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Crystal Lore</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_CrystalRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_CrystalBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_CrystalTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_CrystalTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_CrystalDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Crystal Lore Check}} {{text=Roll: [[@{CrystalDice}@{CrystalTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Exorcism</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Wil</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ExorcismRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ExorcismBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ExorcismTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ExorcismTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ExorcismDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Exorcism Check}} {{text=Roll: [[@{ExorcismDice}@{ExorcismTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Meditation</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Wil</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_MeditationRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_MeditationBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_MeditationTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_MeditationTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_MeditationDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Meditation Check}} {{text=Roll: [[@{MeditationDice}@{MeditationTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Necromancy</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Wil</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_NecroRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_NecroBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_NecroTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_NecroTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_NecroDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Necromancy Check}} {{text=Roll: [[@{NecroDice}@{NecroTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Spell Craft</td>
                                            <td class="sheet-cell-numeric-readonly">3</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SpCraftRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SpCraftBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_SpCraftTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_SpCraftTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_SpCraftDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Spell Craft Check}} {{text=Roll: [[@{SpCraftDice}@{SpCraftTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Thaumaturgy</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ThaumRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ThaumBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ThaumTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ThaumTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ThaumDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Thaumaturgy Check}} {{text=Roll: [[@{ThaumDice}@{ThaumTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Medical</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedMedical" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Attr</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                            <th class="sheet-small-table-header">Bonus</th>
                                            <th class="sheet-small-table-header">Total</th>
                                            <th class="sheet-small-table-header">Tier</th>
                                            <th class="sheet-small-table-header">Dice</th>
                                            <th class="sheet-small-table-header">Roll</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Healing</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_HealRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_HealBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_HealTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_HealTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_HealDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Healing Check}} {{text=Roll: [[@{HealDice}@{HealTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Medicine</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_MedicRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_MedicBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_MedicTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_MedicTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_MedicDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Medicine Check}} {{text=Roll: [[@{MedicDice}@{MedicTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Plant Lore</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_PlantRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_PlantBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_PlantTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_PlantTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_PlantDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Plant Lore Check}} {{text=Roll: [[@{PlantDice}@{PlantTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Poisons</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_PoisRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_PoisBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_PoisTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_PoisTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_PoisDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Poisons Check}} {{text=Roll: [[@{PoisDice}@{PoisTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Physical</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedPhysical" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">

                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Attr</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                            <th class="sheet-small-table-header">Bonus</th>
                                            <th class="sheet-small-table-header">Total</th>
                                            <th class="sheet-small-table-header">Tier</th>
                                            <th class="sheet-small-table-header">Dice</th>
                                            <th class="sheet-small-table-header">Roll</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Acrobatics</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_AcrobatRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_AcrobatBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_AcrobatTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_AcrobatTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_AcrobatDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Acrobatics Check}} {{text=Roll: [[@{AcrobatDice}@{AcrobatTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Climbing</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ClimbRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ClimbBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ClimbTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ClimbTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ClimbDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Climbing Check}} {{text=Roll: [[@{ClimbDice}@{ClimbTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Dancing</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DanceRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DanceBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_DanceTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_DanceTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_DanceDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Dancing Check}} {{text=Roll: [[@{DanceDice}@{DanceTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Drinking</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Bod</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DrinkRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DrinkBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_DrinkTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_DrinkTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_DrinkDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Drinking Check}} {{text=Roll: [[@{DrinkDice}@{DrinkTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Drug Tolerance</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Bod</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DrugRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DrugBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_DrugTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_DrugTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_DrugDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Drug Tolerance Check}} {{text=Roll: [[@{DrugDice}@{DrugTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Endurance</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Bod</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_EndurRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_EndurBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_EndurTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_EndurTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_EndurDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Endurance Check}} {{text=Roll: [[@{EndurDice}@{EndurTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Flying</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_FlyRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_FlyBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_FlyTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_FlyTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_FlyDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Flying Check}} {{text=Roll: [[@{FlyDice}@{FlyTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Juggling</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_JuggleRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_JuggleBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_JuggleTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_JuggleTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_JuggleDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Juggling Check}} {{text=Roll: [[@{JuggleDice}@{JuggleTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Jumping</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_JumpRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_JumpBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_JumpTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_JumpTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_JumpDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Jumping Check}} {{text=Roll: [[@{JumpDice}@{JumpTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Lifting</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Str</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LiftRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LiftBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_LiftTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_LiftTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_LiftDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Lifting Check}} {{text=Roll: [[@{LiftDice}@{LiftTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Lip Reading</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LipRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LipBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_LipTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_LipTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_LipDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Lip Reading Check}} {{text=Roll: [[@{LipDice}@{LipTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Listening</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ListenRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ListenBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ListenTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ListenTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ListenDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Listening Check}} {{text=Roll: [[@{ListenDice}@{ListenTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Observation</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ObservRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ObservBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ObservTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ObservTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ObservDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Observation Check}} {{text=Roll: [[@{ObservDice}@{ObservTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Running</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_RunRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_RunBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_RunTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_RunTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_RunDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Running Check}} {{text=Roll: [[@{RunDice}@{RunTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Swimming</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SwimRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SwimBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_SwimTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_SwimTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_SwimDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Swimming Check}} {{text=Roll: [[@{SwimDice}@{SwimTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Character Skills</h1>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Roguish</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedRoguish" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Attr</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                            <th class="sheet-small-table-header">Bonus</th>
                                            <th class="sheet-small-table-header">Total</th>
                                            <th class="sheet-small-table-header">Tier</th>
                                            <th class="sheet-small-table-header">Dice</th>
                                            <th class="sheet-small-table-header">Roll</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Appraisal</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_AppraisalRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_AppraisalBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_AppraisalTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_AppraisalTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_AppraisalDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Appraisal Check}} {{text=Roll: [[@{AppraisalDice}@{AppraisalTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Begging</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_BegRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_BegBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_BegTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_BegTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_BegDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Begging Check}} {{text=Roll: [[@{BegDice}@{BegTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Concealment</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ConcRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ConcBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ConcTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ConcTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ConcDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Concealment Check}} {{text=Roll: [[@{ConcDice}@{ConcTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Disguise</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DisgRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DisgBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_DisgTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_DisgTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_DisgDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Disguise Check}} {{text=Roll: [[@{DisgDice}@{DisgTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Escape Artistry</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_EscapeRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_EscapeBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_EscapeTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_EscapeTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_EscapeDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Escape Artistry Check}} {{text=Roll: [[@{EscapeDice}@{EscapeTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Forgery</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ForgeryRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ForgeryBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ForgeryTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ForgeryTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ForgeryDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Forgery Check}} {{text=Roll: [[@{ForgeryDice}@{ForgeryTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Gambling</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_GambleRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_GambleBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_GambleTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_GambleTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_GambleDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Gambling Check}} {{text=Roll: [[@{GambleDice}@{GambleTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Lock Picking</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LockRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LockBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_LockTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_LockTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_LockDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Lock Picking Check}} {{text=Roll: [[@{LockDice}@{LockTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Looting</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LootRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LootBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_LootTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_LootTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_LootDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Looting Check}} {{text=Roll: [[@{LootDice}@{LootTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Stealing</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_StealRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_StealBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_StealTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_StealTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_StealDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Stealing Check}} {{text=Roll: [[@{StealDice}@{StealTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Stealth</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_StealthRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_StealthBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_StealthTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_StealthTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_StealthDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Stealth Check}} {{text=Roll: [[@{StealthDice}@{StealthTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Trailing</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TrailRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TrailBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_TrailTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_TrailTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_TrailDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Trailing Check}} {{text=Roll: [[@{TrailDice}@{TrailTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Scholarly</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedScholarly" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">

                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Attr</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                            <th class="sheet-small-table-header">Bonus</th>
                                            <th class="sheet-small-table-header">Total</th>
                                            <th class="sheet-small-table-header">Tier</th>
                                            <th class="sheet-small-table-header">Dice</th>
                                            <th class="sheet-small-table-header">Roll</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Astronomy</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_AstronomyRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_AstronomyBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_AstronomyTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_AstronomyTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_AstronomyDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Astronomy Check}} {{text=Roll: [[@{AstronomyDice}@{AstronomyTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Creature Lore</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_CreatureRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_CreatureBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_CreatureTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_CreatureTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_CreatureDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Creature Lore Check}} {{text=Roll: [[@{CreatureDice}@{CreatureTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Decipher</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DecipherRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DecipherBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_DecipherTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_DecipherTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_DecipherDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Decipher Check}} {{text=Roll: [[@{DecipherDice}@{DecipherTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Demon Lore</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DemonRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_DemonBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_DemonTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_DemonTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_DemonDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Demon Lore Check}} {{text=Roll: [[@{DemonDice}@{DemonTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Heraldry</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_HeraldRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_HeraldBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_HeraldTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_HeraldTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_HeraldDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Heraldry Check}} {{text=Roll: [[@{HeraldDice}@{HeraldTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">History</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_HistoryRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_HistoryBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_HistoryTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_HistoryTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_HistoryDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=History Check}} {{text=Roll: [[@{HistoryDice}@{HistoryTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Law</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LawRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LawBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_LawTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_LawTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_LawDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Law Check}} {{text=Roll: [[@{LawDice}@{LawTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Linguistics</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LingRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LingBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_LingTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_LingTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_LingDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Linguistics Check}} {{text=Roll: [[@{LingDice}@{LingTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Philosophy</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Chr</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_PhilRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_PhilBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_PhilTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_PhilTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_PhilDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Philosophy Check}} {{text=Roll: [[@{PhilDice}@{PhilTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Read & Write</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ReadRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ReadBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ReadTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ReadTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ReadDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Read & Write Check}} {{text=Roll: [[@{ReadDice}@{ReadTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Research</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ResearchRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ResearchBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ResearchTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ResearchTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ResearchDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Research Check}} {{text=Roll: [[@{ResearchDice}@{ResearchTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Teaching</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TeachRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TeachBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_TeachTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_TeachTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_TeachDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Teaching Check}} {{text=Roll: [[@{TeachDice}@{TeachTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Theology</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TheoRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TheoBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_TheoTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_TheoTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_TheoDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Theology Check}} {{text=Roll: [[@{TheoDice}@{TheoTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Survival</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedSurvival" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">

                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Attr</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                            <th class="sheet-small-table-header">Bonus</th>
                                            <th class="sheet-small-table-header">Total</th>
                                            <th class="sheet-small-table-header">Tier</th>
                                            <th class="sheet-small-table-header">Dice</th>
                                            <th class="sheet-small-table-header">Roll</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Cooking</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_CookRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_CookBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_CookTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_CookTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_CookDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Cooking Check}} {{text=Roll: [[@{CookDice}@{CookTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Fishing</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_FishRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_FishBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_FishTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_FishTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_FishDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Fishing Check}} {{text=Roll: [[@{FishDice}@{FishTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Foraging</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ForageRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ForageBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ForageTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ForageTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ForageDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Foraging Check}} {{text=Roll: [[@{ForageDice}@{ForageTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Hunting</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_HuntRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_HuntBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_HuntTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_HuntTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_HuntDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Hunting Check}} {{text=Roll: [[@{HuntDice}@{HuntTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Street Survival</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_StSurvRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_StSurvBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_StSurvTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_StSurvTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_StSurvDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Street Survival Check}} {{text=Roll: [[@{StSurvDice}@{StSurvTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Tracking</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TrackRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TrackBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_TrackTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_TrackTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_TrackDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Tracking Check}} {{text=Roll: [[@{TrackDice}@{TrackTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Traps</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TrapRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TrapBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_TrapTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_TrapTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_TrapDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Traps Check}} {{text=Roll: [[@{TrapDice}@{TrapTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Weather Sense</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_WeatherRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_WeatherBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_WeatherTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_WeatherTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_WeatherDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Weather Sense Check}} {{text=Roll: [[@{WeatherDice}@{WeatherTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Wilderness Survival</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_WildRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_WildBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_WildTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_WildTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_WildDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Wilderness Survival Check}} {{text=Roll: [[@{WildDice}@{WildTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Trade</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedTrade" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Attr</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                            <th class="sheet-small-table-header">Bonus</th>
                                            <th class="sheet-small-table-header">Total</th>
                                            <th class="sheet-small-table-header">Tier</th>
                                            <th class="sheet-small-table-header">Dice</th>
                                            <th class="sheet-small-table-header">Roll</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Armorer</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ArmorerRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_ArmorerBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_ArmorerTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_ArmorerTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_ArmorerDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Armorer Check}} {{text=Roll: [[@{ArmorerDice}@{ArmorerTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Blacksmith</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_BlackRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_BlackBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_BlackTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_BlackTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_BlackDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Blacksmith Check}} {{text=Roll: [[@{BlackDice}@{BlackTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Bowyer & Fletcher</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_BowyerRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_BowyerBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_BowyerTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_BowyerTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_BowyerDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Bowyer & Fletcher Check}} {{text=Roll: [[@{BowyerDice}@{BowyerTier}@{MenMod}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Brewing</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_BrewRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_BrewBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_BrewTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_BrewTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_BrewDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Brewing Check}} {{text=Roll: [[@{BrewDice}@{BrewTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Carpentry</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_CarpRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_CarpBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_CarpTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_CarpTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_CarpDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Carpentry Check}} {{text=Roll: [[@{CarpDice}@{CarpTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Farming</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_FarmRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_FarmBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_FarmTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_FarmTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_FarmDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Farming Check}} {{text=Roll: [[@{FarmDice}@{FarmTier}@{MenMod}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Leather Working</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LWorkRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LWorkBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_LWorkTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_LWorkTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_LWorkDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Leather Working Check}} {{text=Roll: [[@{LWorkDice}@{LWorkTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Locksmith</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LocksmithRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_LocksmithBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_LocksmithTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_LocksmithTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_LocksmithDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Locksmith Check}} {{text=Roll: [[@{LocksmithDice}@{LocksmithTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Masonry</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_MasonRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_MasonBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_MasonTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_MasonTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_MasonDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Masonry Check}} {{text=Roll: [[@{MasonDice}@{MasonTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Mining</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_MiningRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_MiningBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_MiningTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_MiningTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_MiningDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Mining Check}} {{text=Roll: [[@{MiningDice}@{MiningTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Siege Craft</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SiegeRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SiegeBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_SiegeTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_SiegeTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_SiegeDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Siege Craft Check}} {{text=Roll: [[@{SiegeDice}@{SiegeTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Tinker</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TinkerRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TinkerBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_TinkerTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_TinkerTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_TinkerDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Tinker Check}} {{text=Roll: [[@{TinkerDice}@{TinkerTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Weaponsmith</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_WpnSmRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_WpnSmBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_WpnSmTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_WpnSmTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_WpnSmDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Weaponsmith Check}} {{text=Roll: [[@{WpnSmDice}@{WpnSmTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Travel</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedTravel" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Attr</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                            <th class="sheet-small-table-header">Bonus</th>
                                            <th class="sheet-small-table-header">Total</th>
                                            <th class="sheet-small-table-header">Tier</th>
                                            <th class="sheet-small-table-header">Dice</th>
                                            <th class="sheet-small-table-header">Roll</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Navigation</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Per</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_NavRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_NavBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_NavTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_NavTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_NavDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Navigation Check}} {{text=Roll: [[@{NavDice}@{NavTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Riding</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_RidingRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_RidingBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_RidingTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_RidingTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_RidingDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Riding Check}} {{text=Roll: [[@{RidingDice}@{RidingTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Seafaring</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SeaRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SeaBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_SeaTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_SeaTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_SeaDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Seafaring Check}} {{text=Roll: [[@{SeaDice}@{SeaTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Skyfaring</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Int</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SkyRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_SkyBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_SkyTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_SkyTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_SkyDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Skyfaring Check}} {{text=Roll: [[@{SkyDice}@{SkyTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Teamster</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-numeric-readonly">Dex</td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TeamRating" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="number" name="attr_TeamBonus" value="0" />
                                            </td>
                                            <td class="sheet-cell-numeric">
                                                <input type="text" class="sheet-totalfield" name="attr_TeamTotal" value="-" readonly />
                                            </td>
                                            <td><select name="attr_TeamTier">
                                                    <option value="+0">Basic</option>
                                                    <option value="+1">Expert</option>
                                                    <option value="+2">Master</option>
                                                </select></td>
                                            <td>
                                                <input type="text" class="sheet-dice-field" name="attr_TeamDice" value="" readonly />
                                            </td>
                                            <td class="sheet-button-cell"><button type="roll"
                                                    value="&{template:simple} {{character=@{character_name}}}{{name=Teamster Check}} {{text=Roll: [[@{TeamDice}@{TeamTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Additional Skills</h2>
                            <div class="sheet-collapse-section">
                                <input type="checkbox" name="attr_SkillsExpandedAdditional" checked="true" class="sheet-expand-collapse-checkbox">
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">

                                    <fieldset class="repeating_skills">
                                        <table class="sheet-repeating-section">
                                            <tr>
                                                <th class="sheet-small-table-header">Name</th>
                                                <th class="sheet-small-table-header">Cost</th>
                                                <th class="sheet-small-table-header">Attr</th>
                                                <th class="sheet-small-table-header">Rating</th>
                                                <th class="sheet-small-table-header">Bonus</th>
                                                <th class="sheet-small-table-header">Total</th>
                                                <th class="sheet-small-table-header">Tier</th>
                                                <th class="sheet-small-table-header">Dice</th>
                                                <th class="sheet-small-table-header">Roll</th>
                                            </tr>
                                            <tr>
                                                <td class="sheet-skillname-input-cell">
                                                    <input type="text" name="attr_SkillName" value="" />
                                                </td>
                                                <td class="sheet-cell-numeric">
                                                    <input type="number" name="attr_SkillCost" value="1" />
                                                </td>
                                                <td>
                                                    <select name="attr_SkillAttribute" class="sheet-skilldescshort">
                                                        <option value="str">Str</option>
                                                        <option value="dex">Dex</option>
                                                        <option value="bdy">Bod</option>
                                                        <option value="prc">Per</option>
                                                        <option value="int">Int</option>
                                                        <option value="wil">Wil</option>
                                                        <option value="chr">Chr</option>
                                                    </select>
                                                </td>
                                                <td class="sheet-cell-numeric">
                                                    <input type="number" name="attr_SkillRating" value="0" />
                                                </td>
                                                <td class="sheet-cell-numeric">
                                                    <input type="number" name="attr_SkillBonus" value="0" />
                                                </td>
                                                <td class="sheet-cell-numeric">
                                                    <input type="text" name="attr_SkillTotal" value="-" readonly class="sheet-totalfield" />
                                                </td>
                                                <td>
                                                    <select name="attr_SkillTier">
                                                        <option value="+0">Basic</option>
                                                        <option value="+1">Expert</option>
                                                        <option value="+2">Master</option>
                                                    </select>
                                                </td>
                                                <td>
                                                    <input type="text" name="attr_SkillDice" value="" readonly class="sheet-dice-field" />
                                                    <input type="hidden" name="attr_SkillConditionMod" value="0" />
                                                </td>
                                                <td class="sheet-button-cell">
                                                    <button type="roll"
                                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{SkillName} Check}} {{text=Roll: [[@{SkillDice}@{SkillTier}@{SkillConditionMod}+?{Modifier|0}]]}}">
                                                    </button>
                                                </td>
                                            </tr>
                                        </table>
                                    </fieldset>
                                </div>

                                <input type="hidden" name="attr_RepeatedSkillFieldIds" value="No repeating skill fields added yet" />
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </div>

        <div class="sheet-background-column-fixed-right"></div>
    </div>



    <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
    -------------------------------------------------------------------  Roll Templates  --------------------------------------------------------------------
    ------------------------------------------------------------------------------------------------------------------------------------------------------ -->
    <rolltemplate class="sheet-rolltemplate-text">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{title}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>
                
                <div class="sheet-template-text">{{text}}</div>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-class-ability-text">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>
                
                <table>
                    <tr>
                        <th>Rating</th>
                        <td>{{rating}}</td>
                    </tr>
                    <tr>
                        <th>Max. Rating</th>
                        <td>{{maxRating}}</td>
                    </tr>
                    <tr>
                        <th>Power</th>
                        <td>{{power}}</td>
                    </tr>
                </table>

                <div class="sheet-template-hr"></div>

                <div class="sheet-template-text">{{description}}</div>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-percentile">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                {{#rollGreater() difference 0}}
                <div class="sheet-template-failure">Failure</div>
                {{/rollGreater() difference 0}}
                {{#^rollGreater() difference 0}}
                <div class="sheet-template-success">Success</div>
                {{/^rollGreater() difference 0}}

                <div class="sheet-template-hr"></div>

                <table>
                    <tr>
                        <th>Roll</th>
                        <td>{{roll}}</td>
                    </tr>
                    <tr>
                        <th>Target</th>
                        <td>{{target}}</td>
                    </tr>
                </table>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-attack">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{attackType}} Attack</div>
                <div class="sheet-template-subtitle">{{character}}</div>
                
                <table>
                    <tr>
                        <th>Total To Hit</th>
                        <td>{{roll}}</td>
                    </tr>
                </table>

                <div class="sheet-template-hr"></div>

                <table>
                    <tr>
                        <th>Actions</th>
                        <td>{{actions}}</td>
                    </tr>
                </table>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-damage">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{damageType}} Damage</div>
                <div class="sheet-template-subtitle">{{character}}</div>
                
                <table>
                    <tr>
                        <th>Damage</th>
                        <td>{{damage}}</td>
                    </tr>
                </table>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-roll">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <table>
                    <tr>
                        <th>Roll</th>
                        <td>{{roll}}</td>
                    </tr>
                </table>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-simple">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <div class="sheet-template-text-prominent">{{text}}</div>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-two-part">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <div class="sheet-template-text-prominent">{{text}}</div>

                <div class="sheet-template-hr"></div>

                <div class="sheet-template-text-supplementary">{{supplementary}}</div>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-spell-description">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>
                
                <table>
                    <tr>
                        <th>Area</th>
                        <td>{{area}}</td>
                    </tr>
                    <tr>
                        <th>Duration</th>
                        <td>{{duration}}</td>
                    </tr>
                    <tr>
                        <th>Protection</th>
                        <td>{{protection}}</td>
                    </tr>
                    <tr>
                        <th>Mana Drain</th>
                        <td>{{drain}}</td>
                    </tr>
                    <tr>
                        <th>Magic Actions</th>
                        <td>{{actions}}</td>
                    </tr>
                </table>

                <div class="sheet-template-hr"></div>

                <div class="sheet-template-text">{{description}}</div>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-spell-cast">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}} Cast Roll</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <table>
                    <tr>
                        <th>Total to Cast</th>
                        <td>{{roll}}</td>
                    </tr>
                </table>

                <div class="sheet-template-hr"></div>

                <table>
                    <tr>
                        <th>Area</th>
                        <td>{{area}}</td>
                    </tr>
                    <tr>
                        <th>Duration</th>
                        <td>{{duration}}</td>
                    </tr>
                    <tr>
                        <th>Mana Drain</th>
                        <td>{{drain}}</td>
                    </tr>
                    <tr>
                        <th>Magic Actions</th>
                        <td>{{actions}}</td>
                    </tr>
                </table>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-spell-effect">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}} Effect Roll</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <table>
                    <tr>
                        <th>Total Spell Effect</th>
                        <td>{{roll}}</td>
                    </tr>
                </table>

                <div class="sheet-template-hr"></div>

                <table>
                    <tr>
                        <th>Protection</th>
                        <td>{{protection}}</td>
                    </tr>
                </table>
            </div>
        </div>
    </rolltemplate>
</div>