private static MapleStatEffect loadFromData(final MapleData source, final int sourceid, final boolean skill, final boolean overTime, final int level, final String variables) {
        final MapleStatEffect ret = new MapleStatEffect();
        ret.sourceid = sourceid;
        ret.skill = skill;
        ret.level = (byte) level;
        if (source == null) {
            return ret;
        }
        ret.info = new EnumMap<>(MapleStatInfo.class);
        for (final MapleStatInfo i : MapleStatInfo.values()) {
            if (i.isSpecial()) {
                ret.info.put(i, parseEval(i.name().substring(0, i.name().length() - 1), source, i.getDefault(), variables, level));
            } else {
                ret.info.put(i, parseEval(i.name(), source, i.getDefault(), variables, level));
            }
        }
        ret.hpR = parseEval("hpR", source, 0, variables, level) / 100.0;
        ret.mpR = parseEval("mpR", source, 0, variables, level) / 100.0;
        ret.ignoreMob = (short) parseEval("ignoreMobpdpR", source, 0, variables, level);
        ret.thaw = (short) parseEval("thaw", source, 0, variables, level);
        ret.interval = parseEval("interval", source, 0, variables, level);
        ret.expinc = parseEval("expinc", source, 0, variables, level);
        ret.exp = parseEval("exp", source, 0, variables, level);
        ret.morphId = parseEval("morph", source, 0, variables, level);
        ret.cp = parseEval("cp", source, 0, variables, level);
        ret.cosmetic = parseEval("cosmetic", source, 0, variables, level);
        ret.slotCount = (byte) parseEval("slotCount", source, 0, variables, level);
        ret.preventslip = (byte) parseEval("preventslip", source, 0, variables, level);
        ret.useLevel = (short) parseEval("useLevel", source, 0, variables, level);
        ret.nuffSkill = parseEval("nuffSkill", source, 0, variables, level);
        ret.familiarTarget = (byte) (parseEval("familiarPassiveSkillTarget", source, 0, variables, level) + 1);
        ret.immortal = (byte) parseEval("immortal", source, 0, variables, level);
        ret.type = (byte) parseEval("type", source, 0, variables, level);
        ret.bs = (byte) parseEval("bs", source, 0, variables, level);
        ret.indiePdd = (short) parseEval("indiePdd", source, 0, variables, level);
        ret.indieMdd = (short) parseEval("indieMdd", source, 0, variables, level);
        ret.expBuff = parseEval("expBuff", source, 0, variables, level);
        ret.cashup = parseEval("cashBuff", source, 0, variables, level);
        ret.itemup = parseEval("itemupbyitem", source, 0, variables, level);
        ret.mesoup = parseEval("mesoupbyitem", source, 0, variables, level);
        ret.berserk = parseEval("berserk", source, 0, variables, level);
        ret.berserk2 = parseEval("berserk2", source, 0, variables, level);
        ret.booster = parseEval("booster", source, 0, variables, level);
        ret.lifeId = (short) parseEval("lifeId", source, 0, variables, level);
        ret.inflation = (short) parseEval("inflation", source, 0, variables, level);
        ret.imhp = (short) parseEval("imhp", source, 0, variables, level);
        ret.immp = (short) parseEval("immp", source, 0, variables, level);
        ret.illusion = parseEval("illusion", source, 0, variables, level);
        ret.consumeOnPickup = parseEval("consumeOnPickup", source, 0, variables, level);
        if (ret.consumeOnPickup == 1) {
            if (parseEval("party", source, 0, variables, level) > 0) {
                ret.consumeOnPickup = 2;
            }
        }
        ret.recipe = parseEval("recipe", source, 0, variables, level);
        ret.recipeUseCount = (byte) parseEval("recipeUseCount", source, 0, variables, level);
        ret.recipeValidDay = (byte) parseEval("recipeValidDay", source, 0, variables, level);
        ret.reqSkillLevel = (byte) parseEval("reqSkillLevel", source, 0, variables, level);
        ret.effectedOnAlly = (byte) parseEval("effectedOnAlly", source, 0, variables, level);
        ret.effectedOnEnemy = (byte) parseEval("effectedOnEnemy", source, 0, variables, level);
        ret.incPVPdamage = (short) parseEval("incPVPDamage", source, 0, variables, level);
        ret.moneyCon = parseEval("moneyCon", source, 0, variables, level);
        ret.moveTo = parseEval("moveTo", source, -1, variables, level);

        ret.charColor = 0;
        String cColor = MapleDataTool.getString("charColor", source, null);
        if (cColor != null) {
            ret.charColor |= Integer.parseInt("0x" + cColor.substring(0, 2));
            ret.charColor |= Integer.parseInt("0x" + cColor.substring(2, 4) + "00");
            ret.charColor |= Integer.parseInt("0x" + cColor.substring(4, 6) + "0000");
            ret.charColor |= Integer.parseInt("0x" + cColor.substring(6, 8) + "000000");
        }
        ret.traits = new EnumMap<>(MapleTraitType.class);
        for (MapleTraitType t : MapleTraitType.values()) {
            int expz = parseEval(t.name() + "EXP", source, 0, variables, level);
            if (expz != 0) {
                ret.traits.put(t, expz);
            }
        }
        List<MapleDisease> cure = new ArrayList<>(5);
        if (parseEval("poison", source, 0, variables, level) > 0) {
            cure.add(MapleDisease.POISON);
        }
        if (parseEval("seal", source, 0, variables, level) > 0) {
            cure.add(MapleDisease.SEAL);
        }
        if (parseEval("darkness", source, 0, variables, level) > 0) {
            cure.add(MapleDisease.DARKNESS);
        }
        if (parseEval("weakness", source, 0, variables, level) > 0) {
            cure.add(MapleDisease.WEAKEN);
        }
        if (parseEval("curse", source, 0, variables, level) > 0) {
            cure.add(MapleDisease.CURSE);
        }
        ret.cureDebuffs = cure;
        ret.petsCanConsume = new ArrayList<>();
        for (int i = 0; true; i++) {
            final int dd = parseEval(String.valueOf(i), source, 0, variables, level);
            if (dd > 0) {
                ret.petsCanConsume.add(dd);
            } else {
                break;
            }
        }
        final MapleData mdd = source.getChildByPath("0");
        if (mdd != null && mdd.getChildren().size() > 0) {
            ret.mobSkill = (short) parseEval("mobSkill", mdd, 0, variables, level);
            ret.mobSkillLevel = (short) parseEval("level", mdd, 0, variables, level);
        } else {
            ret.mobSkill = 0;
            ret.mobSkillLevel = 0;
        }
        final MapleData pd = source.getChildByPath("randomPickup");
        if (pd != null) {
            ret.randomPickup = new ArrayList<>();
            for (MapleData p : pd) {
                ret.randomPickup.add(MapleDataTool.getInt(p));
            }
        }
        final MapleData ltd = source.getChildByPath("lt");
        if (ltd != null) {
            ret.lt = (Point) ltd.getData();
            ret.rb = (Point) source.getChildByPath("rb").getData();
        }
        final MapleData ltc = source.getChildByPath("con");
        if (ltc != null) {
            ret.availableMap = new ArrayList<>();
            for (MapleData ltb : ltc) {
                ret.availableMap.add(new Pair<>(MapleDataTool.getInt("sMap", ltb, 0), MapleDataTool.getInt("eMap", ltb, 999999999)));
            }
        }
        final MapleData ltb = source.getChildByPath("familiar");
        if (ltb != null) {
            ret.fatigueChange = (short) (parseEval("incFatigue", ltb, 0, variables, level) - parseEval("decFatigue", ltb, 0, variables, level));
            ret.familiarTarget = (byte) parseEval("target", ltb, 0, variables, level);
            final MapleData lta = ltb.getChildByPath("targetList");
            if (lta != null) {
                ret.familiars = new ArrayList<>();
                for (MapleData ltz : lta) {
                    ret.familiars.add(MapleDataTool.getInt(ltz, 0));
                }
            }
        } else {
            ret.fatigueChange = 0;
        }
        int totalprob = 0;
        final MapleData lta = source.getChildByPath("reward");
        if (lta != null) {
            ret.rewardMeso = parseEval("meso", lta, 0, variables, level);
            final MapleData ltz = lta.getChildByPath("case");
            if (ltz != null) {
                ret.rewardItem = new ArrayList<>();
                for (MapleData lty : ltz) {
                    ret.rewardItem.add(new Triple<>(MapleDataTool.getInt("id", lty, 0), MapleDataTool.getInt("count", lty, 0), MapleDataTool.getInt("prop", lty, 0))); // todo: period (in minutes)
                    totalprob += MapleDataTool.getInt("prob", lty, 0);
                }
            }
        } else {
            ret.rewardMeso = 0;
        }
        ret.totalprob = totalprob;
        // start of server calculated stuffs
        if (ret.skill) {
            final int priceUnit = ret.info.get(MapleStatInfo.priceUnit); // Guild skills
            if (priceUnit > 0) {
                final int price = ret.info.get(MapleStatInfo.price);
                final int extendPrice = ret.info.get(MapleStatInfo.extendPrice);
                ret.info.put(MapleStatInfo.price, price * priceUnit);
                ret.info.put(MapleStatInfo.extendPrice, extendPrice * priceUnit);
            }
            switch (sourceid) {
                case 1100002:
                case 1200002:
                case 1300002:
                case 3100001:
                case 3200001:
                case 11101002:
                case 51100002:
                case 13101002:
                case 2111007:
                case 2211007:
                case 2311007:
                case 32111010:
                case 22161005:
                case 12111007:
                case 33100009:
                case 22150004:
                case 22181004: //All Final Attack
                case 1120013:
                case 3120008:
                case 23100006:
                case 23120012:
                    ret.info.put(MapleStatInfo.mobCount, 6);
                    break;
                case 35121005:
                case 35111004:
                case 35121013:
                    ret.info.put(MapleStatInfo.attackCount, 6);
                    ret.info.put(MapleStatInfo.bulletCount, 6);
                    break;
                case 24100003: // TODO: for now, or could it be card stack? (1 count)
                case 24120002:
                    ret.info.put(MapleStatInfo.attackCount, 15);
                    break;
            }
            if (GameConstants.isNoDelaySkill(sourceid)) {
                ret.info.put(MapleStatInfo.mobCount, 6);
            }
        }
        if (!ret.skill && ret.info.get(MapleStatInfo.time) > -1) {
            ret.overTime = true;
        } else {
            ret.info.put(MapleStatInfo.time, (ret.info.get(MapleStatInfo.time) * 1000)); // items have their times stored in ms, of course
            ret.info.put(MapleStatInfo.subTime, (ret.info.get(MapleStatInfo.subTime) * 1000));
            ret.overTime = overTime || ret.isMorph() || ret.isPirateMorph() || ret.isFinalAttack() || ret.isAngel() || ret.getSummonMovementType() != null;
        }
        ret.monsterStatus = new EnumMap<>(MonsterStatus.class);
        ret.statups = new EnumMap<>(MapleBuffStat.class);
        if (ret.overTime && ret.getSummonMovementType() == null && !ret.isEnergyCharge()) {
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.WATK, ret.info.get(MapleStatInfo.pad));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.WDEF, ret.info.get(MapleStatInfo.pdd));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.MATK, ret.info.get(MapleStatInfo.mad));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.MDEF, ret.info.get(MapleStatInfo.mdd));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ACC, ret.info.get(MapleStatInfo.acc));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.AVOID, ret.info.get(MapleStatInfo.eva));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.SPEED, sourceid == 32120001 || sourceid == 32101003 ? ret.info.get(MapleStatInfo.x) : ret.info.get(MapleStatInfo.speed));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.JUMP, ret.info.get(MapleStatInfo.jump));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.MAXHP, ret.info.get(MapleStatInfo.mhpR));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.MAXMP, ret.info.get(MapleStatInfo.mmpR));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.BOOSTER, ret.booster);
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.HP_LOSS_GUARD, Integer.valueOf(ret.thaw));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.EXPRATE, ret.expBuff); // EXP
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ACASH_RATE, ret.cashup); // custom
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.DROP_RATE, GameConstants.getModifier(ret.sourceid, ret.itemup)); // defaults to 2x
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.MESO_RATE, GameConstants.getModifier(ret.sourceid, ret.mesoup)); // defaults to 2x
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.BERSERK_FURY, ret.berserk2);
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ILLUSION, ret.illusion);
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.PYRAMID_PQ, ret.berserk);
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ENHANCED_MAXHP, ret.info.get(MapleStatInfo.emhp));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ENHANCED_MAXMP, ret.info.get(MapleStatInfo.emmp));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ENHANCED_WATK, ret.info.get(MapleStatInfo.epad));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ENHANCED_MATK, ret.info.get(MapleStatInfo.emad));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ENHANCED_WDEF, ret.info.get(MapleStatInfo.epdd));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ENHANCED_MDEF, ret.info.get(MapleStatInfo.emdd));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.GIANT_POTION, Integer.valueOf(ret.inflation));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.STR, ret.info.get(MapleStatInfo.str));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.DEX, ret.info.get(MapleStatInfo.dex));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.INT, ret.info.get(MapleStatInfo.int_));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.LUK, ret.info.get(MapleStatInfo.luk));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.INDIE_PAD, ret.info.get(MapleStatInfo.indiePad));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.INDIE_MAD, ret.info.get(MapleStatInfo.indieMad));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.HP_BOOST, Integer.valueOf(ret.imhp));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.MP_BOOST, Integer.valueOf(ret.immp)); //same one? lol
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.HP_BOOST_PERCENT, ret.info.get(MapleStatInfo.indieMhpR));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.MP_BOOST_PERCENT, ret.info.get(MapleStatInfo.indieMmpR));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.HP_BOOST, ret.info.get(MapleStatInfo.indieMhp));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.MP_BOOST, ret.info.get(MapleStatInfo.indieMmp));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.PVP_DAMAGE, Integer.valueOf(ret.incPVPdamage));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ANGEL_JUMP, ret.info.get(MapleStatInfo.indieJump));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.INDIE_SPEED, ret.info.get(MapleStatInfo.indieSpeed));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ANGEL_ACC, ret.info.get(MapleStatInfo.indieAcc));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ANGEL_AVOID, ret.info.get(MapleStatInfo.indieEva));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ANGEL_STAT, ret.info.get(MapleStatInfo.indieAllStat));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.ATTACK_SPEED, ret.info.get(MapleStatInfo.indieBooster));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.PVP_ATTACK, ret.info.get(MapleStatInfo.PVPdamage));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.INVINCIBILITY, Integer.valueOf(ret.immortal));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.NO_SLIP, Integer.valueOf(ret.preventslip));
            addBuffStatPairToListIfNotZero(ret.statups, MapleBuffStat.FAMILIAR_SHADOW, ret.charColor > 0 ? 1 : 0);
            if (sourceid == 5221006 || ret.isPirateMorph()) { //HACK: add stance :D and also this buffstat has to be the first one..
                ret.statups.put(MapleBuffStat.STANCE, 100); //100% :D:D:D
            }
        }
        if (ret.skill) { // hack because we can't get from the datafile...
            boolean found = false;
            for (CustomSkills skills : CustomSkills.values()) {
                if (skills.isBuff() && !skills.isStatInfoBuff() && skills.getId() == sourceid) {
                    found = true;
                    ret.statups.put(skills.getStat().getLeft(), skills.getStat().getRight());
                } else if (skills.isBuff() && skills.isStatInfoBuff() && skills.getId() == sourceid) {
                    found = true;
                    ret.statups.put(skills.getStatInfo().getLeft(), ret.info.get(skills.getStatInfo().getRight()));
                }
            }
            
            if (!found) {
                boolean handle = BuffClassFetcher.getHandleMethod(ret, sourceid);
                if (!handle) {
                    switch (sourceid) {
                        case 2001002: // magic guard
                        case 12001001:
                        case 22111001:
                            ret.statups.put(MapleBuffStat.MAGIC_GUARD, ret.info.get(MapleStatInfo.x));
                            break;
                        case 2301003: // invincible
                            ret.statups.put(MapleBuffStat.INVINCIBLE, ret.info.get(MapleStatInfo.x));
                            break;
                        case 35120000:
                        case 35001002:
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            break;
                        case 9101004:
                        case 9001004: // hide
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.DARKSIGHT, ret.info.get(MapleStatInfo.x));
                            break;
                        case 13101006: // Wind Walk
                            ret.statups.put(MapleBuffStat.WIND_WALK, ret.info.get(MapleStatInfo.x));
                            break;
                        case 4330001:
                            ret.statups.put(MapleBuffStat.DARKSIGHT, (int) ret.level);
                            break;
                        case 4001003: // Dark Sight
                        case 14001003: // cygnus ds
                        case 20031211:
                            ret.statups.put(MapleBuffStat.DARKSIGHT, ret.info.get(MapleStatInfo.x)); // d
                            break;
                        case 4211003: // pickpocket
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.PICKPOCKET, ret.info.get(MapleStatInfo.x));
                            break;
                        case 4211005: // mesoguard
                        case 4201011:
                            ret.statups.put(MapleBuffStat.MESOGUARD, ret.info.get(MapleStatInfo.x));
                            break;
                        case 4111001: // mesoup
                            ret.statups.put(MapleBuffStat.MESOUP, ret.info.get(MapleStatInfo.x));
                            break;
                        case 14111000: // cygnus
                            ret.statups.put(MapleBuffStat.SHADOWPARTNER, ret.info.get(MapleStatInfo.x)); // d
                            break;
                        case 4211008:
                            ret.statups.put(MapleBuffStat.SHADOWPARTNER, (int) ret.level);
                            break;
                        case 11101002: // All Final attack
                        case 51100002:
                        case 13101002:
                            ret.statups.put(MapleBuffStat.FINALATTACK, ret.info.get(MapleStatInfo.x));
                            break;
                        case 22161004:
                            ret.statups.put(MapleBuffStat.ONYX_SHROUD, ret.info.get(MapleStatInfo.x));
                            break;
                        case 3101004: // soul arrow
                        case 3201004:
                        case 2311002: // mystic door - hacked buff icon
                        case 35101005:
                        case 13101003:
                        case 13101024://new cyngus
                            ret.statups.put(MapleBuffStat.SOULARROW, ret.info.get(MapleStatInfo.x));
                            break;
                        case 2321010:
                        case 2221009:
                        case 2121009:
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.BUFF_MASTERY, ret.info.get(MapleStatInfo.x));
                            break;
                        case 2320011:
                        case 2220010:
                        case 2120010:
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.MANY_USES, ret.info.get(MapleStatInfo.x));
                            break;
                        case 1211006: // wk charges
                        case 1211004:
                        case 1211008:
                        case 1221004:
                        case 11111007:
                        // case 51111003: // Mihile's Radiant Charge
                        case 21101006:
                        case 21111005:
                        case 15101006:
                            ret.statups.put(MapleBuffStat.WK_CHARGE, ret.info.get(MapleStatInfo.x));
                            ret.statups.put(MapleBuffStat.DAMAGE_BUFF, ret.info.get(MapleStatInfo.z));
                            break;
