roll20-character-sheets/Demon Gate Scripted/Demon_Gate_Scripted.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()
    {
        UpdateLifting();
    
        UpdateAllAdditionalSkills();
    }
    
    function UpdateBdySkills()
    {
        UpdateDrinking();
        UpdateDrugTolerance();
        UpdateEndurance();
    
        UpdateAllAdditionalSkills();
    }
    
    function UpdateDexSkills()
    {
        UpdateAcrobatics();
        UpdateClimbing();
        UpdateDancing();
        UpdateEscapeArtistry();
        UpdateFlying();
        UpdateJuggling();
        UpdateJumping();
        UpdateLockPicking();
        UpdateRiding();
        UpdateRunning();
        UpdateStealing();
        UpdateStealth();
        UpdateSwimming();
        UpdateTeamster();
    
        UpdateAllAdditionalSkills();
    }
    
    function UpdatePrcSkills()
    {
        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();
    
        UpdateAllAdditionalSkills();
    }
    
    function UpdateIntSkills()
    {
        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();
    
        UpdateAllAdditionalSkills();
    }
    
    function UpdateWilSkills()
    {
        UpdateBattleChant();
        UpdateBloodMagic();
        UpdateConjuring();
        UpdateExorcism();
        UpdateMeditation();
        UpdateNecromancy();
    
        UpdateAllAdditionalSkills();
    }
    
    function UpdateChrSkills()
    {
        UpdateActing();
        UpdateAnimalKinship();
        UpdateBarter();
        UpdateBegging();
        UpdateDeception();
        UpdateImpersonation();
        UpdateInterrogation();
        UpdateLeadership();
        UpdatePhilosophy();
        UpdateSeduction();
        UpdateSinging();
        UpdateSpeech();
        UpdateStoryTelling();
        UpdateStreetwise();
    
        UpdateAllAdditionalSkills();
    }
    
    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)});
        });
    }
    
    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' };
    }