//                    case 51111004:
//                        ret.statups.put(MapleBuffStat.ABNORMAL_STATUS_R, ret.info.get(MapleStatInfo.y));
//                        ret.statups.put(MapleBuffStat.ELEMENTAL_STATUS_R, ret.info.get(MapleStatInfo.z));
//                        ret.statups.put(MapleBuffStat.DEFENCE_BOOST_R, ret.info.get(MapleStatInfo.x));
//                        break;
//                    case 51121006:
//                        ret.statups.put(MapleBuffStat.DAMAGE_BUFF, ret.info.get(MapleStatInfo.x));
//                        ret.statups.put(MapleBuffStat.CRITICAL_RATE_BUFF, ret.info.get(MapleStatInfo.criticaldamageMin.x));
//                        ret.statups.put(MapleBuffStat.CRITICAL_RATE_BUFF, ret.info.get(MapleStatInfo.criticaldamageMax.x));
//                        break;
                        case 2111008:
                        case 2211008:
                        case 12101005:
                        case 22121001: // Elemental Reset
                            ret.statups.put(MapleBuffStat.ELEMENT_RESET, ret.info.get(MapleStatInfo.x));
                            break;
                        case 3111000:
                        case 3121008:
                        case 13111001:
                            ret.statups.put(MapleBuffStat.CONCENTRATE, ret.info.get(MapleStatInfo.x));
                            break;
                        case 5110001: // Energy Charge
                        case 15100004:
                            ret.statups.put(MapleBuffStat.ENERGY_CHARGE, 0);
                            break;
                        case 1101004:
                        case 1201004:
                        case 1301004:
                        case 3101002:
                        case 3201002:
                        case 4101003:
                        case 4201002:
                        case 23101002:
                        case 2111005: // spell booster, do these work the same?
                        case 2211005:
                        case 5101006:
                        case 5201003:
                        case 11101001:
                        case 12101004:
                        case 13101001:
                        case 14101002:
                        case 15101002:
                        case 22141002: // Magic Booster
                        case 2311006: // Magic Booster
                        case 32101005:
                        case 33001003:
                        case 35101006:
                        case 5301002:
                        case 24101005:
                        case 5701005:
                        // case 51101003: //Mihile's sword booster
                        case 27101004: //Luminous booster
                            ret.statups.put(MapleBuffStat.BOOSTER, ret.info.get(MapleStatInfo.x) * 2);
                            break;
                        case 21001003: // Aran - Pole Arm Booster
                            ret.statups.put(MapleBuffStat.BOOSTER, -ret.info.get(MapleStatInfo.y));
                            break;
                        case 35111013:
                        case 5111007:
                        case 5211007:
                        case 5811007:
                        case 5911007:
                        case 5311005:
                        case 5320007:
                        case 5120012:
                        case 5220014:
                        case 5711011:
                        case 5720005:
                        case 15111011:
                            ret.statups.put(MapleBuffStat.DICE_ROLL, 0);
                            break;
                        case 5120011:
                        case 5220012:
                            ret.info.put(MapleStatInfo.cooltime, ret.info.get(MapleStatInfo.x));
                            ret.statups.put(MapleBuffStat.DAMAGE_RATE, (int) ret.info.get(MapleStatInfo.damR)); //i think
                            break;
                        case 5121009:
                        case 15111005:
                            ret.statups.put(MapleBuffStat.SPEED_INFUSION, ret.info.get(MapleStatInfo.x));
                            break;
                        case 4321000: //tornado spin uses same buffstats
                            ret.info.put(MapleStatInfo.time, 1000);
                            ret.statups.put(MapleBuffStat.DASH_SPEED, 100 + ret.info.get(MapleStatInfo.x));
                            ret.statups.put(MapleBuffStat.DASH_JUMP, ret.info.get(MapleStatInfo.y)); //always 0 but its there
                            break;
                        case 5001005: // Dash
                        case 15001003:
                            ret.statups.put(MapleBuffStat.DASH_SPEED, ret.info.get(MapleStatInfo.x));
                            ret.statups.put(MapleBuffStat.DASH_JUMP, ret.info.get(MapleStatInfo.y));
                            break;
                        case 1101007: // pguard
                        case 1201007:
                            ret.statups.put(MapleBuffStat.POWERGUARD, ret.info.get(MapleStatInfo.x));
                            break;
                        case 32111004: //conversion
                            ret.statups.put(MapleBuffStat.CONVERSION, ret.info.get(MapleStatInfo.x));
                            break;
                        case 1301007: // hyper body
                        case 9001008:
                        case 9101008:
                            ret.statups.put(MapleBuffStat.MAXHP, ret.info.get(MapleStatInfo.x));
                            ret.statups.put(MapleBuffStat.MAXMP, ret.info.get(MapleStatInfo.x));
                            break;
                        case 1111002: // combo
                        case 11111001: // combo
                        case 1101013:
                            ret.statups.put(MapleBuffStat.COMBO, 1);
                         //   System.out.println("Combo just buff stat");
                            break;
                        case 21120007: //combo barrier
                            ret.statups.put(MapleBuffStat.COMBO_BARRIER, ret.info.get(MapleStatInfo.x));
                            break;
                        case 5211006: // Homing Beacon
                        case 5220011: // Bullseye
                        case 22151002: //killer wings
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.HOMING_BEACON, ret.info.get(MapleStatInfo.x));
                            break;
                        case 1311015: // Cross Surge
                            ret.statups.put(MapleBuffStat.CROSS_SURGE, ret.info.get(MapleStatInfo.x));
                            break;
                        case 21111009: //combo recharge
                        case 1311006: //dragon roar
                        case 1311005: //NOT A BUFF - Sacrifice
                            ret.hpR = -ret.info.get(MapleStatInfo.x) / 100.0;
                            break;
                        case 1211010: //NOT A BUFF - HP Recover
                            ret.hpR = ret.info.get(MapleStatInfo.x) / 100.0;
                            break;
                        case 4341002:
                            ret.info.put(MapleStatInfo.time, 60 * 1000);
                            ret.hpR = -ret.info.get(MapleStatInfo.x) / 100.0;
                            ret.statups.put(MapleBuffStat.FINAL_CUT, ret.info.get(MapleStatInfo.y));
                            break;
                        case 2111007:
                        case 2211007:
                        case 2311007:
                        case 32111010:
                        case 22161005:
                        case 12111007:
                            ret.info.put(MapleStatInfo.mpCon, ret.info.get(MapleStatInfo.y));
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.TELEPORT_MASTERY, ret.info.get(MapleStatInfo.x));
                            ret.monsterStatus.put(MonsterStatus.STUN, 1);
                            break;

                        case 4331003:
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.OWL_SPIRIT, ret.info.get(MapleStatInfo.y));
                            break;
                        case 1311008: // dragon blood
                            if (!GameConstants.GMS) { //TODO JUMP
                                ret.statups.put(MapleBuffStat.DRAGONBLOOD, ret.info.get(MapleStatInfo.x));
                            }
                            break;
                        case 5321005:
                        case 1121000: // maple warrior, all classes
                        case 5721000:
                        case 1221000:
                        case 1321000:
                        case 2121000:
                        case 2221000:
                        case 2321000:
                        case 3121000:
                        case 3221000:
                        case 4121000:
                        case 4221000:
                        case 5121000:
                        case 5221000:
                        case 21121000: // Aran - Maple Warrior
                        case 32121007:
                        case 35121007:
                        case 23121005:
                        case 24121008: // phantom
                        case 100001268: // Zero
                            // case 51121005: //Mihile's Maple Warrior
                            ret.statups.put(MapleBuffStat.MAPLE_WARRIOR, ret.info.get(MapleStatInfo.x));
                            break;
                        case 15111006: //spark
                            ret.statups.put(MapleBuffStat.SPARK, ret.info.get(MapleStatInfo.x));
                            break;
                        case 3121002: // sharp eyes bow master
                        case 3221002: // sharp eyes marksmen
                            ret.statups.put(MapleBuffStat.SHARP_EYES, (ret.info.get(MapleStatInfo.x) << 8) + ret.info.get(MapleStatInfo.criticaldamageMax));
                            break;
                        case 22151003: //magic resistance
                            ret.statups.put(MapleBuffStat.MAGIC_RESISTANCE, ret.info.get(MapleStatInfo.x));
                            break;
                        case 2000007:
                        case 12000006:
                        case 22000002:
                        case 32000012:
                            ret.statups.put(MapleBuffStat.ELEMENT_WEAKEN, ret.info.get(MapleStatInfo.x));
                            break;
                        case 21101003: // Body Pressure
                            ret.statups.put(MapleBuffStat.BODY_PRESSURE, ret.info.get(MapleStatInfo.x));
                            break;
                        case 21000000: // Aran Combo
                            ret.statups.put(MapleBuffStat.ARAN_COMBO, 100);
                            break;
                        case 23101003:
                            ret.statups.put(MapleBuffStat.DAMAGE_R, ret.info.get(MapleStatInfo.damage));
                            ret.statups.put(MapleBuffStat.CRITICAL_RATE, ret.info.get(MapleStatInfo.x));
                            break;
                        case 21100005: // Combo Drain
                        case 32101004:
                            ret.statups.put(MapleBuffStat.COMBO_DRAIN, ret.info.get(MapleStatInfo.x));
                            break;
                        case 41101003: // Military Might
                            ret.statups.put(MapleBuffStat.ENHANCED_MAXHP, ret.info.get(MapleStatInfo.x));
                            ret.statups.put(MapleBuffStat.ENHANCED_MAXMP, ret.info.get(MapleStatInfo.y));
                            ret.statups.put(MapleBuffStat.ENHANCED_WATK, ret.info.get(MapleStatInfo.padX));
                            ret.statups.put(MapleBuffStat.SPEED, ret.info.get(MapleStatInfo.speed));
                            ret.statups.put(MapleBuffStat.JUMP, ret.info.get(MapleStatInfo.jump));
                            break;
                        case 41110009: // Warrior's Heart
                            ret.statups.put(MapleBuffStat.RECOVERY, ret.info.get(MapleStatInfo.damage));
                            break;
                        case 42101020:
                            ret.statups.put(MapleBuffStat.RECOVERY, ret.info.get(MapleStatInfo.hp));
                            break;
                        case 23111004://Ignis Roar
                        case 23121054:
                            ret.statups.put(MapleBuffStat.INDIE_PAD, (int) ret.info.get(MapleStatInfo.indiePad));
                            break;
                        case 21111001: // Smart Knockback
                            ret.statups.put(MapleBuffStat.SMART_KNOCKBACK, ret.info.get(MapleStatInfo.x));
                            break;
                            
                        case 23121004://TODO LEGEND
                            ret.statups.put(MapleBuffStat.DAMAGE_RATE, (int) ret.info.get(MapleStatInfo.damR));
                            ret.statups.put(MapleBuffStat.ENHANCED_MAXHP, (int) ret.info.get(MapleStatInfo.emhp));
                            break;
                        case 1211009:
                        case 1111007:
                        case 1311007: //magic crash
                        case 51111005: //Mihile's magic crash
                            ret.monsterStatus.put(MonsterStatus.MAGIC_CRASH, 1);
                            break;
                        case 1220013:
                            ret.statups.put(MapleBuffStat.DIVINE_SHIELD, ret.info.get(MapleStatInfo.x) + 1);
                            break;
                        case 1211011:
                            ret.statups.put(MapleBuffStat.COMBAT_ORDERS, ret.info.get(MapleStatInfo.x));
                            break;
                        case 23111005:
                            ret.statups.put(MapleBuffStat.ABNORMAL_STATUS_R, ret.info.get(MapleStatInfo.terR));
                            ret.statups.put(MapleBuffStat.ELEMENTAL_STATUS_R, ret.info.get(MapleStatInfo.terR));
                            ret.statups.put(MapleBuffStat.WATER_SHIELD, ret.info.get(MapleStatInfo.x));
                            break;
                        case 22131001: //magic shield
                            ret.statups.put(MapleBuffStat.MAGIC_SHIELD, ret.info.get(MapleStatInfo.x));
                            break;
                        case 22181003: //soul stone
                            ret.statups.put(MapleBuffStat.SOUL_STONE, 1);
                            break;
                        case 24111002: //Final Feint
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.SOUL_STONE, 1);
                            break;
                        case 32121003: //twister
                            ret.statups.put(MapleBuffStat.TORNADO, ret.info.get(MapleStatInfo.x));
                            break;
                        case 2311009: //holy magic
                            ret.statups.put(MapleBuffStat.HOLY_MAGIC_SHELL, ret.info.get(MapleStatInfo.x));
                            ret.info.put(MapleStatInfo.cooltime, ret.info.get(MapleStatInfo.y));
                            ret.hpR = ret.info.get(MapleStatInfo.z) / 100.0;
                            break;
                        case 32111005: //body boost
                            ret.info.put(MapleStatInfo.time, 60000);
                            ret.statups.put(MapleBuffStat.BODY_BOOST, (int) ret.level); //lots of variables
                            break;
                        case 22131002:
                        case 22141003: // Slow
                            ret.statups.put(MapleBuffStat.SLOW, ret.info.get(MapleStatInfo.x));
                            break;
                        case 4001002: // disorder
                        case 14001002: // cygnus disorder
                            ret.monsterStatus.put(MonsterStatus.WATK, ret.info.get(MapleStatInfo.x));
                            ret.monsterStatus.put(MonsterStatus.WDEF, ret.info.get(MapleStatInfo.y));
                            break;
                        case 5221009: // Mind Control
                            ret.monsterStatus.put(MonsterStatus.HYPNOTIZE, 1);
                            break;
                        case 4341003: // Monster Bomb
                            ret.monsterStatus.put(MonsterStatus.MONSTER_BOMB, (int) ret.info.get(MapleStatInfo.damage));
                            break;
                        case 1201006: // threaten
                            ret.monsterStatus.put(MonsterStatus.WATK, ret.info.get(MapleStatInfo.x));
                            ret.monsterStatus.put(MonsterStatus.WDEF, ret.info.get(MapleStatInfo.x));
                            ret.monsterStatus.put(MonsterStatus.DARKNESS, ret.info.get(MapleStatInfo.z));
                            break;
                        case 22141001:
                        case 1211002: // charged blow
                        case 1111008: // shout
                        case 4211002: // assaulter
                        case 3101005: // arrow bomb
                        case 1111005: // coma: sword
                        case 4221007: // boomerang step
                        case 5101002: // Backspin Blow
                        case 5101003: // Double Uppercut
                        case 5121004: // Demolition
                        case 5121005: // Snatch
                        case 5121007: // Barrage
                        case 5201004: // pirate blank shot
                        case 4121008: // Ninja Storm
                        case 22151001:
                        case 4201004: //steal, new
                        case 33101001:
                        case 33101002:
                        case 32101001:
                        case 32111011:
                        case 32121004:
                        case 33111002:
                        case 33121002:
                        case 35101003:
                        case 35111015:
                        case 5111002: //energy blast
                        case 15101005:
                        case 4331005:
                        case 1121001: //magnet
                        case 1221001:
                        case 1321001:
                        case 9001020:
                        case 31111001:
                        case 31101002:
                        case 9101020:
                        case 2211003:
                        case 2311004:
                        case 3120010:
                        case 22181001:
                        case 21110006:
                        case 22131000:
                        case 5301001:
                        case 5311001:
                        case 5311002:
                        case 2221006:
                        case 5310008:
                            ret.monsterStatus.put(MonsterStatus.STUN, 1);
                            break;
                        case 90001004:
                        case 4321002:
                        case 1111003:
                        case 11111002:
                            ret.monsterStatus.put(MonsterStatus.DARKNESS, ret.info.get(MapleStatInfo.x));
                            break;
                        case 4221003:
                        case 4121003:
                        case 33121005:
                            ret.monsterStatus.put(MonsterStatus.SHOWDOWN, ret.info.get(MapleStatInfo.x));
                            ret.monsterStatus.put(MonsterStatus.MDEF, ret.info.get(MapleStatInfo.x)); // removed for taunt
                            ret.monsterStatus.put(MonsterStatus.WDEF, ret.info.get(MapleStatInfo.x)); // removed for taunt
                            break;
                        case 31121003:
                            ret.monsterStatus.put(MonsterStatus.SHOWDOWN, ret.info.get(MapleStatInfo.w));
                            ret.monsterStatus.put(MonsterStatus.MDEF, ret.info.get(MapleStatInfo.x));
                            ret.monsterStatus.put(MonsterStatus.WDEF, ret.info.get(MapleStatInfo.x));
                            ret.monsterStatus.put(MonsterStatus.MATK, ret.info.get(MapleStatInfo.x));
                            ret.monsterStatus.put(MonsterStatus.WATK, ret.info.get(MapleStatInfo.x));
                            ret.monsterStatus.put(MonsterStatus.ACC, ret.info.get(MapleStatInfo.x));
                            break;
                        case 23121002: //not sure if negative
                            ret.monsterStatus.put(MonsterStatus.WDEF, -ret.info.get(MapleStatInfo.x));
                            break;
                        case 2201004: // cold beam
                        case 2221003:
                        case 2211002: // ice strike
                        case 3211003: // blizzard
                        case 2211006: // il elemental compo
                        case 2221007: // Blizzard
                        case 5211005: // Ice Splitter
                        case 2121006: // Paralyze
                        case 21120006: // Tempest
                        case 22121000:
                        case 90001006:
                        case 2221001:
                            ret.monsterStatus.put(MonsterStatus.FREEZE, 1);
                            ret.info.put(MapleStatInfo.time, ret.info.get(MapleStatInfo.time) * 2); // freezing skills are a little strange
                            break;
                        case 2101003: // fp slow
                        case 2201003: // il slow
                        case 12101001:
                        case 90001002:
                            ret.monsterStatus.put(MonsterStatus.SPEED, ret.info.get(MapleStatInfo.x));
                            break;
                        case 5011002:
                            ret.monsterStatus.put(MonsterStatus.SPEED, ret.info.get(MapleStatInfo.z));
                            break;
                        case 1121010: //enrage
                            ret.statups.put(MapleBuffStat.ENRAGE, ret.info.get(MapleStatInfo.x) * 100 + ret.info.get(MapleStatInfo.mobCount));
                            break;
                        case 23111002: //TODO LEGEND: damage increase?
                        case 22161002: //phantom imprint
                            ret.monsterStatus.put(MonsterStatus.IMPRINT, ret.info.get(MapleStatInfo.x));
                            break;
                        case 90001003:
                            ret.monsterStatus.put(MonsterStatus.POISON, 1);
                            break;
                        case 4121004: // Ninja ambush
                        case 4221004:
                            ret.monsterStatus.put(MonsterStatus.NINJA_AMBUSH, (int) ret.info.get(MapleStatInfo.damage));
                            break;
                        case 2311005:
                            ret.monsterStatus.put(MonsterStatus.DOOM, 1);
                            break;
                        case 32111006:
                            ret.statups.put(MapleBuffStat.REAPER, 1);
                            break;
                        case 35121003:
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.SUMMON, 1);
                            break;
                        case 35111001:
                        case 35111010:
                        case 35111009:
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.PUPPET, 1);
                            break;
                        case 4341006:
                        case 3120012:
                        case 3220012:
                        case 3111002: // puppet ranger
                        case 3211002: // puppet sniper
                        case 13111004: // puppet cygnus
                        case 13111024: // Emerald Flower
                        case 5211001: // Pirate octopus summon
                        case 5220002: // wrath of the octopi
                        case 33111003:
                        case 5321003:
                        case 5211014:
                            ret.statups.put(MapleBuffStat.PUPPET, 1);
                            break;
                        case 3120006:
                        case 3220005:
                            ret.statups.put(MapleBuffStat.ELEMENTAL_STATUS_R, (int) ret.info.get(MapleStatInfo.terR));
                            ret.statups.put(MapleBuffStat.SPIRIT_LINK, 1);
                            break;
                        case 5220019:
                            ret.info.put(MapleStatInfo.time, 120000);
                            break;
                        case 5211011:
                        case 5211015:
                        case 5211016:
                        case 5711001: // turret
                        case 2121005: // elquines
                        case 3201007:
                        case 3101007:
                        case 3211005: // golden eagle
                        case 3111005: // golden hawk
                        case 33111005:
                        case 35111002:
                        case 3121006: // phoenix
                        case 23111008:
                        case 23111009:
                        case 23111010:
                            ret.statups.put(MapleBuffStat.SUMMON, 1);
                            ret.monsterStatus.put(MonsterStatus.STUN, 1);
                            break;
                        case 3221005: // frostprey
                        case 2221005: // ifrit
                            ret.statups.put(MapleBuffStat.SUMMON, 1);
                            ret.monsterStatus.put(MonsterStatus.FREEZE, 1);
                            break;
                        case 35111005:
                            ret.statups.put(MapleBuffStat.SUMMON, 1);
                            ret.monsterStatus.put(MonsterStatus.SPEED, ret.info.get(MapleStatInfo.x));
                            ret.monsterStatus.put(MonsterStatus.WDEF, ret.info.get(MapleStatInfo.y));
                            break;
                        case 1321007: // Beholder
                        case 1301013: // Evil Eye
//                        case 1311013: // Evil Eye of Domination
                            ret.statups.put(MapleBuffStat.BEHOLDER, (int) ret.level);
                            break;
                        case 2321003: // bahamut
                        case 5211002: // Pirate bird summon
                        case 11001004:
                        case 12001004:
                        case 12111004: // Itrit
                        case 13001004:
                        case 14001005:
                        case 15001004:
                        case 35111011:
                        case 35121009:
                        case 35121011:
                        case 33101008: //summon - its raining mines
                        case 4111007: //dark flare
                        case 4211007: //dark flare
                        case 14111010: //dark flare
                        case 5321004:
                            ret.statups.put(MapleBuffStat.SUMMON, 1);
                            break;
                        case 65101002:
                            ret.statups.put(MapleBuffStat.DAMAGE_ABSORBED, ret.info.get(MapleStatInfo.x));
                            break;
                        case 65111004: // Iron Blossom
                             ret.statups.put(MapleBuffStat.STANCE, ret.info.get(MapleStatInfo.prop));
                            break;
                        case 35121010:
                            ret.info.put(MapleStatInfo.time, 60000);
                            ret.statups.put(MapleBuffStat.DAMAGE_BUFF, ret.info.get(MapleStatInfo.x));
                            break;
                        case 31121005:
                            ret.statups.put(MapleBuffStat.DAMAGE_RATE, (int) ret.info.get(MapleStatInfo.damR));
                            ret.statups.put(MapleBuffStat.DARK_METAMORPHOSIS, 6); // mob count
                            break;
                        case 2311003: // hs
                        case 9001002: // GM hs
                        case 9101002:
                            ret.statups.put(MapleBuffStat.HOLY_SYMBOL, ret.info.get(MapleStatInfo.x));
                            break;
                        case 80001034: //virtue
                        case 80001035: //virtue
                        case 80001036: //virtue
                            ret.statups.put(MapleBuffStat.VIRTUE_EFFECT, 1);
                            break;
                        case 2211004: // il seal
                        case 2111004: // fp seal
                        case 12111002: // cygnus seal
                        case 90001005:
                            ret.monsterStatus.put(MonsterStatus.SEAL, 1);
                            break;
                        case 24121003:
                            ret.info.put(MapleStatInfo.damage, ret.info.get(MapleStatInfo.v));
                            ret.info.put(MapleStatInfo.attackCount, ret.info.get(MapleStatInfo.w));
                            ret.info.put(MapleStatInfo.mobCount, ret.info.get(MapleStatInfo.x));
                            break;
                        case 4111003: // shadow web
                        case 14111001:
                            ret.monsterStatus.put(MonsterStatus.SHADOW_WEB, 1);
                            break;
                        case 4111009: // Shadow Stars
                        case 5201008:
                        case 14111007:
                            ret.statups.put(MapleBuffStat.SPIRIT_CLAW, 0);
                            break;
                        case 2121004:
                        case 2221004:
                        case 2321004: // Infinity
                            ret.hpR = ret.info.get(MapleStatInfo.y) / 100.0;
                            ret.mpR = ret.info.get(MapleStatInfo.y) / 100.0;
                            ret.statups.put(MapleBuffStat.INFINITY, ret.info.get(MapleStatInfo.x));
                            if (GameConstants.GMS) { //TODO JUMP
                                ret.statups.put(MapleBuffStat.STANCE, (int) ret.info.get(MapleStatInfo.prop));
                            }
                            break;
                        case 22181004:
                            ret.statups.put(MapleBuffStat.ONYX_WILL, (int) ret.info.get(MapleStatInfo.damage)); //is this the right order
                            ret.statups.put(MapleBuffStat.STANCE, (int) ret.info.get(MapleStatInfo.prop));
                            break;
                        case 1121002:
                        case 1221002:
                        case 1321002: // Stance
                        // case 51121004: //Mihile's Stance
                        case 50001214:
                        case 80001140:
                        case 21121003: // Aran - Freezing Posture
                        case 32121005:
                        case 5321010:
                            ret.statups.put(MapleBuffStat.STANCE, (int) ret.info.get(MapleStatInfo.prop));
                            break;
                        case 2121002: // mana reflection
                        case 2221002:
                        case 2321002:
                            ret.statups.put(MapleBuffStat.MANA_REFLECTION, 1);
                            break;
                        case 2321005: // holy shield, TODO JUMP