</script>
<div>
    <h2></h2>
    <h2>This sheet ("Demon Gate Scripted") has been replaced by a newer version with more features</h2>
    <h2>(called just "Demon Gate").</h2>
    <h2></h2>
    <h2>This sheet is no longer being supported and "Demon Gate Scripted" will eventually be removed.</h2>
    <h2></h2>
    <h2>Please switch this game's character sheet to "Demon Gate" at your earliest convenenience. Thanks!</h2>
    <h2></h2>

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



    <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
    ----------------------------------------------------------------------  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%20Scripted/DemonGateLogo.png">
            </div>

            <div class="sheet-column-grow">
                <table class="sheet-wide-table-auto">
                    <tr>
                        <th>Character Name:</th>
                        <td class="sheet-table-column-fullwidth">
                            <input type="text" class="sheet-input-wide sheet-input-full" name="attr_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 class="sheet-wide-table-auto">
                    <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 class="sheet-wide-table-auto">
                    <tr>
                        <th>Saved Saga Points: </th>
                        <td class="sheet-table-column-fullwidth sheet-input-like-no-padding">
                            <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-table-column-fullwidth sheet-input-like-no-padding">
                            <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 class="sheet-empty-cell">
                            <input type="number" class="sheet-prominent-field sheet-input-narrow" name="attr_Level" min="1" value="1" readonly />
                        </td>
                    </tr>
                </table>
            </div>
        </div>

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

                <div class="sheet-flex-section-centre">
                    <div class="sheet-column-prominent-stat">
                        <table class="sheet-wide-table-auto">
                            <tr>
                                <th colspan="2">
                                    <h2>Hit Points</h2>
                                </th>
                            </tr>
                            <tr>
                                <td colspan="2">
                                    <input type="number" class="sheet-extra-prominent-field" name="attr_CurHP" min="1" value="1" />
                                </td>
                            </tr>
                            <tr>
                                <th>Max</th>
                                <td>
                                    <input type="number" name="attr_MaxHP" class="sheet-input-full" min="1" value="1" />
                                </td>
                            </tr>
                        </table>
                    </div>

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

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

                    <div class="sheet-column-prominent-stat">
                        <table class="sheet-wide-table-auto">
                            <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-wide-table-auto sheet-vertical-margin-moderate">
                    <tr>
                        <th colspan="7">
                            <h2>Physical Condition</h2>
                            </th>
                    </tr>
                    <tr>
                        <td class="sheet-small-text sheet-physical-condition-0" width="14%">
                            <input type="radio" value="+0" name="attr_PhysMod" checked="true" />
                        </td>
                        <td class="sheet-small-text sheet-physical-condition-1" width="14%">
                            <input type="radio" value="-0" name="attr_PhysMod" />
                        </td>
                        <td class="sheet-small-text sheet-physical-condition-2" width="14%">
                            <input type="radio" value="-1" name="attr_PhysMod" />
                        </td>
                        <td class="sheet-small-text sheet-physical-condition-3" width="14%">
                            <input type="radio" value="-2" name="attr_PhysMod" />
                        </td>
                        <td class="sheet-small-text sheet-physical-condition-4" width="14%">
                            <input type="radio" value="-3" name="attr_PhysMod" />
                        </td>
                        <td class="sheet-small-text sheet-physical-condition-5" width="14%">
                            <input type="radio" value="-4" name="attr_PhysMod" />
                        </td>
                        <td class="sheet-small-text sheet-physical-condition-6" width="14%">
                            <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-wide-table-auto sheet-vertical-margin-moderate">
                    <tr>
                        <th colspan="7">
                            <h2>Mental Condition</h2>
                            </th>
                    </tr>
                    <tr>
                        <td class="sheet-small-text sheet-mental-condition-0" width="14%">
                            <input type="radio" value="+0" name="attr_MenMod" checked="true" />
                        </td>
                        <td class="sheet-small-text sheet-mental-condition-1" width="14%">
                            <input type="radio" value="-0" name="attr_MenMod" />
                        </td>
                        <td class="sheet-small-text sheet-mental-condition-2" width="14%">
                            <input type="radio" value="-1" name="attr_MenMod" />
                        </td>
                        <td class="sheet-small-text sheet-mental-condition-3" width="14%">
                            <input type="radio" value="-2" name="attr_MenMod" />
                        </td>
                        <td class="sheet-small-text sheet-mental-condition-4" width="14%">
                            <input type="radio" value="-3" name="attr_MenMod" />
                        </td>
                        <td class="sheet-small-text sheet-mental-condition-5" width="14%">
                            <input type="radio" value="-4" name="attr_MenMod" />
                        </td>
                        <td class="sheet-small-text sheet-mental-condition-6" width="14%">
                            <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-wide-table-auto sheet-vertical-margin">
                    <tr>
                        <td class="sheet-skillhead" style="width:20%">Attribute</td>
                        <td class="sheet-skillhead" style="width:10%">Base</td>
                        <td class="sheet-skillhead" style="width:10%">Bonus</td>
                        <td class="sheet-skillhead" style="width:10%">Total</td>
                        <td class="sheet-skillhead" style="width:10%">Rank</td>
                        <td class="sheet-skillhead" style="width:35%">Dice</td>
                        <td class="sheet-skillhead" style="width:5%"></td>
                    </tr>
                    <tr>
                        <th>
                            <h3>Strength</h3>
                        </th>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_StrBase" value="0" min="0" max="100" /></td>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_StrBonus" value="0" min="-100" max="100" /></td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <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 align="center"><button type="roll"
                                value="&{template:default} {{name=Strength Check}}  {{Roll = [[@{StrDice}@{PhysMod}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <th>Damage Modifier:</th>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_DmgModBase" value="0" readonly />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_DmgModBonus" value="0" />
                        </td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <input type="text" class="sheet-text-centred" name="attr_WtAllow" value="vl" readonly />
                        </td>
                        <td colspan="3"></td>
                    </tr>
                </table>

                <!--Dexterity-->
                <table class="sheet-wide-table-auto sheet-vertical-margin">
                    <tr>
                        <td class="sheet-skillhead" style="width:20%">Attribute</td>
                        <td class="sheet-skillhead" style="width:10%">Base</td>
                        <td class="sheet-skillhead" style="width:10%">Bonus</td>
                        <td class="sheet-skillhead" style="width:10%">Total</td>
                        <td class="sheet-skillhead" style="width:10%">Rank</td>
                        <td class="sheet-skillhead" style="width:35%">Dice</td>
                        <td class="sheet-skillhead" style="width:5%"></td>
                    </tr>
                    <tr>
                        <th>
                            <h3>Dexterity</h3>
                        </th>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_DexBase" value="0" min="0" max="100" /></td>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_DexBonus" value="0" min="-100" max="100" /></td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <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 align="center"><button type="roll"
                                value="&{template:default} {{name=Dexterity Check}}  {{Roll = [[@{DexDice}@{PhysMod}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <th>Defense Modifier:</th>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_DefModBase" value="0" readonly />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_DefModBonus" value="0" />
                        </td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <input type="number" name="attr_InitModBase" value="0" readonly />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_InitModBonus" value="0" />
                        </td>
                        <td class="sheet-cell-narrow">
                            <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-narrow"></td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_MvmtBonus" value="0" />
                        </td>
                        <td class="sheet-cell-narrow sheet-read-only-field">
                            <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-wide-table-auto sheet-vertical-margin">
                    <tr>
                        <td class="sheet-skillhead" style="width:20%">Attribute</td>
                        <td class="sheet-skillhead" style="width:10%">Base</td>
                        <td class="sheet-skillhead" style="width:10%">Bonus</td>
                        <td class="sheet-skillhead" style="width:10%">Total</td>
                        <td class="sheet-skillhead" style="width:10%">Rank</td>
                        <td class="sheet-skillhead" style="width:35%">Dice</td>
                        <td class="sheet-skillhead" style="width:5%"></td>
                    </tr>
                    <tr>
                        <th>
                            <h3>Body</h3>
                        </th>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_BdyBase" value="0" min="0" max="100" /></td>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_BdyBonus" value="0" min="-100" max="100" /></td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <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 align="center"><button type="roll"
                                value="&{template:default} {{name=Body Check}}  {{Roll = [[@{BdyDice}@{PhysMod}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <th>Toughness:</th>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_ToughBase" value="0" readonly />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_ToughBonus" value="0" />
                        </td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <input type="hidden" name="attr_HPAdj" value="0" />
                            <input type="number" name="attr_BdySave" value="0" readonly />
                        </td>
                        <td align="center">
                            <button type="roll" value="&{template:default} {{name=Body Save}}  {{Successes = [[{(1d20 + ?{Modifier|0})}>@{BdySave}]]}}"></button>
                        </td>
                        <td colspan="2"></td>
                    </tr>
                </table>

                <!--Perception-->
                <table class="sheet-wide-table-auto sheet-vertical-margin">
                    <tr>
                        <td class="sheet-skillhead" style="width:20%">Attribute</td>
                        <td class="sheet-skillhead" style="width:10%">Base</td>
                        <td class="sheet-skillhead" style="width:10%">Bonus</td>
                        <td class="sheet-skillhead" style="width:10%">Total</td>
                        <td class="sheet-skillhead" style="width:10%">Rank</td>
                        <td class="sheet-skillhead" style="width:35%">Dice</td>
                        <td class="sheet-skillhead" style="width:5%"></td>
                    </tr>
                    <tr>
                        <th>
                            <h3>Perception</h3>
                        </th>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_PrcBase" value="0" min="0" max="100" /></td>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_PrcBonus" value="0" min="-100" max="100" /></td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <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 align="center"><button type="roll"
                                value="&{template:default} {{name=Perception Check}}  {{Roll = [[@{PrcDice}@{PhysMod}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <th>Shot Damage Modifier:</th>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_ShotDmgModBase" value="0" readonly />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_ShotDmgModBonus" value="0" />
                        </td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <input type="number" name="attr_RgBase" value="0" readonly />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_RgBonus" value="0" />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_RgTotal" value="0" class="sheet-totalfield" readonly />
                        </td>
                        <td colspan="3"></td>
                    </tr>
                </table>

                <!--Intelligence-->
                <table class="sheet-wide-table-auto sheet-vertical-margin">
                    <tr>
                        <td class="sheet-skillhead" style="width:20%">Attribute</td>
                        <td class="sheet-skillhead" style="width:10%">Base</td>
                        <td class="sheet-skillhead" style="width:10%">Bonus</td>
                        <td class="sheet-skillhead" style="width:10%">Total</td>
                        <td class="sheet-skillhead" style="width:10%">Rank</td>
                        <td class="sheet-skillhead" style="width:35%">Dice</td>
                        <td class="sheet-skillhead" style="width:5%"></td>
                    </tr>
                    <tr>
                        <th>
                            <h3>Intelligence</h3>
                        </th>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_IntBase" value="0" min="0" max="100" /></td>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_IntBonus" value="0" min="-100" max="100" /></td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <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 align="center"><button type="roll"
                                value="&{template:default} {{name=Intelligence Check}}  {{Roll = [[@{IntDice}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <th>Spell Effect:</th>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_SpEffBase" value="0" readonly />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_SpEffBonus" value="0" />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_SpEffTotal" value="0" class="sheet-totalfield" readonly />
                        </td>
                        <td colspan="3"></td>
                    </tr>
                    <tr>
                        <th>Spell Time:</th>
                        <td class="sheet-cell-narrow"></td>
                        <td class="sheet-cell-narrow">
                            <input type="text" name="attr_SpellTime" readonly />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="text" name="attr_SpText" readonly />
                        </td>
                        <td colspan="3"></td>
                    </tr>
                    <tr>
                        <th>Languages:</th>
                        <td colspan="2"></td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_Langs" value="0" readonly />
                        </td>
                        <td colspan="3"></td>
                    </tr>
                </table>

                <!--Willpower-->
                <table class="sheet-wide-table-auto sheet-vertical-margin">
                    <tr>
                        <td class="sheet-skillhead" style="width:20%">Attribute</td>
                        <td class="sheet-skillhead" style="width:10%">Base</td>
                        <td class="sheet-skillhead" style="width:10%">Bonus</td>
                        <td class="sheet-skillhead" style="width:10%">Total</td>
                        <td class="sheet-skillhead" style="width:10%">Rank</td>
                        <td class="sheet-skillhead" style="width:35%">Dice</td>
                        <td class="sheet-skillhead" style="width:5%"></td>
                    </tr>
                    <tr>
                        <th>
                            <h3>Willpower</h3>
                        </th>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_WilBase" value="0" min="0" max="100" /></td>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_WilBonus" value="0" min="-100" max="100" /></td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <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 align="center"><button type="roll"
                                value="&{template:default} {{name=Willpower Check}}  {{Roll = [[@{WilDice}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <th>Mental Defense:</th>
                        <td class="sheet-cell-narrow">
                            <input type="hidden" name="attr_ManaAdj" value="0" />
                            <input type="number" name="attr_MenDefBase" value="0" readonly />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_MenDefBonus" value="0" />
                        </td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <input type="number" name="attr_FortBase" value="0" readonly />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_FortBonus" value="0" />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_FortTotal" value="0" class="sheet-totalfield" readonly />
                        </td>
                        <td colspan="3"></td>
                    </tr>
                </table>

                <!--Charisma-->
                <table class="sheet-wide-table-auto sheet-vertical-margin">
                    <tr>
                        <td class="sheet-skillhead" style="width:20%">Attribute</td>
                        <td class="sheet-skillhead" style="width:10%">Base</td>
                        <td class="sheet-skillhead" style="width:10%">Bonus</td>
                        <td class="sheet-skillhead" style="width:10%">Total</td>
                        <td class="sheet-skillhead" style="width:10%">Rank</td>
                        <td class="sheet-skillhead" style="width:35%">Dice</td>
                        <td class="sheet-skillhead" style="width:5%"></td>
                    </tr>
                    <tr>
                        <th>
                            <h3>Charisma</h3>
                        </th>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_ChrBase" value="0" min="0" max="100" /></td>
                        <td class="sheet-cell-narrow"><input type="number" name="attr_ChrBonus" value="0" min="-100" max="100" /></td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <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 align="center"><button type="roll"
                                value="&{template:default} {{name=Charisma Check}}  {{Roll = [[@{ChrDice}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <th>Social Pool:</th>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_SocialBase" value="0" readonly />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_SocialBonus" value="0" />
                        </td>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <input type="number" name="attr_RepBonus" value="0" readonly />
                        </td>
                        <td colspan="3"></td>
                    </tr>
                </table>

                <!--Beauty-->
                <table class="sheet-wide-table-auto sheet-vertical-margin">
                    <tr>
                        <td class="sheet-skillhead" style="width:20%">Attribute</td>
                        <td class="sheet-skillhead" style="width:10%">Base</td>
                        <td class="sheet-skillhead" style="width:10%">Bonus</td>
                        <td class="sheet-skillhead" style="width:10%">Total</td>
                        <td class="sheet-skillhead" style="width:10%">Rank</td>
                        <td class="sheet-skillhead" style="width:35%">Dice</td>
                        <td class="sheet-skillhead" style="width:5%"></td>
                    </tr>
                    <tr>
                        <th>
                            <h3>Beauty</h3>
                        </th>
                        <td class="sheet-cell-narrow">
                            <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-narrow">
                            <input type="number" name="attr_BtyBonus" value="0" min="-100" max="100" />
                        </td>
                        <td class="sheet-cell-narrow">
                            <input type="number" name="attr_BtyTotal" value="0" class="sheet-totalfield" readonly />
                        </td>
                        <td colspan="3"></td>
                    </tr>
                </table>
            </div>
        </div>
    </div>



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

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

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

                <h2 class="sheet-table-header-collapse">Melee</h2>
                <div class="sheet-empty-cell">
                    <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 class="sheet-wide-table">
                            <tr>
                                <td class="sheet-skillhead">Name</td>
                                <td class="sheet-skillhead">Cost</td>
                                <td class="sheet-skillhead">Rating</td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">Unarmed</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclonger" 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 align="left" class="sheet-skillname" width="40%">Alchemy</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Axes</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Flails</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Grenades</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Hammers</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Javelins</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Knives</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Maces</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Polearms</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Shurikens</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Staves</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Swords</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Whips</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Blind Fighting</td>
                                <td align="center" class="sheet-skillstat" width="10%">2</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclong" name="attr_BlindFighting">
                                        <option value="0">---</option>
                                        <option value="1">Owned</option>
                                    </select></td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">Dual Melee</td>
                                <td align="center" class="sheet-skillstat" width="10%">3</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclong" name="attr_DualMelee">
                                        <option value="0">---</option>
                                        <option value="1">Owned</option>
                                    </select></td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">Throwing</td>
                                <td align="center" class="sheet-skillstat" width="10%">1</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclong" name="attr_Throwing">
                                        <option value="0">---</option>
                                        <option value="1">Owned</option>
                                    </select></td>
                            </tr>
                            <tr class="sheet-blankrow"></tr>
                            <tr>
                                <td align="center" colspan="3">* = As Rating</td>
                            </tr>
                        </table>
                    </div>
                </div>

                <h2 class="sheet-table-header-collapse">Shooting</h2>
                <div class="sheet-empty-cell">
                    <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 class="sheet-wide-table">
                            <tr>
                                <td class="sheet-skillhead">Name</td>
                                <td class="sheet-skillhead">Cost</td>
                                <td class="sheet-skillhead">Rating</td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">Black Powder</td>
                                <td align="center" class="sheet-skillstat" width="10%">1</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclong" name="attr_BlackPowder">
                                        <option value="0">---</option>
                                        <option value="1">Owned</option>
                                    </select></td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">--Lances</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">--Pistols</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">--Rifles</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">--Shotguns</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Blind Shooting</td>
                                <td align="center" class="sheet-skillstat" width="10%">2</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclong" name="attr_BlindShooting">
                                        <option value="0">---</option>
                                        <option value="1">Owned</option>
                                    </select></td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">Dual Shooting</td>
                                <td align="center" class="sheet-skillstat" width="10%">3</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclong" name="attr_DualShooting">
                                        <option value="0">---</option>
                                        <option value="1">Owned</option>
                                    </select></td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">Projectiles</td>
                                <td align="center" class="sheet-skillstat" width="10%">1</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclong" name="attr_Projectiles">
                                        <option value="0">---</option>
                                        <option value="1">Owned</option>
                                    </select></td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">--Blow Guns</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">--Bows</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">--Crossbows</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">--Hand Bows</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">--Slings</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Siege Weapons</td>
                                <td align="center" class="sheet-skillstat" width="10%">1</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclong" name="attr_Siege">
                                        <option value="0">---</option>
                                        <option value="1">Owned</option>
                                    </select></td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">--Ballistae</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">--Cannons</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">--Catapults</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">--Trebuchets</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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>

                <h2 class="sheet-table-header-collapse">Magic</h2>
                <div class="sheet-empty-cell">
                    <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 class="sheet-wide-table">
                            <tr>
                                <td class="sheet-skillhead">Name</td>
                                <td class="sheet-skillhead">Cost</td>
                                <td class="sheet-skillhead">Rating</td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">Black Magic</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Blue Magic</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Brown Magic</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Gold Magic</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Gray Magic</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Green Magic</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Red Magic</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">White Magic</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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>

                <h2 class="sheet-table-header-collapse">Armor</h2>
                <div class="sheet-empty-cell">
                    <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 class="sheet-wide-table">
                            <tr>
                                <td class="sheet-skillhead">Name</td>
                                <td class="sheet-skillhead">Cost</td>
                                <td class="sheet-skillhead">Rating</td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">Light Armor</td>
                                <td align="center" class="sheet-skillstat" width="10%">2</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclong" name="attr_LightArmor">
                                        <option value="0">---</option>
                                        <option value="1">Owned</option>
                                    </select></td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">Medium Armor</td>
                                <td align="center" class="sheet-skillstat" width="10%">2</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclong" name="attr_MedArmor">
                                        <option value="0">---</option>
                                        <option value="1">Owned</option>
                                    </select></td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">Heavy Armor</td>
                                <td align="center" class="sheet-skillstat" width="10%">2</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclong" name="attr_HeavyArmor">
                                        <option value="0">---</option>
                                        <option value="1">Owned</option>
                                    </select></td>
                            </tr>
                            <tr>
                                <td align="left" class="sheet-skillname" width="40%">Body Armor</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Bracers</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Greaves</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Helmet</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Pauldron</td>
                                <td align="center" class="sheet-skillstat" width="10%">*</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesc" 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 align="left" class="sheet-skillname" width="40%">Shields</td>
                                <td align="center" class="sheet-skillstat" width="10%">3</td>
                                <td align="center" class="sheet-descstat" width="50%"><select class="sheet-skilldesclong" name="attr_Shields">
                                        <option value="0">---</option>
                                        <option value="1">+1 cover</option>
                                    </select></td>
                            </tr>
                        </table>
                    </div>
                </div>

                <h2 class="sheet-table-header-collapse">Combat Specializations</h2>
                <div class="sheet-empty-cell">
                    <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 class="sheet-wide-table">
                            <tr>
                                <td class="sheet-skillhead" width="90%">Name</td>
                                <td class="sheet-skillhead" width="10%">Rating</td>
                            </tr>
                            <tr>
                                <td colspan="2">
                                    <fieldset class="repeating_wpnspecs">
                                        <div class="sheet-repeating-section">
                                            <table class="sheet-wide-table">
                                                <tr>
                                                    <td align="center" class="sheet-descstat" width="90%">
                                                        <input type="text" class="sheet-skillfield" name="attr_WpnSpecName" value="" style="width: 15em" />
                                                    </td>
                                                    <td align="center" class="sheet-descstat" width="10%">
                                                        <input type="number" class="sheet-skillfield" name="attr_WpnSpecRating" value="4" style="width: 2.2em" />
                                                    </td>
                                                </tr>
                                            </table>
                                        </div>
                                    </fieldset>
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>
            </div>

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

                <h2 class="sheet-table-header-collapse">Fluent Languages</h2>
                <div class="sheet-empty-cell">
                    <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 class="sheet-wide-table">
                                    <tr>
                                        <td align="center" class="sheet-descstat">
                                            <input type="text" class="sheet-skillfield" name="attr_LearnedLang" value="" style="width: 18em" />
                                        </td>
                                    </tr>
                                </table>
                            </div>
                        </fieldset>
                    </div>
                </div>

                <h2 class="sheet-table-header-collapse">Non-Fluent Languages</h2>
                <div class="sheet-empty-cell">
                    <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 class="sheet-wide-table">
                            <tr>
                                <td class="sheet-skillhead" width="18%">Name</td>
                                <td class="sheet-skillhead" width="5%">Cost</td>
                                <td class="sheet-skillhead" width="7%">Attr</td>
                                <td class="sheet-skillhead" width="10%">Rating</td>
                                <td class="sheet-skillhead" width="10%">Bonus</td>
                                <td class="sheet-skillhead" width="10%">Total</td>
                                <td class="sheet-skillhead" width="35%">Dice</td>
                                <td class="sheet-skillhead" width="5%">Roll</td>
                            </tr>
                            <tr>
                                <td class="sheet-smallname">
                                    <input type="text" class="sheet-input-wide sheet-input-full" name="attr_Lang1Name" value="" />
                                </td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_Lang1Rating" value="0" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_Lang1Bonus" value="0" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_Lang1Total" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_Lang1Dice" value="" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=@{Lang1Name} Check}}  {{Roll = [[@{Lang1Dice}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-smallname">
                                    <input type="text" class="sheet-input-wide sheet-input-full" name="attr_Lang2Name" value="" />
                                </td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_Lang2Rating" value="0" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_Lang2Bonus" value="0" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_Lang2Total" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_Lang2Dice" value="" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=@{Lang2Name} Check}}  {{Roll = [[@{Lang2Dice}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-smallname">
                                    <input type="text" class="sheet-input-wide sheet-input-full" name="attr_Lang3Name" value="" />
                                </td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_Lang3Rating" value="0" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_Lang3Bonus" value="0" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_Lang3Total" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_Lang3Dice" value="" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=@{Lang3Name} Check}}  {{Roll = [[@{Lang3Dice}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>

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

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

                <h2 class="sheet-table-header-collapse">Diplomatic</h2>
                <div class="sheet-empty-cell">
                    <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 class="sheet-wide-table">
                            <tr>
                                <td class="sheet-skillhead" width="18%">Name</td>
                                <td class="sheet-skillhead" width="5%">Cost</td>
                                <td class="sheet-skillhead" width="7%">Attr</td>
                                <td class="sheet-skillhead" width="10%">Rating</td>
                                <td class="sheet-skillhead" width="10%">Bonus</td>
                                <td class="sheet-skillhead" width="10%">Total</td>
                                <td class="sheet-skillhead" width="10%">Tier</td>
                                <td class="sheet-skillhead" width="25%">Dice</td>
                                <td class="sheet-skillhead" width="5%">Roll</td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Animal Kinship</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Chr</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_AnimalRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_AnimalBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_AnimalTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_AnimalTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_AnimalDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Animal Kinship Check}}  {{Roll = [[@{AnimalDice}@{AnimalTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Bartering</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Chr</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_BarterRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_BarterBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_BarterTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_BarterTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_BarterDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Bartering Check}}  {{Roll = [[@{BarterDice}@{BarterTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Deception</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Chr</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_DeceptRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_DeceptBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_DeceptTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_DeceptTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_DeceptDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Deception Check}}  {{Roll = [[@{DeceptDice}@{DeceptTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Detect Lies</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Per</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_LiesRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_LiesBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_LiesTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_LiesTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_LiesDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Detect Lies Check}}  {{Roll = [[@{LiesDice}@{LiesTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Interrogation</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Chr</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_IntrgRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_IntrgBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_IntrgTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_IntrgTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_IntrgDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Interrogation Check}}  {{Roll = [[@{IntrgDice}@{IntrgTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Leadership</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Chr</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_LeadRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_LeadBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_LeadTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_LeadTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_LeadDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Leadership Check}}  {{Roll = [[@{LeadDice}@{LeadTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Seduction</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Chr</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_SeducRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_SeducBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_SeducTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_SeducTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_SeducDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Seduction Check}}  {{Roll = [[@{SeducDice}@{SeducTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Speech</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Chr</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_SpeechRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_SpeechBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_SpeechTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_SpeechTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_SpeechDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Speech Check}}  {{Roll = [[@{SpeechDice}@{SpeechTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Streetwise</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Chr</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_StreetRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_StreetBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_StreetTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_StreetTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_StreetDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Streetwise Check}}  {{Roll = [[@{StreetDice}@{StreetTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>

                <h2 class="sheet-table-header-collapse">Magical</h2>
                <div class="sheet-empty-cell">
                    <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 width="100%" style="margin-top: 20px;">
                            <tr>
                                <td class="sheet-skillhead" width="18%">Name</td>
                                <td class="sheet-skillhead" width="5%">Cost</td>
                                <td class="sheet-skillhead" width="7%">Attr</td>
                                <td class="sheet-skillhead" width="10%">Rating</td>
                                <td class="sheet-skillhead" width="10%">Bonus</td>
                                <td class="sheet-skillhead" width="10%">Total</td>
                                <td class="sheet-skillhead" width="10%">Tier</td>
                                <td class="sheet-skillhead" width="25%">Dice</td>
                                <td class="sheet-skillhead" width="5%">Roll</td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Alchemy</td>
                                <td class="sheet-skillstat">2</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_AlchRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_AlchBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_AlchTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_AlchTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_AlchDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Alchemy Check}}  {{Roll = [[@{AlchDice}@{AlchTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Astrology</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_AstroRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_AstroBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_AstroTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_AstroTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_AstroDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Astrology Check}}  {{Roll = [[@{AstroDice}@{AstroTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Battle Chant</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Wil</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_ChantRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_ChantBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_ChantTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_ChantTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_ChantDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Battle Chant Check}}  {{Roll = [[@{ChantDice}@{ChantTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Blood Magic</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Wil</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_BloodRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_BloodBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_BloodTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_BloodTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_BloodDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Blood Magic Check}}  {{Roll = [[@{BloodDice}@{BloodTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Circle Magic</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_CircleRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_CircleBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_CircleTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_CircleTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_CircleDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Circle Magic Check}}  {{Roll = [[@{CircleDice}@{CircleTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Conjuring</td>
                                <td class="sheet-skillstat">2</td>
                                <td class="sheet-skillstat">Wil</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_ConjRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_ConjBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_ConjTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_ConjTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_ConjDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Conjuring Check}}  {{Roll = [[@{ConjDice}@{ConjTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Crystal Lore</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_CrystalRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_CrystalBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_CrystalTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_CrystalTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_CrystalDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Crystal Lore Check}}  {{Roll = [[@{CrystalDice}@{CrystalTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Exorcism</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Wil</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_ExorcismRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_ExorcismBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_ExorcismTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_ExorcismTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_ExorcismDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Exorcism Check}}  {{Roll = [[@{ExorcismDice}@{ExorcismTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Meditation</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Wil</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_MeditationRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_MeditationBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_MeditationTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_MeditationTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_MeditationDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Meditation Check}}  {{Roll = [[@{MeditationDice}@{MeditationTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Necromancy</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Wil</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_NecroRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_NecroBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_NecroTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_NecroTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_NecroDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Necromancy Check}}  {{Roll = [[@{NecroDice}@{NecroTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Spell Craft</td>
                                <td class="sheet-skillstat">3</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_SpCraftRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_SpCraftBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_SpCraftTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_SpCraftTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_SpCraftDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Spell Craft Check}}  {{Roll = [[@{SpCraftDice}@{SpCraftTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Thaumaturgy</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_ThaumRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_ThaumBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_ThaumTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_ThaumTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_ThaumDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Thaumaturgy Check}}  {{Roll = [[@{ThaumDice}@{ThaumTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>

                <h2 class="sheet-table-header-collapse">Medical</h2>
                <div class="sheet-empty-cell">
                    <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 class="sheet-wide-table">
                            <tr>
                                <td class="sheet-skillhead" width="18%">Name</td>
                                <td class="sheet-skillhead" width="5%">Cost</td>
                                <td class="sheet-skillhead" width="7%">Attr</td>
                                <td class="sheet-skillhead" width="10%">Rating</td>
                                <td class="sheet-skillhead" width="10%">Bonus</td>
                                <td class="sheet-skillhead" width="10%">Total</td>
                                <td class="sheet-skillhead" width="10%">Tier</td>
                                <td class="sheet-skillhead" width="25%">Dice</td>
                                <td class="sheet-skillhead" width="5%">Roll</td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Healing</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_HealRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_HealBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_HealTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_HealTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_HealDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Healing Check}}  {{Roll = [[@{HealDice}@{HealTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Medicine</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_MedicRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_MedicBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_MedicTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_MedicTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_MedicDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Medicine Check}}  {{Roll = [[@{MedicDice}@{MedicTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Plant Lore</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_PlantRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_PlantBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_PlantTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_PlantTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_PlantDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Plant Lore Check}}  {{Roll = [[@{PlantDice}@{PlantTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Poisons</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_PoisRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_PoisBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_PoisTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_PoisTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_PoisDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Poisons Check}}  {{Roll = [[@{PoisDice}@{PoisTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>

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

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

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

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

                <h2 class="sheet-table-header-collapse">Survival</h2>
                <div class="sheet-empty-cell">
                    <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 class="sheet-wide-table">
                            <tr>
                                <td class="sheet-skillhead" width="18%">Name</td>
                                <td class="sheet-skillhead" width="5%">Cost</td>
                                <td class="sheet-skillhead" width="7%">Attr</td>
                                <td class="sheet-skillhead" width="10%">Rating</td>
                                <td class="sheet-skillhead" width="10%">Bonus</td>
                                <td class="sheet-skillhead" width="10%">Total</td>
                                <td class="sheet-skillhead" width="10%">Tier</td>
                                <td class="sheet-skillhead" width="25%">Dice</td>
                                <td class="sheet-skillhead" width="5%">Roll</td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Cooking</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Per</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_CookRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_CookBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_CookTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_CookTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_CookDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Cooking Check}}  {{Roll = [[@{CookDice}@{CookTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Fishing</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Per</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_FishRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_FishBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_FishTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_FishTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_FishDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Fishing Check}}  {{Roll = [[@{FishDice}@{FishTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Foraging</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Per</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_ForageRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_ForageBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_ForageTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_ForageTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_ForageDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Foraging Check}}  {{Roll = [[@{ForageDice}@{ForageTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Hunting</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Per</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_HuntRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_HuntBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_HuntTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_HuntTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_HuntDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Hunting Check}}  {{Roll = [[@{HuntDice}@{HuntTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Street Survival</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_StSurvRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_StSurvBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_StSurvTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_StSurvTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_StSurvDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Street Survival Check}}  {{Roll = [[@{StSurvDice}@{StSurvTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Tracking</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Per</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_TrackRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_TrackBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_TrackTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_TrackTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_TrackDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Tracking Check}}  {{Roll = [[@{TrackDice}@{TrackTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Traps</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Per</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_TrapRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_TrapBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_TrapTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_TrapTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_TrapDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Traps Check}}  {{Roll = [[@{TrapDice}@{TrapTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Weather Sense</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Per</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_WeatherRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_WeatherBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_WeatherTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_WeatherTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_WeatherDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Weather Sense Check}}  {{Roll = [[@{WeatherDice}@{WeatherTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Wilderness Survival</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_WildRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_WildBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_WildTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_WildTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_WildDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Wilderness Survival Check}}  {{Roll = [[@{WildDice}@{WildTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>

                <h2 class="sheet-table-header-collapse">Trade</h2>
                <div class="sheet-empty-cell">
                    <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 class="sheet-wide-table">
                            <tr>
                                <td class="sheet-skillhead" width="18%">Name</td>
                                <td class="sheet-skillhead" width="5%">Cost</td>
                                <td class="sheet-skillhead" width="7%">Attr</td>
                                <td class="sheet-skillhead" width="10%">Rating</td>
                                <td class="sheet-skillhead" width="10%">Bonus</td>
                                <td class="sheet-skillhead" width="10%">Total</td>
                                <td class="sheet-skillhead" width="10%">Tier</td>
                                <td class="sheet-skillhead" width="25%">Dice</td>
                                <td class="sheet-skillhead" width="5%">Roll</td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Armorer</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_ArmorerRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_ArmorerBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_ArmorerTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_ArmorerTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_ArmorerDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Armorer Check}}  {{Roll = [[@{ArmorerDice}@{ArmorerTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Blacksmith</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_BlackRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_BlackBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_BlackTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_BlackTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_BlackDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Blacksmith Check}}  {{Roll = [[@{BlackDice}@{BlackTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Bowyer & Fletcher</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_BowyerRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_BowyerBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_BowyerTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_BowyerTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_BowyerDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Bowyer & Fletcher Check}}  {{Roll = [[@{BowyerDice}@{BowyerTier}@{MenMod}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Brewing</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_BrewRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_BrewBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_BrewTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_BrewTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_BrewDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Brewing Check}}  {{Roll = [[@{BrewDice}@{BrewTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Carpentry</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_CarpRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_CarpBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_CarpTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_CarpTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_CarpDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Carpentry Check}}  {{Roll = [[@{CarpDice}@{CarpTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Farming</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_FarmRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_FarmBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_FarmTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_FarmTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_FarmDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Farming Check}}  {{Roll = [[@{FarmDice}@{FarmTier}@{MenMod}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Leather Working</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_LWorkRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_LWorkBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_LWorkTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_LWorkTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_LWorkDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Leather Working Check}}  {{Roll = [[@{LWorkDice}@{LWorkTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Locksmith</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_LocksmithRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_LocksmithBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_LocksmithTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_LocksmithTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_LocksmithDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Locksmith Check}}  {{Roll = [[@{LocksmithDice}@{LocksmithTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Masonry</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_MasonRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_MasonBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_MasonTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_MasonTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_MasonDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Masonry Check}}  {{Roll = [[@{MasonDice}@{MasonTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Mining</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_MiningRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_MiningBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_MiningTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_MiningTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_MiningDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Mining Check}}  {{Roll = [[@{MiningDice}@{MiningTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Siege Craft</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_SiegeRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_SiegeBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_SiegeTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_SiegeTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_SiegeDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Siege Craft Check}}  {{Roll = [[@{SiegeDice}@{SiegeTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Tinker</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_TinkerRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_TinkerBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_TinkerTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_TinkerTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_TinkerDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Tinker Check}}  {{Roll = [[@{TinkerDice}@{TinkerTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Weaponsmith</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_WpnSmRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_WpnSmBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_WpnSmTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_WpnSmTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_WpnSmDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Weaponsmith Check}}  {{Roll = [[@{WpnSmDice}@{WpnSmTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>

                <h2 class="sheet-table-header-collapse">Travel</h2>
                <div class="sheet-empty-cell">
                    <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 class="sheet-wide-table">
                            <tr>
                                <td class="sheet-skillhead" width="18%">Name</td>
                                <td class="sheet-skillhead" width="5%">Cost</td>
                                <td class="sheet-skillhead" width="7%">Attr</td>
                                <td class="sheet-skillhead" width="10%">Rating</td>
                                <td class="sheet-skillhead" width="10%">Bonus</td>
                                <td class="sheet-skillhead" width="10%">Total</td>
                                <td class="sheet-skillhead" width="10%">Tier</td>
                                <td class="sheet-skillhead" width="25%">Dice</td>
                                <td class="sheet-skillhead" width="5%">Roll</td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Navigation</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Per</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_NavRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_NavBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_NavTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_NavTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_NavDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Navigation Check}}  {{Roll = [[@{NavDice}@{NavTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Riding</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Dex</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_RidingRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_RidingBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_RidingTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_RidingTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_RidingDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Riding Check}}  {{Roll = [[@{RidingDice}@{RidingTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Seafaring</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_SeaRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_SeaBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_SeaTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_SeaTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_SeaDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Seafaring Check}}  {{Roll = [[@{SeaDice}@{SeaTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Skyfaring</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Int</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_SkyRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_SkyBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_SkyTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_SkyTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_SkyDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Skyfaring Check}}  {{Roll = [[@{SkyDice}@{SkyTier}@{MenMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Teamster</td>
                                <td class="sheet-skillstat">1</td>
                                <td class="sheet-skillstat">Dex</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_TeamRating" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-skillfield" name="attr_TeamBonus" value="0" style="width: 2.2em" />
                                </td>
                                <td align="center" class="sheet-descstat">
                                    <input type="text" class="sheet-totalfield" name="attr_TeamTotal" value="-" readonly />
                                </td>
                                <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_TeamTier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select></td>
                                <td align="center" class="sheet-skillstat">
                                    <input type="text" class="sheet-autofield" name="attr_TeamDice" value="" style="width: 10em" readonly />
                                </td>
                                <td align="center"><button type="roll"
                                        value="&{template:default} {{name=Teamster Check}}  {{Roll = [[@{TeamDice}@{TeamTier}@{PhysMod}+?{Modifier|0}]]}}"></button>
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>

                <h2 class="sheet-table-header-collapse">Additional Skills</h2>
                <div class="sheet-empty-cell">
                    <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-wide-table sheet-repeating-section">
                                <tr>
                                    <td class="sheet-skillhead" width="18%">Name</td>
                                    <td class="sheet-skillhead" width="5%">Cost</td>
                                    <td class="sheet-skillhead" width="7%">Attr</td>
                                    <td class="sheet-skillhead" width="10%">Rating</td>
                                    <td class="sheet-skillhead" width="10%">Bonus</td>
                                    <td class="sheet-skillhead" width="10%">Total</td>
                                    <td class="sheet-skillhead" width="10%">Tier</td>
                                    <td class="sheet-skillhead" width="25%">Dice</td>
                                    <td class="sheet-skillhead" width="5%">Roll</td>
                                </tr>
                                <tr>
                                    <td class="sheet-descstat">
                                        <input type="text" name="attr_SkillName" value="" class="sheet-skillname-input" />
                                    </td>
                                    <td align="center" class="sheet-descstat-narrow">
                                        <input type="number" name="attr_SkillCost" value="1" class="sheet-skillfield" />
                                    </td>
                                    <td align="center" class="sheet-descstat">
                                        <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 align="center" class="sheet-descstat">
                                        <input type="number" name="attr_SkillRating" value="0" class="sheet-skillfield" />
                                    </td>
                                    <td align="center" class="sheet-descstat">
                                        <input type="number" name="attr_SkillBonus" value="0" class="sheet-skillfield" />
                                    </td>
                                    <td align="center" class="sheet-descstat">
                                        <input type="text" name="attr_SkillTotal" value="-" readonly class="sheet-totalfield" />
                                    </td>
                                    <td align="center" class="sheet-descstat">
                                        <select name="attr_SkillTier" class="sheet-skilldesclong">
                                            <option value="+0">Basic</option>
                                            <option value="+1">Expert</option>
                                            <option value="+2">Master</option>
                                        </select>
                                    </td>
                                    <td align="center" class="sheet-skillstat">
                                        <input type="text" name="attr_SkillDice" value="" readonly class="sheet-autofield-wide" />
                                        <input type="hidden" name="attr_SkillConditionMod" value="0" />
                                    </td>
                                    <td align="center">
                                        <button type="roll"
                                            value="&{template:default} {{name=@{SkillName} Check}} {{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>



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


        <div class="sheet-flex-section">
            <div class="sheet-column-grow">
                <table class="sheet-wide-table">
                    <tr>
                        <th colspan="3">
                            <h2>Attack & Damage</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="60%">Name</td>
                        <td class="sheet-skillhead" width="20%">Attack</td>
                        <td class="sheet-skillhead" width="20%">Damage</td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Weapon1Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon1Name} Attack}}  {{Roll = [[d20+@{Weapon1Hit}@{PhysMod}+@{Weapon1HitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon1Name} Damage}}  {{Roll = [[(@{Weapon1Dmg}+@{Weapon1DmgBonus}+@{W1DmgMod}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Weapon2Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon2Name} Attack}}  {{Roll = [[d20+@{Weapon2Hit}@{PhysMod}+@{Weapon2HitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon2Name} Damage}}  {{Roll = [[(@{Weapon2Dmg}+@{Weapon2DmgBonus}+@{W2DmgMod}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Weapon3Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon3Name} Attack}}  {{Roll = [[d20+@{Weapon3Hit}@{PhysMod}+@{Weapon3HitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon3Name} Damage}}  {{Roll = [[(@{Weapon3Dmg}+@{Weapon3DmgBonus}+@{W3DmgMod}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Weapon4Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon4Name} Attack}}  {{Roll = [[d20+@{Weapon4Hit}@{PhysMod}+@{Weapon4HitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon4Name} Damage}}  {{Roll = [[(@{Weapon4Dmg}+@{Weapon4DmgBonus}+@{W4DmgMod}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Weapon5Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon5Name} Attack}}  {{Roll = [[d20+@{Weapon5Hit}@{PhysMod}+@{Weapon5HitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon5Name} Damage}}  {{Roll = [[(@{Weapon5Dmg}+@{Weapon5DmgBonus}+@{W5DmgMod}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Weapon6Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon6Name} Attack}}  {{Roll = [[d20+@{Weapon6Hit}@{PhysMod}+@{Weapon6HitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon6Name} Damage}}  {{Roll = [[(@{Weapon6Dmg}+@{Weapon6DmgBonus}+@{W6DmgMod}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_u1" value="Basic Unarmed" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=Unarmed Attack}}  {{Roll = [[d20+@{UnarmedHit}@{PhysMod}+@{UnarmedHitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=Unarmed Damage}}  {{Roll = [[(@{UnarmedDmg}+@{UnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_AltUnarmedName" value="Alternate Unarmed" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{AltUnarmedName} Attack}}  {{Roll = [[d20+@{AltUnarmedHit}@{PhysMod}+@{AltUnarmedHitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{AltUnarmedName} Damage}}  {{Roll = [[(@{AltUnarmedDmg}+@{AltUnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                </table>
            </div>

            <div class="sheet-column-grow">
                <table class="sheet-wide-table">
                    <tr>
                        <th colspan="3">
                            <h2>Spells</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="60%">Name</td>
                        <td class="sheet-skillhead" width="20%">Attack</td>
                        <td class="sheet-skillhead" width="20%">Damage</td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Spell1Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell1Name} Attack}}  {{Roll = [[d20+@{Spell1HitMod}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell1Name} Damage}}  {{Roll = [[(@{Spell1Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Spell2Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell2Name} Attack}}  {{Roll = [[d20+@{Spell2HitMod}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell2Name} Damage}}  {{Roll = [[(@{Spell2Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Spell3Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell3Name} Attack}}  {{Roll = [[d20+@{Spell3HitMod}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell3Name} Damage}}  {{Roll = [[(@{Spell3Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Spell4Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell4Name} Attack}}  {{Roll = [[d20+@{Spell4HitMod}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell4Name} Damage}}  {{Roll = [[(@{Spell4Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Spell5Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell5Name} Attack}}  {{Roll = [[d20+@{Spell5HitMod}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell5Name} Damage}}  {{Roll = [[(@{Spell5Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Spell6Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell6Name} Attack}}  {{Roll = [[d20+@{Spell6HitMod}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell6Name} Damage}}  {{Roll = [[(@{Spell6Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Spell7Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell7Name} Attack}}  {{Roll = [[d20+@{Spell7HitMod}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell7Name} Damage}}  {{Roll = [[(@{Spell7Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Spell8Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell8Name} Attack}}  {{Roll = [[d20+@{Spell8HitMod}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell8Name} Damage}}  {{Roll = [[(@{Spell8Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Spell9Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell9Name} Attack}}  {{Roll = [[d20+@{Spell9HitMod}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell9Name} Damage}}  {{Roll = [[(@{Spell9Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_Spell10Name" value="" style="width: 20em" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell10Name} Attack}}  {{Roll = [[d20+@{Spell10HitMod}@{MenMod}+?{Modifier|0}]]}}"></button>
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=@{Spell10Name} Damage}}  {{Roll = [[(@{Spell10Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                </table>
            </div>

            <div class="sheet-column-grow">
                <table class="sheet-wide-table">
                    <tr>
                        <th colspan="2">
                            <h2>Actions</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="60%">Type</td>
                        <td class="sheet-skillhead" width="20%">Amt</td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Unarmed</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_UnarmedActions" value="0" style="width: 2.2em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Melee</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_MeleeActions" value="0" style="width: 2.2em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Projectile</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_ProjActions" value="0" style="width: 2.2em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Magic</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_MagicActions" value="0" style="width: 2.2em" />
                        </td>
                    </tr>
                </table>
            </div>

            <div class="sheet-column-grow">
                <table class="sheet-wide-table">
                    <tr>
                        <th colspan="3">
                            <h2>Defense</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead">Type</td>
                        <td class="sheet-skillhead">Bonus</td>
                        <td class="sheet-skillhead">Roll</td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Dodge</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-desctotalfield" name="attr_DefModTotal" value="0" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll" value="&{template:default} {{name=Dodge Roll}}  {{Roll = [[d20+@{DefModTotal}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Parry</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_ParryBonus" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll" value="&{template:default} {{name=Parry Roll}}  {{Roll = [[d20+@{DefModTotal}+@{ParryBonus}-1+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Block w/ Melee</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_BlockBonus" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll" value="&{template:default} {{name=Block Roll}}  {{Roll = [[d20+@{DefModTotal}+@{BlockBonus}+1+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Block w/ Shield</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_ShieldBlockBonus" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll"
                                value="&{template:default} {{name=Shield Block}}  {{Roll = [[d20+@{DefModTotal}+@{ShieldBlockBonus}+@{ShieldCover}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Mental Defense</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-desctotalfield" name="attr_MenDefTotal" value="0" readonly />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <button type="roll" value="&{template:default} {{name=Mental Defense}}  {{Roll = [[d20+@{MenDefTotal}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                </table>
            </div>

            <div class="sheet-column-grow">
                <table class="sheet-wide-table">
                    <tr>
                        <th colspan="3">
                            <h2>Initiative</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillname" width="70%">Initiative</td>
                        <td align="center" class="sheet-descstat" width="30%">
                            <button type="roll"
                                value="&{template:default} {{name=Initiative Roll}}  {{@{selected|token_name} rolls a [[1d10!+@{selected|InitModTotal}+?{Modifier|0}&{tracker}]]}}"></button>
                        </td>
                    </tr>
                </table>
            </div>

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

            <div class="sheet-column-grow">
                <table class="sheet-wide-table">
                    <tr>
                        <th colspan="2">
                            <h2>Resistances</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Fire</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_FireRes" value="0" style="width: 3em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Cold</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_ColdRes" value="0" style="width: 3em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Toxic</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_ToxicRes" value="0" style="width: 3em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Electrical</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_ElecRes" value="0" style="width: 3em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Sonic</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_SonicRes" value="0" style="width: 3em" />
                        </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-wide-table sheet-spacer-top-margin">
                    <tr>
                        <th colspan="4">
                            <h2>Unarmed</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%">Name</td>
                        <td class="sheet-skillhead" width="20%">Hit Bonus</td>
                        <td class="sheet-skillhead" width="20%">Specialization</td>
                        <td class="sheet-skillhead" width="10%">Hit</td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname sheet-read-only-field">Basic Unarmed</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_UnarmedHitBonus" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-autofield" name="attr_UnarmedHit" value="0" readonly />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=Unarmed Attack}}  {{Roll = [[d20+@{UnarmedHit}@{PhysMod}+@{UnarmedHitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%">Accessory</td>
                        <td class="sheet-skillhead" width="20%">Bonus Dmg</td>
                        <td class="sheet-skillhead" width="20%">Damage</td>
                        <td class="sheet-skillhead" width="10%">Dmg</td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-attfield" name="attr_UnarmedAccessory" value="" style="width: 20em" />
                        </td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_UnarmedDmgBonus" value="0" style="width: 10em" />
                        </td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="hidden" name="attr_UnarmedRank" value="0" />
                            <input type="hidden" name="attr_RaceUnarmedRank" value="3" />
                            <input type="text" class="sheet-autofield" name="attr_UnarmedDmg" value="d6!" style="width: 10em" readonly />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=Unarmed Damage}}  {{Roll = [[(@{UnarmedDmg}+@{UnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr class="sheet-blankrow"></tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%">Name</td>
                        <td class="sheet-skillhead" width="20%">Hit Bonus</td>
                        <td class="sheet-skillhead" width="20%">Specialization</td>
                        <td class="sheet-skillhead" width="10%">Hit</td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-autofield" name="attr_AltUnarmedName" value="Alternate Unarmed" style="width: 20em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_AltUnarmedHitBonus" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-autofield" name="attr_AltUnarmedHit" value="0" readonly />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{AltUnarmedName} Attack}}  {{Roll = [[d20+@{AltUnarmedHit}@{PhysMod}+@{AltUnarmedHitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%">Accessory</td>
                        <td class="sheet-skillhead" width="20%">Bonus Dmg</td>
                        <td class="sheet-skillhead" width="20%">Damage</td>
                        <td class="sheet-skillhead" width="10%">Dmg</td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-attfield" name="attr_AltUnarmedAccessory" value="" style="width: 20em" />
                        </td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_AltUnarmedDmgBonus" value="0" style="width: 10em" />
                        </td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-autofield" name="attr_AltUnarmedDmg" value="d6!" style="width: 10em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{AltUnarmedName} Damage}}  {{Roll = [[(@{AltUnarmedDmg}+@{AltUnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                </table>

                <table class="sheet-wide-table sheet-spacer-top-margin">
                    <tr>
                        <th colspan="4">
                            <h2>Primary Weapon</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%">Name</td>
                        <td class="sheet-skillhead" width="20%">Hit Bonus</td>
                        <td class="sheet-skillhead" width="20%">Specialization</td>
                        <td class="sheet-skillhead" width="10%">Hit</td>
                    </tr>

                    <!--WEAPONS-->
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-attfield" name="attr_Weapon1Name" value="" style="width: 20em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon1HitBonus" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon1Hit" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon1Name} Attack}}  {{Roll = [[d20+@{Weapon1Hit}@{PhysMod}+@{Weapon1HitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%"></td>
                        <td class="sheet-skillhead" width="20%">Bonus Dmg</td>
                        <td class="sheet-skillhead" width="20%">Damage</td>
                        <td class="sheet-skillhead" width="10%">Dmg</td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Damage:</td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_Weapon1DmgBonus" value="0" style="width: 10em" />
                        </td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_Weapon1Dmg" value="0" style="width: 10em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon1Name} Damage}}  {{Roll = [[(@{Weapon1Dmg}+@{Weapon1DmgBonus}+@{W1DmgMod}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Accessory:</td>
                        <td class="sheet-smallname" colspan="2">
                            <input type="text" class="sheet-attfield" name="attr_Weapon1Acc" value="" style="width: 20em" />
                        </td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Type:</td>
                        <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_W1Type">
                                <option value="m">Melee</option>
                                <option value="r">Ranged</option>
                                <option value="o">Other</option>
                            </select></td>
                        <td><input type="hidden" name="attr_W1DmgMod" value="0" /></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Durability:</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Weapon1Dur" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Weight:</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Weapon1Wgt" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Ammo:</td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon1Ammo" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                </table>

                <table class="sheet-wide-table sheet-spacer-top-margin">
                    <tr>
                        <th colspan="4">
                            <h2>Secondary Weapon</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%">Name</td>
                        <td class="sheet-skillhead" width="20%">Hit Bonus</td>
                        <td class="sheet-skillhead" width="20%">Specialization</td>
                        <td class="sheet-skillhead" width="10%">Hit</td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-attfield" name="attr_Weapon2Name" value="" style="width: 20em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon2HitBonus" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon2Hit" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon2Name} Attack}}  {{Roll = [[d20+@{Weapon2Hit}@{PhysMod}+@{Weapon2HitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%"></td>
                        <td class="sheet-skillhead" width="20%">Bonus Dmg</td>
                        <td class="sheet-skillhead" width="20%">Damage</td>
                        <td class="sheet-skillhead" width="10%">Dmg</td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Damage:</td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_Weapon2DmgBonus" value="0" style="width: 10em" />
                        </td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_Weapon2Dmg" value="0" style="width: 10em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon2Name} Damage}}  {{Roll = [[(@{Weapon2Dmg}+@{Weapon2DmgBonus}+@{W2DmgMod}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Accessory:</td>
                        <td class="sheet-smallname" colspan="2">
                            <input type="text" class="sheet-attfield" name="attr_Weapon2Acc" value="" style="width: 20em" />
                        </td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Type:</td>
                        <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_W2Type">
                                <option value="m">Melee</option>
                                <option value="r">Ranged</option>
                                <option value="o">Other</option>
                            </select></td>
                        <td><input type="hidden" name="attr_W2DmgMod" value="0" /></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Durability:</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Weapon2Dur" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Weight:</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Weapon2Wgt" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Ammo:</td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon2Ammo" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr class="sheet-blankrow"></tr>
                </table>

                <table class="sheet-wide-table sheet-spacer-top-margin">
                    <tr>
                        <th colspan="4">
                            <h2>Third Weapon</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%">Name</td>
                        <td class="sheet-skillhead" width="20%">Hit Bonus</td>
                        <td class="sheet-skillhead" width="20%">Specialization</td>
                        <td class="sheet-skillhead" width="10%">Hit</td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-attfield" name="attr_Weapon3Name" value="" style="width: 20em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon3HitBonus" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon3Hit" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon3Name} Attack}}  {{Roll = [[d20+@{Weapon3Hit}@{PhysMod}+@{Weapon3HitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%"></td>
                        <td class="sheet-skillhead" width="20%">Bonus Dmg</td>
                        <td class="sheet-skillhead" width="20%">Damage</td>
                        <td class="sheet-skillhead" width="10%">Dmg</td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Damage:</td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_Weapon3DmgBonus" value="0" style="width: 10em" />
                        </td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_Weapon3Dmg" value="0" style="width: 10em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon3Name} Damage}}  {{Roll = [[(@{Weapon3Dmg}+@{Weapon3DmgBonus}+@{W3DmgMod}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Accessory:</td>
                        <td class="sheet-smallname" colspan="2">
                            <input type="text" class="sheet-attfield" name="attr_Weapon3Acc" value="" style="width: 20em" />
                        </td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Type:</td>
                        <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_W3Type">
                                <option value="m">Melee</option>
                                <option value="r">Ranged</option>
                                <option value="o">Other</option>
                            </select></td>
                        <td><input type="hidden" name="attr_W3DmgMod" value="0" /></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Durability:</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Weapon3Dur" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Weight:</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Weapon3Wgt" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Ammo:</td>
                        <td class="sheet-skilstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon3Ammo" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                </table>

                <table class="sheet-wide-table sheet-spacer-top-margin">
                    <tr>
                        <th colspan="4">
                            <h2>Fourth Weapon</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%">Name</td>
                        <td class="sheet-skillhead" width="20%">Hit Bonus</td>
                        <td class="sheet-skillhead" width="20%">Specialization</td>
                        <td class="sheet-skillhead" width="10%">Hit</td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-attfield" name="attr_Weapon4Name" value="" style="width: 20em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon4HitBonus" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon4Hit" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon4Name} Attack}}  {{Roll = [[d20+@{Weapon4Hit}@{PhysMod}+@{Weapon4HitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%"></td>
                        <td class="sheet-skillhead" width="20%">Bonus Dmg</td>
                        <td class="sheet-skillhead" width="20%">Damage</td>
                        <td class="sheet-skillhead" width="10%">Dmg</td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Damage:</td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_Weapon4DmgBonus" value="0" style="width: 10em" />
                        </td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_Weapon4Dmg" value="0" style="width: 10em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon4Name} Damage}}  {{Roll = [[(@{Weapon4Dmg}+@{Weapon4DmgBonus}+@{W4DmgMod}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Accessory:</td>
                        <td class="sheet-smallname" colspan="2">
                            <input type="text" class="sheet-attfield" name="attr_Weapon4Acc" value="" style="width: 20em" />
                        </td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Type:</td>
                        <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_W4Type">
                                <option value="m">Melee</option>
                                <option value="r">Ranged</option>
                                <option value="o">Other</option>
                            </select></td>
                        <td><input type="hidden" name="attr_W4DmgMod" value="0" /></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Durability:</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Weapon4Dur" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Weight:</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Weapon4Wgt" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Ammo:</td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon4Ammo" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                </table>

                <table class="sheet-wide-table sheet-spacer-top-margin">
                    <tr>
                        <th colspan="4">
                            <h2>Fifth Weapon</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%">Name</td>
                        <td class="sheet-skillhead" width="20%">Hit Bonus</td>
                        <td class="sheet-skillhead" width="20%">Specialization</td>
                        <td class="sheet-skillhead" width="10%">Hit</td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-attfield" name="attr_Weapon5Name" value="" style="width: 20em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon5HitBonus" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon5Hit" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon5Name} Attack}}  {{Roll = [[d20+@{Weapon5Hit}@{PhysMod}+@{Weapon5HitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%"></td>
                        <td class="sheet-skillhead" width="20%">Bonus Dmg</td>
                        <td class="sheet-skillhead" width="20%">Damage</td>
                        <td class="sheet-skillhead" width="10%">Dmg</td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Damage:</td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_Weapon5DmgBonus" value="0" style="width: 10em" />
                        </td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_Weapon5Dmg" value="0" style="width: 10em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon5Name} Damage}}  {{Roll = [[(@{Weapon5Dmg}+@{Weapon5DmgBonus}+@{W5DmgMod}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Accessory:</td>
                        <td class="sheet-smallname" colspan="2">
                            <input type="text" class="sheet-attfield" name="attr_Weapon5Acc" value="" style="width: 20em" />
                        </td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Type:</td>
                        <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_W5Type">
                                <option value="m">Melee</option>
                                <option value="r">Ranged</option>
                                <option value="o">Other</option>
                            </select></td>
                        <td><input type="hidden" name="attr_W5DmgMod" value="0" /></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Durability:</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Weapon5Dur" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Weight:</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Weapon5Wgt" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Ammo:</td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon5Ammo" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                </table>

                <table class="sheet-wide-table sheet-spacer-top-margin">
                    <tr>
                        <th colspan="4">
                            <h2>Sixth Weapon</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%">Name</td>
                        <td class="sheet-skillhead" width="20%">Hit Bonus</td>
                        <td class="sheet-skillhead" width="20%">Specialization</td>
                        <td class="sheet-skillhead" width="10%">Hit</td>
                    </tr>
                    <tr>
                        <td class="sheet-smallname">
                            <input type="text" class="sheet-attfield" name="attr_Weapon6Name" value="" style="width: 20em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon6HitBonus" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon6Hit" value="0" style="width: 2.2em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon6Name} Attack}}  {{Roll = [[d20+@{Weapon6Hit}@{PhysMod}+@{Weapon6HitBonus}+?{Modifier|0}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="50%"></td>
                        <td class="sheet-skillhead" width="20%">Bonus Dmg</td>
                        <td class="sheet-skillhead" width="15%">Damage</td>
                        <td class="sheet-skillhead" width="15%">Dmg</td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Damage:</td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_Weapon6DmgBonus" value="0" style="width: 10em" />
                        </td>
                        <td align="center" class="sheet-descstatsmall">
                            <input type="text" class="sheet-attfield" name="attr_Weapon6Dmg" value="0" style="width: 10em" />
                        </td>
                        <td align="center">
                            <button type="roll"
                                value="&{template:default} {{name=@{Weapon6Name} Damage}}  {{Roll = [[(@{Weapon6Dmg}+@{Weapon6DmgBonus}+@{W6DmgMod}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Accessory:</td>
                        <td class="sheet-smallname" colspan="2">
                            <input type="text" class="sheet-attfield" name="attr_Weapon6Acc" value="" style="width: 20em" />
                        </td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Type:</td>
                        <td align="center" class="sheet-descstat"><select class="sheet-skilldesclong" name="attr_W6Type">
                                <option value="m">Melee</option>
                                <option value="r">Ranged</option>
                                <option value="o">Other</option>
                            </select></td>
                        <td><input type="hidden" name="attr_W6DmgMod" value="0" /></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Durability:</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Weapon6Dur" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Weight:</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Weapon6Wgt" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Ammo:</td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Weapon6Ammo" value="" style="width: 7em" />
                        </td>
                        <td></td>
                        <td></td>
                    </tr>
                </table>
            </div>

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

                <table class="sheet-wide-table sheet-spacer-top-margin">
                    <tr>
                        <th colspan="4">
                            <h2>Shield</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead" width="35%">Slot</td>
                        <td class="sheet-skillhead" width="45%">Name</td>
                        <td class="sheet-skillhead" width="15%">SHP</td>
                        <td class="sheet-skillhead" width="10%">Cover</td>
                    </tr>
                    <tr>
                        <td class="sheet-skillname">Shield</td>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_ShieldName" value="" style="width: 18em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_ShieldDur" value="0" style="width: 3em" />
                        </td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_ShieldCover" value="0" style="width: 2.2em" />
                        </td>
                    </tr>
                </table>

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

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

                <table class="sheet-wide-table sheet-spacer-top-margin">
                    <tr>
                        <th colspan="2">
                            <h2>Money</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead">Type</td>
                        <td class="sheet-skillhead">Amount</td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead">Mertacullum</td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Mertacullum" value="0" style="width: 18em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead">Gold Talons</td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Gold" value="0" style="width: 18em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead">Silver (shillings)</td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Silver" value="0" style="width: 18em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead">Copper (crets)</td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Copper" value="0" style="width: 18em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead">Bones (bits)</td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Bones" value="0" style="width: 18em" />
                        </td>
                    </tr>
                </table>

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

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

                <table class="sheet-wide-table sheet-spacer-top-margin">
                    <tr>
                        <th colspan="2">
                            <h2>Equipment (Belt)</h2>
                        </th>
                    </tr>
                    <tr>
                        <td class="sheet-skillhead">Name</td>
                        <td class="sheet-skillhead">Amount</td>
                    </tr>
                    <tr>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Belt1Name" value="" style="width: 22em" />
                        </td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Belt1Amt" value="0" style="width: 5em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Belt2Name" value="" style="width: 22em" />
                        </td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Belt2Amt" value="0" style="width: 5em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Belt3Name" value="" style="width: 22em" />
                        </td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Belt3Amt" value="0" style="width: 5em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Belt4Name" value="" style="width: 22em" />
                        </td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Belt4Amt" value="0" style="width: 5em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Belt5Name" value="" style="width: 22em" />
                        </td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Belt5Amt" value="0" style="width: 5em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Belt6Name" value="" style="width: 22em" />
                        </td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Belt6Amt" value="0" style="width: 5em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Belt7Name" value="" style="width: 22em" />
                        </td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Belt7Amt" value="0" style="width: 5em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Belt8Name" value="" style="width: 22em" />
                        </td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Belt8Amt" value="0" style="width: 5em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Belt9Name" value="" style="width: 22em" />
                        </td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Belt9Amt" value="0" style="width: 5em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-skillstat">
                            <input type="text" class="sheet-attfield" name="attr_Belt10Name" value="" style="width: 22em" />
                        </td>
                        <td class="sheet-skillstat">
                            <input type="number" class="sheet-attfield" name="attr_Belt10Amt" value="0" style="width: 5em" />
                        </td>
                    </tr>
                </table>


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

                <fieldset class="repeating_equip">
                    <table class="sheet-wide-table sheet-repeating-section">
                        <tr>
                            <td class="sheet-skillhead">Name</td>
                            <td class="sheet-skillhead">Amount</td>
                            <td class="sheet-skillhead">Weight</td>
                        </tr>
                        <tr>
                            <td align="center" class="sheet-descstatsmall" width="60%">
                                <input type="text" class="sheet-attfield" name="attr_EquipName" value="" style="width: 25em" />
                            </td>
                            <td class="sheet-skillstat" width="20%">
                                <input type="number" class="sheet-attfield" name="attr_EquipAmt" value="0" style="width: 5em" />
                            </td>
                            <td class="sheet-skillstat" width="20%">
                                <input type="text" class="sheet-attfield" name="attr_EquipWgt" value="" style="width: 5em" />
                            </td>
                        </tr>
                    </table>
                    <table width="100%">
                        <tr>
                            <td align="left" width="20%" class="sheet-skillhead">Notes</td>
                            <td align="center" width="80%" class="sheet-descstatsmall">
                                <input type="text" class="sheet-attfield" name="attr_EquipNotes" value="" style="width: 33em" />
                            </td>
                        </tr>
                    </table>
                </fieldset>

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


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

                <fieldset class="repeating_trans">
                    <table class="sheet-wide-table sheet-repeating-section">
                        <tr>
                            <td class="sheet-skillhead" width="40%">Type</td>
                            <td class="sheet-skillhead" width="40%">Name</td>
                            <td class="sheet-skillhead" width="20%">Speed</td>
                        </tr>
                        <tr>
                            <td align="center" class="sheet-descstatsmall">
                                <input type="text" class="sheet-attfield" name="attr_TransType" value="" style="width: 16em" />
                            </td>
                            <td align="center" class="sheet-descstatsmall">
                                <input type="text" class="sheet-attfield" name="attr_TransName" value="" style="width: 16em" />
                            </td>
                            <td align="center" class="sheet-skillstat">
                                <input type="text" class="sheet-attfield" name="attr_TransSpd" value="" style="width: 5em" />
                            </td>
                        </tr>
                        <tr>
                            <td class="sheet-skillhead" colspan="3">Accessories</td>
                        </tr>
                        <tr>
                            <td align="center" valign="center" class="sheet-skillstat" colspan="3">
                                <textarea style="height: 4em; width: 38em" class="sheet-text-area-full" name="attr_TransAcc" value=""></textarea>
                            </td>
                        </tr>
                        <tr class="sheet-blankrow"></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-wide-table sheet-repeating-section">
                        <tr>
                            <td class="sheet-skillhead" width="50%">Name</td>
                            <td class="sheet-skillhead" width="25%">Income</td>
                            <td class="sheet-skillhead" width="25%">Upkeep</td>
                        </tr>
                        <tr>
                            <td align="center" class="sheet-descstatsmall">
                                <input type="text" class="sheet-attfield" name="attr_HideoutName" value="" style="width: 18em" />
                            </td>
                            <td align="center" class="sheet-skillstat">
                                <input type="text" class="sheet-attfield" name="attr_HideoutIncome" value="" style="width: 7em" />
                            </td>
                            <td align="center" class="sheet-skillstat">
                                <input type="text" class="sheet-attfield" name="attr_HideoutUpkeep" value="" style="width: 7em" />
                            </td>
                        </tr>
                        <tr>
                            <td class="sheet-skillhead" colspan="3">Notes</td>
                        </tr>
                        <tr>
                            <td align="center" valign="center" class="sheet-skillstat" colspan="3">
                                <textarea style="height: 4em; width: 38em" 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">
                <h2>Details</h2>

                <table class="sheet-wide-table-auto">
                    <tr>
                        <td class="sheet-attname">Soul Points</td>
                        <td align="center" class="sheet-descstat">
                            <input type="number" class="sheet-attfield" name="attr_SoulPoints" value="0" style="width: 5em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-attname" width="15%">Path</td>
                        <td align="center" class="sheet-descstat" width="20%">
                            <input type="text" class="sheet-attfield" name="attr_ReligionPath" value="" style="width: 12em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-attname" rowspan="3">Gods</td>
                        <td align="center" class="sheet-descstat">
                            <input type="text" class="sheet-attfield" name="attr_Gods1" value="" style="width: 12em" />
                        </td>
                    </tr>
                    <tr>
                        <td align="center" class="sheet-descstat">
                            <input type="text" class="sheet-attfield" name="attr_Gods2" value="" style="width: 12em" />
                        </td>
                    </tr>
                    <tr>
                        <td align="center" class="sheet-descstat">
                            <input type="text" class="sheet-attfield" name="attr_Gods3" value="" style="width: 12em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-attname" width="15%">Spirit Animal</td>
                        <td align="center" class="sheet-descstat" width="20%">
                            <input type="text" class="sheet-attfield" name="attr_SpiritAnimal" value="" style="width: 12em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-attname" width="15%">Astrological Sign</td>
                        <td align="center" class="sheet-descstat" width="20%">
                            <input type="text" class="sheet-attfield" name="attr_AstSign" value="" style="width: 12em" />
                        </td>
                    </tr>
                    <tr>
                        <td class="sheet-attname" width="15%">Fate Power</td>
                        <td align="center" class="sheet-descstat" width="20%">
                            <input type="text" class="sheet-attfield" name="attr_FatePower" value="" style="width: 12em" />
                        </td>
                    </tr>
                </table>
            </div>

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

                <div class="sheet-spiritual-influence-wrapper">
                    <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:default} {{name=Spiritual Influence Check}}  {{Successes = [[{(1d100 + ?{Modifier|0})}<@{SpiritInf}]]}}">
                        Roll Spiritual Influence
                    </button>
                </div>
            </div>
        </div>


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

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

        <h2 class="sheet-spacer-top-margin sheet-table-header-collapse">Additional Spells</h2>
        <div class="sheet-empty-cell">
            <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 class="sheet-wide-table-auto">
                        <tr>
                            <th class="sheet-skillhead" width="18%">Name</th>
                            <th class="sheet-skillhead" width="10%">Area</th>
                            <th class="sheet-skillhead" width="10%" colspan="2">Duration</th>
                            <th class="sheet-skillhead" width="10%">Protection</th>
                            <th class="sheet-skillhead" width="5%">Actions</th>
                            <th class="sheet-skillhead" width="45%">Description</th>
                        </tr>
                        <tr>
                            <td class="sheet-smallname">
                                <input type="text" class="sheet-attfield" name="attr_SpellName" value="" style="width: 18em" />
                            </td>
                            <td class="sheet-smallname">
                                <input type="text" class="sheet-attfield" name="attr_SpellArea" value="" style="width: 9em" />
                            </td>
                            <td class="sheet-smallname" colspan="2">
                                <input type="text" class="sheet-attfield" name="attr_SpellDur" value="" style="width: 9em" />
                            </td>
                            <td class="sheet-smallname">
                                <input type="text" class="sheet-attfield" name="attr_SpellProt" value="" style="width: 9em" />
                            </td>
                            <td align="center" class="sheet-descstat">
                                <input type="number" class="sheet-attfield" name="attr_SpellAct" value="0" style="width: 2.2em" />
                            </td>
                            <td align="center" class="sheet-skillstat" rowspan="4">
                                <textarea class="sheet-text-area-full" name="attr_SpellDesc" value=""></textarea>
                            </td>
                        </tr>
                        <tr>
                            <td align="center" class="sheet-smallname" rowspan="2"><button type="roll" class="sheet-valuebutton"
                                    value="&{template:default} {{name=@{SpellName}}} {{Area = @{SpellArea}}} {{Duration = @{SpellDur}}} {{Protection = @{SpellProt}}} {{Actions = @{SpellAct}}} {{Drain = @{SpellDrain}}} {{Description = @{SpellDesc}}}">Display
                                    Info</button></td>
                            <td class="sheet-skillhead">Drain</td>
                            <td class="sheet-skillhead">+ To Hit</td>
                            <td class="sheet-skillhead">Attack</td>
                            <td class="sheet-skillhead">Effect</td>
                            <td class="sheet-skillhead">Roll</td>
                        </tr>
                        <tr>
                            <td align="center" class="sheet-descstat">
                                <input type="number" class="sheet-attfield" name="attr_SpellDrain" value="0" style="width: 5em" />
                            </td>
                            <td align="center" class="sheet-descstat">
                                <input type="number" class="sheet-attfield" name="attr_SpellHitMod" value="0" style="width: 2.2em" />
                            </td>
                            <td align="center">
                                <button type="roll"
                                    value="&{template:default} {{name=@{SpellName} Attack}}  {{Roll = [[d20+@{SpellHitMod}@{MenMod}+?{Modifier|0}]]}}"></button>
                            </td>
                            <td class="sheet-smallname">
                                <input type="text" class="sheet-attfield" name="attr_SpellDmg" value="" style="width: 9em" />
                            </td>
                            <td align="center">
                                <button type="roll"
                                    value="&{template:default} {{name=@{SpellName} Damage}}  {{Roll = [[(@{SpellDmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"></button>
                            </td>
                        </tr>
                        <tr class="sheet-blankrow"></tr>
                    </table>
                </fieldset>
            </div>
        </div>

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

        <h2 class="sheet-spacer-top-margin sheet-table-header-collapse">Abilities</h2>
        <div class="sheet-empty-cell">
            <input type="checkbox" name="attr_ChiAbilitiesExpanded" checked="true" class="sheet-expand-collapse-checkbox">
            <span class="sheet-expand-collapse-symbol"></span>
            <div class="sheet-collapsible">

                <table class="sheet-wide-table-auto">
                    <tr>
                        <td class="sheet-skillhead" width="18%">Name</td>
                        <td class="sheet-skillhead" width="5%">Rating</td>
                        <td class="sheet-skillhead" width="10%">Drain</td>
                        <td class="sheet-skillhead" width="65%">Description</td>
                    </tr>
                    <tr>
                        <td colspan="4">
                            <fieldset class="repeating_chiabilities">
                                <table class="sheet-wide-table-auto">
                                    <tr>
                                        <td class="sheet-smallname" width="20%">
                                            <input type="text" class="sheet-attfield" name="attr_ChiAbilityName" value="" style="width: 18em" />
                                        </td>
                                        <td align="center" class="sheet-descstat" width="5%">
                                            <input type="number" class="sheet-attfield" name="attr_ChiAbilityRating" value="1" style="width: 2.2em" />
                                        </td>
                                        <td class="sheet-smallname" width="10%">
                                            <input type="text" class="sheet-attfield" name="attr_ChiAbilityDrain" value="" style="width: 9em" />
                                        </td>
                                        <td align="center" class="sheet-skillstat" width="65%">
                                            <textarea style="width: 55em" class="sheet-text-area-full" name="attr_ChiAbilityDesc" value=""></textarea>
                                        </td>
                                    </tr>
                                </table>
                            </fieldset>
                        </td>
                    </tr>
                </table>
            </div>
        </div>


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

        <h2 class="sheet-spacer-top-margin sheet-table-header-collapse">Formulae</h2>
        <div class="sheet-empty-cell">
            <input type="checkbox" name="attr_AlchemicalFormulaeExpanded" checked="true" class="sheet-expand-collapse-checkbox">
            <span class="sheet-expand-collapse-symbol"></span>
            <div class="sheet-collapsible">

                <table class="sheet-wide-table-auto">
                    <tr>
                        <td class="sheet-skillhead" width="20%">Item</td>
                        <td class="sheet-skillhead" width="40%">Ingredients Necessary</td>
                        <td class="sheet-skillhead" width="40%">Units Harvested</td>
                    </tr>
                    <tr>
                        <td colspan="3">
                            <fieldset class="repeating_alchemical">
                                <table width="100%">
                                    <tr>
                                        <td class="sheet-smallname" width="20%">
                                            <input type="text" class="sheet-attfield" name="attr_FormulaName" value="" style="width: 18em" />
                                        </td>
                                        <td class="sheet-smallname" width="40%">
                                            <input type="text" class="sheet-attfield" name="attr_FormulaIngr" value="" style="width: 35em" />
                                        </td>
                                        <td class="sheet-smallname" width="40%">
                                            <input type="text" class="sheet-attfield" name="attr_FormulaHarv" value="" style="width: 35em" />
                                        </td>
                                    </tr>
                                </table>
                            </fieldset>
                        </td>
                    </tr>
                </table>
            </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-input-full sheet-tall-control" placeholder="Name of trait" />
                            </div>
                            <div class="sheet-flex-form-fixed sheet-empty-cell sheet-tall-control">
                                <button type="roll" class="sheet-button sheet-button-small" value="&{template:default} {{name=@{TraitName}}} {{o = @{TraitDesc}}}">
                                    Display in Chat
                                </button>
                            </div>
                        </div>
                        <div class="sheet-empty-cell">
                            <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-full sheet-input-wide sheet-tall-control sheet-input-like">Vision</div>
                        </div>
                        <div class="sheet-flex-form-fixed sheet-empty-cell sheet-tall-control">
                            <button type="roll" class="sheet-button sheet-button-small" value="&{template:default} {{name=Vision}} {{o = @{Vision}}}">
                                Display in Chat
                            </button>
                        </div>
                    </div>
                    <div class="sheet-empty-cell">
                        <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-input-full sheet-tall-control"
                                    placeholder="Name of racial ability" />
                            </div>
                            <div class="sheet-flex-form-fixed sheet-empty-cell sheet-tall-control">
                                <button type="roll" class="sheet-button sheet-button-small" value="&{template:default} {{name=@{RaceAbilName}}} {{o = @{RaceAbilDesc}}}">
                                    Display in Chat
                                </button>
                            </div>
                        </div>
                        <div class="sheet-empty-cell">
                            <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-input-full sheet-tall-control" placeholder="Name of talent" />
                            </div>
                            <div class="sheet-flex-form-fixed sheet-empty-cell sheet-tall-control">
                                <button type="roll" class="sheet-button sheet-button-small" value="&{template:default} {{name=@{TalentName}}} {{o = @{TalentDesc}}}">
                                    Display in Chat
                                </button>
                            </div>
                        </div>
                        <div class="sheet-empty-cell">
                            <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-input-full sheet-tall-control"
                                    placeholder="Name of class ability" />
                            </div>
                            <div class="sheet-flex-form-fixed sheet-empty-cell sheet-tall-control">
                                <button type="roll" class="sheet-button sheet-button-small"
                                    value="&{template:default} {{name=@{ClassAbilName}}} {{o = @{ClassAbilDesc}}}">
                                    Display in Chat
                                </button>
                            </div>
                        </div>
                        <div class="sheet-empty-cell">
                            <input type="checkbox" name="attr_ClassAbilExpanded" checked="true" class="sheet-expand-collapse-checkbox">
                            <span class="sheet-expand-collapse-symbol"></span>
                            <textarea class="sheet-text-area-full sheet-collapsible" name="attr_ClassAbilDesc" value=""
                                placeholder="Description of class ability"></textarea>
                        </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">
                        <table class="sheet-wide-table">
                            <tr>
                                <td class="sheet-attname" width="65%">Total Rep Pts</td>
                                <td align="center" class="sheet-descstat" width="35%">
                                    <input type="number" class="sheet-attfield" name="attr_TotalReputation" value="0" style="width: 5em" />
                                </td>
                            </tr>
                        </table>

                        <table class="sheet-wide-table">
                            <tr>
                                <td class="sheet-attname">Honor</td>
                                <td align="center" class="sheet-descstat">
                                    <input type="number" class="sheet-attfield" name="attr_HonorRep" value="0" style="width: 5em" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillhead">Location</td>
                                <td class="sheet-skillhead">Amt</td>
                            </tr>
                            <tr>
                                <td colspan="2">
                                    <fieldset class="repeating_honorrep">
                                        <div class="sheet-repeating-section">
                                            <table width="100%">
                                                <tr>
                                                    <td class="sheet-smallname" width="65%">
                                                        <input type="text" class="sheet-attfield" name="attr_HonorRepName" value="" style="width: 17em" />
                                                    </td>
                                                    <td align="center" class="sheet-descstat" width="35%">
                                                        <input type="number" class="sheet-attfield" name="attr_HonorRepAmt" value="0" style="width: 5em" />
                                                    </td>
                                                </tr>
                                            </table>
                                        </div>
                                    </fieldset>
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table class="sheet-wide-table">
                            <tr>
                                <td class="sheet-attname" width="65%">Glory</td>
                                <td align="center" class="sheet-descstat" width="35%">
                                    <input type="number" class="sheet-attfield" name="attr_Glory" value="0" style="width: 2.2em" />%
                                </td>
                            </tr>
                        </table>

                        <table class="sheet-wide-table">
                            <tr>
                                <td class="sheet-attname" width="65%">Corruption</td>
                                <td align="center" class="sheet-descstat" width="35%">
                                    <input type="number" class="sheet-attfield" name="attr_CorruptRep" value="0" style="width: 5em" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillhead">Location</td>
                                <td class="sheet-skillhead">Amt</td>
                            </tr>
                            <tr>
                                <td colspan="2">
                                    <fieldset class="repeating_corruptrep">
                                        <div class="sheet-repeating-section">
                                            <table class="sheet-wide-table">
                                                <tr>
                                                    <td class="sheet-smallname" width="65%">
                                                        <input type="text" class="sheet-attfield" name="attr_CorruptRepName" value="" style="width: 17em" />
                                                    </td>
                                                    <td align="center" class="sheet-descstat" width="35%">
                                                        <input type="number" class="sheet-attfield" name="attr_CorruptRepAmt" value="0" style="width: 5em" />
                                                    </td>
                                                </tr>
                                            </table>
                                        </div>
                                    </fieldset>
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>
            </div>

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

                <table class="sheet-wide-table sheet-spacer-top-margin">
                    <tr>
                        <td class="sheet-skillhead" width="80%">Name</td>
                        <td class="sheet-skillhead" width="20%">Rank</td>
                    </tr>
                    <tr>
                        <td colspan="2">
                            <fieldset class="repeating_knownchars">
                                <div class="sheet-repeating-section">
                                    <table class="sheet-wide-table">
                                        <tr>
                                            <td class="sheet-smallname" width="80%">
                                                <input type="text" class="sheet-attfield" name="attr_KnownCharName" value="" style="width: 20em" />
                                            </td>
                                            <td align="center" class="sheet-descstat" width="20%">
                                                <input type="number" class="sheet-attfield" name="attr_KnownCharRank" value="0" style="width: 2.2em" />
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </fieldset>
                        </td>
                    </tr>
                </table>
            </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-input-full sheet-tall-control" placeholder="Note title" />
                        </div>
                        <div class="sheet-empty-cell">
                            <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-input-full sheet-tall-control" placeholder="Note title" />
                        </div>
                        <div class="sheet-empty-cell">
                            <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>
</div>