//                            ret.statups.put(MapleBuffStat.HOLY_SHIELD, GameConstants.GMS ? (int) ret.level : ret.info.get(MapleStatInfo.x));
                            ret.statups.put(MapleBuffStat.HOLY_SHIELD, ret.info.get(MapleStatInfo.x));
                            ret.statups.put(MapleBuffStat.HP_BOOST, ret.info.get(MapleStatInfo.y));//fix names
                            ret.statups.put(MapleBuffStat.MP_BOOST, ret.info.get(MapleStatInfo.z));
                            break;
                        case 3121007: // Hamstring
                            ret.statups.put(MapleBuffStat.HAMSTRING, ret.info.get(MapleStatInfo.x));
                            ret.monsterStatus.put(MonsterStatus.SPEED, ret.info.get(MapleStatInfo.x));
                            break;
                        case 3221006: // Blind
                        case 33111004:
                            ret.statups.put(MapleBuffStat.BLIND, ret.info.get(MapleStatInfo.x));
                            ret.monsterStatus.put(MonsterStatus.ACC, ret.info.get(MapleStatInfo.x));
                            break;
                      
                        case 9101003: //customs for infinite dmg :D
                            ret.statups.put(MapleBuffStat.INDIE_PAD, Integer.MAX_VALUE);
                            ret.statups.put(MapleBuffStat.INDIE_MAD, Integer.MAX_VALUE);
                            ret.statups.put(MapleBuffStat.DAMAGE_CAP_INCREASE, 500000);
                        case 2301004:
                        case 9001003:
                            ret.statups.put(MapleBuffStat.BLESS, (int) ret.level);
                            break;
                        case 32120000:
                            ret.info.put(MapleStatInfo.dot, ret.info.get(MapleStatInfo.damage));
                            ret.info.put(MapleStatInfo.dotTime, 3);
                        case 32001003: //dark aura
                        case 32110007:
                            ret.info.put(MapleStatInfo.time, (sourceid == 32110007 ? 60000 : 2100000000));
                            ret.statups.put(MapleBuffStat.DARK_AURA, ret.info.get(MapleStatInfo.x));
                            break;
                        case 32111012: //blue aura
                        case 32110000:
                        case 32110008:
                            ret.info.put(MapleStatInfo.time, (sourceid == 32110008 ? 60000 : 2100000000));
                            ret.statups.put(MapleBuffStat.BLUE_AURA, (int) ret.level);
                            break;
                        case 32120001:
                            ret.monsterStatus.put(MonsterStatus.SPEED, ret.info.get(MapleStatInfo.speed));
                        case 32101003: //yellow aura
                        case 32110009:
                            ret.info.put(MapleStatInfo.time, (sourceid == 32110009 ? 60000 : 2100000000));
                            ret.statups.put(MapleBuffStat.YELLOW_AURA, (int) ret.level);
                            break;
                        case 33101004: //it's raining mines
                            ret.statups.put(MapleBuffStat.RAINING_MINES, ret.info.get(MapleStatInfo.x)); //x?
                            break;
                        case 35101007: //perfect armor
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.PERFECT_ARMOR, ret.info.get(MapleStatInfo.x));
                            break;
                        case 35121006: //satellite safety
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.SATELLITESAFE_PROC, ret.info.get(MapleStatInfo.x));
                            ret.statups.put(MapleBuffStat.SATELLITESAFE_ABSORB, ret.info.get(MapleStatInfo.y));
                            break;
                        case 80001040:
                        case 20021110:
                        case 20031203:
                            ret.moveTo = ret.info.get(MapleStatInfo.x);
                            break;
                        case 5311004:
                            ret.statups.put(MapleBuffStat.BARREL_ROLL, 0);
                            break;
                        case 5121015:
                            ret.statups.put(MapleBuffStat.DAMAGE_BUFF, ret.info.get(MapleStatInfo.x));
                            break;
                        case 80001089: // Soaring
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.SOARING, 1);
                            break;
                        case 20031205:
                            ret.statups.put(MapleBuffStat.PHANTOM_MOVE, ret.info.get(MapleStatInfo.x));
                            break;
                        case 5211009:
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            break;
                        case 35001001: //flame
                        case 35101009:
                            ret.info.put(MapleStatInfo.time, 1000);
                            ret.statups.put(MapleBuffStat.MECH_CHANGE, level); //ya wtf
                            break;
                        case 35121013:
                        case 35111004: //siege
                            ret.info.put(MapleStatInfo.time, 5000);
                            ret.statups.put(MapleBuffStat.MECH_CHANGE, level); //ya wtf
                            break;
                        case 35121005: //missile
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.MECH_CHANGE, level); //ya wtf
                            break;
                        case 10001075: // Cygnus Echo
                        case 50001075: // Mihile's Empress's Prayer
                            ret.statups.put(MapleBuffStat.ECHO_OF_HERO, ret.info.get(MapleStatInfo.x));
                            break;       
                        case 51111007:
                        // case 51121008:
                        //     ret.monsterStatus.put(MonsterStatus.STUN, 1);
                        //     break;
                        // case 51121007:
                        //     ret.statups.put(MapleBuffStat.BLIND, ret.info.get(MapleStatInfo.x));
                        //     ret.monsterStatus.put(MonsterStatus.ACC, ret.info.get(MapleStatInfo.x));
                        //     break;
                        default:
                            break;
                    }
                }
            }
            if (GameConstants.isBeginnerJob(sourceid / 10000)) {
                    switch (sourceid % 10000) {
                        case 1087:
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.INDIE_PAD, 10);
                            ret.statups.put(MapleBuffStat.INDIE_MAD, 10);
                            ret.statups.put(MapleBuffStat.SPEED, 1);
                            break;
                        case 1085:
                        case 1090:
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.INDIE_PAD, 5);
                            ret.statups.put(MapleBuffStat.INDIE_MAD, 5);
                            ret.statups.put(MapleBuffStat.SPEED, 1);
                            break;
                        case 1179:
                            ret.info.put(MapleStatInfo.time, 2100000000);
                            ret.statups.put(MapleBuffStat.INDIE_PAD, 12);
                            ret.statups.put(MapleBuffStat.INDIE_MAD, 12);
                            ret.statups.put(MapleBuffStat.SPEED, 1);
                            break;
//            if (GameConstants.isBeginnerJob(sourceid / 10000)) {
//                switch (sourceid % 10000) {
//                    //angelic blessing: HACK, we're actually supposed to use the passives for atk/matk buff
//                    case 1087:
//                        ret.info.put(MapleStatInfo.time, 2100000000);
//                        ret.statups.put(MapleBuffStat.INDIE_PAD, 10);
//                        ret.statups.put(MapleBuffStat.INDIE_MAD, 10);
//                        break;
//                    case 1085:
//                    case 1090:
//                        ret.info.put(MapleStatInfo.time, 2100000000);
//                        ret.statups.put(MapleBuffStat.INDIE_PAD, 5);
//                        ret.statups.put(MapleBuffStat.INDIE_MAD, 5);
//                        break;
//                    case 1179:
//                    case 1154:
//                        ret.info.put(MapleStatInfo.time, 2100000000);
//                        ret.statups.put(MapleBuffStat.INDIE_PAD, 12);
//                        ret.statups.put(MapleBuffStat.INDIE_MAD, 12);
//                        break;
                    case 1105:
                        ret.statups.put(MapleBuffStat.ICE_SKILL, 1);
                        ret.info.put(MapleStatInfo.time, 2100000000);
                        break;
                    case 93:
                        ret.statups.put(MapleBuffStat.HIDDEN_POTENTIAL, 1);
                        break;
                    case 8001:
                        ret.statups.put(MapleBuffStat.SOULARROW, ret.info.get(MapleStatInfo.x));
                        break;
                    case 1005: // Echo of Hero
                        ret.statups.put(MapleBuffStat.ECHO_OF_HERO, ret.info.get(MapleStatInfo.x));
                        break;
                    case 1011: // Berserk fury
                        ret.statups.put(MapleBuffStat.BERSERK_FURY, ret.info.get(MapleStatInfo.x));
                        break;
                    case 1010:
                        ret.statups.put(MapleBuffStat.DIVINE_BODY, 1);
                        break;
                    case 1001:
                        if (sourceid / 10000 == 3001 || sourceid / 10000 == 3000) { //resistance is diff
                            ret.statups.put(MapleBuffStat.INFILTRATE, ret.info.get(MapleStatInfo.x));
                        } else {
                            ret.statups.put(MapleBuffStat.RECOVERY, ret.info.get(MapleStatInfo.x));
                        }
                        break;
                    case 8003:
                        ret.statups.put(MapleBuffStat.MAXHP, ret.info.get(MapleStatInfo.x));
                        ret.statups.put(MapleBuffStat.MAXMP, ret.info.get(MapleStatInfo.x));
                        break;
                    case 8004:
                        ret.statups.put(MapleBuffStat.COMBAT_ORDERS, ret.info.get(MapleStatInfo.x));
                        break;
                    case 8005:
                        ret.statups.put(MapleBuffStat.HOLY_SHIELD, 1);
                        break;
                    case 8006:
                        ret.statups.put(MapleBuffStat.SPEED_INFUSION, ret.info.get(MapleStatInfo.x));
                        break;
                    case 103:
                        ret.monsterStatus.put(MonsterStatus.STUN, 1);
                        break;
                    case 99:
                    case 104:
                        ret.monsterStatus.put(MonsterStatus.FREEZE, 1);
                        ret.info.put(MapleStatInfo.time, ret.info.get(MapleStatInfo.time) * 2); // freezing skills are a little strange
                        break;
                    case 8002:
                        ret.statups.put(MapleBuffStat.SHARP_EYES, (ret.info.get(MapleStatInfo.x) << 8) + ret.info.get(MapleStatInfo.y) + ret.info.get(MapleStatInfo.criticaldamageMax));
                        break;
                    case 1026: // Soaring
                    case 1142: // Soaring
                        ret.info.put(MapleStatInfo.time, 2100000000);
                        ret.statups.put(MapleBuffStat.SOARING, 1);
                        break;
                }
            }
        } else {
            switch (sourceid) {
                case 2022746: //angel bless
                case 2022747: //d.angel bless
                case 2022823:
                    ret.statups.clear(); //no atk/matk
                    ret.statups.put(MapleBuffStat.PYRAMID_PQ, 1); //ITEM_EFFECT buff
                    break;
            }
        }
        if (ret.isPoison()) {
            ret.monsterStatus.put(MonsterStatus.POISON, 1);
        }