Index: battle.c
===================================================================
--- battle.c	(revision 16990)
+++ battle.c	(working copy)
@@ -414,9 +414,9 @@
         ARR_FIND(1, 6, t, tsd->talisman[t] > 0);
 
         if (t < 5 && atk_elem == t)
-            damage -= damage * tsd->talisman[t] * 3 / 100; // -3% custom value
+            damage -= (int)(damage * (tsd->talisman[t] * 3 / 100.0)); // -3% custom value
     }
-    return damage*ratio/100;
+    return (int)(damage*(ratio/100.0));
 }
 /*==========================================
  * Calculates card bonuses damage adjustments.
@@ -439,6 +439,7 @@
 	if( !damage )
 		return 0;
 
+	#define bccDAMAGE_RATE(a){ damage = (int)(damage * ((a) / 1000.0));}
 	switch(attack_type){
 		case BF_MAGIC:
 			if ( sd && !(nk&NK_NO_CARDFIX_ATK) ) {
@@ -454,7 +455,8 @@
 					}
 				}
 				if (cardfix != 1000)
-					damage = damage * cardfix / 1000;
+					bccDAMAGE_RATE(cardfix);
+
 			}
 
 			if( tsd && !(nk&NK_NO_CARDFIX_DEF) )
@@ -498,7 +500,7 @@
 					cardfix = cardfix * ( 100 - tsd->sc.data[SC_MDEF_RATE]->val1 ) / 100;
 
 				if (cardfix != 1000)
-					damage = damage * cardfix / 1000;
+					bccDAMAGE_RATE(cardfix);
 			}
 			break;
 		case BF_WEAPON:
@@ -630,10 +632,11 @@
 					cardfix_ = cardfix_ * (100 + sd->sc.data[SC_EDP]->val1 * 60 ) / 100;
 				}
 #endif
-				if( (left&1) && cardfix_ != 1000 )
-					damage = damage * cardfix_ / 1000;
-				else if( cardfix != 1000 )
-					damage = damage * cardfix / 1000;
+				if( (left&1) && cardfix_ != 1000 ){
+					bccDAMAGE_RATE(cardfix_);
+				}else if( cardfix != 1000 ){
+					bccDAMAGE_RATE(cardfix);
+				}
 
 		}else if( tsd && !(nk&NK_NO_CARDFIX_DEF) ){
 			if( !(nk&NK_NO_ELEFIX) )
@@ -687,7 +690,7 @@
 				cardfix = cardfix * ( 100 - tsd->sc.data[SC_DEF_RATE]->val1 ) / 100;
 
 			if( cardfix != 1000 )
-				damage = damage * cardfix / 1000;
+				bccDAMAGE_RATE(cardfix);
 		}
 			break;
 		case BF_MISC:
@@ -721,7 +724,7 @@
 					cardfix = cardfix * ( 100 - tsd->bonus.long_attack_def_rate ) / 100;
 
 				if (cardfix != 10000)
-					damage = (int)( (int64)damage * cardfix / 1000);
+					bccDAMAGE_RATE(cardfix);
 			}
 			break;
 	}
@@ -748,17 +751,20 @@
     if (battle_config.ksprotection && mob_ksprotected(src, bl))
         return 0;
 
+	#define DAMAGE_RATE(a){damage = (int)(damage * ((a)/100.0)); }
+	#define DAMAGE_SUBRATE(a){damage -= (int)(damage * ((a)/100.0)); }
+	#define DAMAGE_ADDRATE(a){damage += (int)(damage * ((a)/100.0)); }
     if (bl->type == BL_PC) {
         sd=(struct map_session_data *)bl;
         //Special no damage states
         if (flag&BF_WEAPON && sd->special_state.no_weapon_damage)
-            damage -= damage*sd->special_state.no_weapon_damage/100;
+            DAMAGE_SUBRATE(sd->special_state.no_weapon_damage);
 
         if (flag&BF_MAGIC && sd->special_state.no_magic_damage)
-            damage -= damage*sd->special_state.no_magic_damage/100;
+            DAMAGE_SUBRATE(sd->special_state.no_magic_damage);
 
         if (flag&BF_MISC && sd->special_state.no_misc_damage)
-            damage -= damage*sd->special_state.no_misc_damage/100;
+            DAMAGE_SUBRATE(sd->special_state.no_misc_damage);
 
         if (!damage) return 0;
     }
@@ -947,7 +953,7 @@
 
 #ifdef RENEWAL
         if (sc->data[SC_RAID]) {
-            damage += 20*damage/100;
+           DAMAGE_ADDRATE(20);
 
             if (--sc->data[SC_RAID]->val1 == 0)
                 status_change_end(bl, SC_RAID, INVALID_TIMER);
@@ -957,7 +963,7 @@
         if (damage) {
             struct map_session_data *tsd = BL_CAST(BL_PC, src);
             if (sc->data[SC_DEEPSLEEP]) {
-                damage += damage / 2; // 1.5 times more damage while in Deep Sleep.
+                damage += damage>>1; // 1.5 times more damage while in Deep Sleep.
                 status_change_end(bl,SC_DEEPSLEEP,INVALID_TIMER);
             }
             if (tsd && sd && sc->data[SC_CRYSTALIZE] && flag&BF_WEAPON) {
@@ -966,7 +972,7 @@
                     case W_2HMACE:
                     case W_1HAXE:
                     case W_2HAXE:
-                        damage = damage * 150 / 100;
+                        DAMAGE_RATE(150);
                         break;
                     case W_MUSICAL:
                     case W_WHIP:
@@ -981,7 +987,7 @@
                     case W_DAGGER:
                     case W_1HSWORD:
                     case W_2HSWORD:
-                        damage = damage * 50 / 100;
+                        DAMAGE_RATE(50);
                         break;
                 }
             }
@@ -995,7 +1001,7 @@
 #ifndef RENEWAL
         if (sc->data[SC_ASSUMPTIO]) {
             if (map_flag_vs(bl->m))
-                damage = damage*2/3; //Receive 66% damage
+                damage = damage/3*2; //Receive 66% damage
             else
                 damage >>= 1; //Receive 50% damage
         }
@@ -1003,16 +1009,16 @@
 
         if (sc->data[SC_DEFENDER] &&
             (flag&(BF_LONG|BF_WEAPON)) == (BF_LONG|BF_WEAPON))
-            damage=damage*(100-sc->data[SC_DEFENDER]->val2)/100;
+            DAMAGE_RATE(100-sc->data[SC_DEFENDER]->val2);
 
         if (sc->data[SC_ADJUSTMENT] &&
             (flag&(BF_LONG|BF_WEAPON)) == (BF_LONG|BF_WEAPON))
-            damage -= 20*damage/100;
+            DAMAGE_SUBRATE(20);
 
         if (sc->data[SC_FOGWALL] && skill_num != RK_DRAGONBREATH) {
-            if (flag&BF_SKILL) //25% reduction
-                damage -= 25*damage/100;
-            else if ((flag&(BF_LONG|BF_WEAPON)) == (BF_LONG|BF_WEAPON))
+            if (flag&BF_SKILL){ //25% reduction
+                DAMAGE_SUBRATE(25);
+            }else if ((flag&(BF_LONG|BF_WEAPON)) == (BF_LONG|BF_WEAPON))
                 damage >>= 2; //75% reduction
         }
 
@@ -1022,20 +1028,20 @@
             if (sc->data[SC_MANU_DEF])
                 for (i=0; ARRAYLENGTH(mob_manuk)>i; i++)
                     if (mob_manuk[i]==((TBL_MOB *)src)->class_) {
-                        damage -= sc->data[SC_MANU_DEF]->val1*damage/100;
+                        DAMAGE_SUBRATE(sc->data[SC_MANU_DEF]->val1);
                         break;
                     }
             if (sc->data[SC_SPL_DEF])
                 for (i=0; ARRAYLENGTH(mob_splendide)>i; i++)
                     if (mob_splendide[i]==((TBL_MOB *)src)->class_) {
-                        damage -= sc->data[SC_SPL_DEF]->val1*damage/100;
+                        DAMAGE_SUBRATE(sc->data[SC_SPL_DEF]->val1);
                         break;
                     }
         }
 
         if ((sce=sc->data[SC_ARMOR]) && //NPC_DEFENDER
             sce->val3&flag && sce->val4&flag)
-            damage -= damage*sc->data[SC_ARMOR]->val2/100;
+            DAMAGE_SUBRATE(sc->data[SC_ARMOR]->val2);
 
 #ifdef RENEWAL
         if (sc->data[SC_ENERGYCOAT] && (flag&BF_WEAPON || flag&BF_MAGIC) && skill_num != WS_CARTTERMINATION)
@@ -1050,13 +1056,13 @@
             if (!status_charge(bl, 0, (10+5*per)*status->max_sp/1000))
                 status_change_end(bl, SC_ENERGYCOAT, INVALID_TIMER);
             //Reduction: 6% + 6% every 20%
-            damage -= damage * 6 * (1+per) / 100;
+            DAMAGE_SUBRATE(6 * (1+per));
         }
         if (sc->data[SC_GRANITIC_ARMOR]) {
-            damage -= damage * sc->data[SC_GRANITIC_ARMOR]->val2/100;
+            DAMAGE_SUBRATE(sc->data[SC_GRANITIC_ARMOR]->val2);
         }
         if (sc->data[SC_PAIN_KILLER]) {
-            damage -= damage * sc->data[SC_PAIN_KILLER]->val3/100;
+            DAMAGE_SUBRATE(sc->data[SC_PAIN_KILLER]->val3);
         }
         if ((sce=sc->data[SC_MAGMA_FLOW]) && (rnd()%100 <= sce->val2)) {
             skill_castend_damage_id(bl,src,MH_MAGMA_FLOW,sce->val1,gettick(),0);
@@ -1067,7 +1073,7 @@
          **/
 #ifdef RENEWAL
         if (sc->data[SC_STEELBODY]) {
-            damage = damage > 10 ? damage / 10 : 1;
+            damage = damage > 19 ? damage / 10 : 1;
         }
 #endif
 
@@ -1153,7 +1159,7 @@
 
     if (sc && sc->count) {
         if (sc->data[SC_INVINCIBLE] && !sc->data[SC_INVINCIBLEOFF])
-            damage += damage * 75 / 100;
+            DAMAGE_ADDRATE(75);
         // [Epoque]
         if (bl->type == BL_MOB) {
             int i;
@@ -1163,7 +1169,7 @@
                )
                 for (i=0; ARRAYLENGTH(mob_manuk)>i; i++)
                     if (((TBL_MOB *)bl)->class_==mob_manuk[i]) {
-                        damage += damage*sce->val1/100;
+                        DAMAGE_ADDRATE(sce->val1);
                         break;
                     }
             if (((sce=sc->data[SC_SPL_ATK]) && (flag&BF_WEAPON)) ||
@@ -1171,7 +1177,7 @@
                )
                 for (i=0; ARRAYLENGTH(mob_splendide)>i; i++)
                     if (((TBL_MOB *)bl)->class_==mob_splendide[i]) {
-                        damage += damage*sce->val1/100;
+                       DAMAGE_ADDRATE(sce->val1);
                         break;
                     }
         }
@@ -1188,16 +1194,16 @@
     if (battle_config.pk_mode && sd && bl->type == BL_PC && damage && map[bl->m].flag.pvp) {
         if (flag & BF_SKILL) { //Skills get a different reduction than non-skills. [Skotlex]
             if (flag&BF_WEAPON)
-                damage = damage * battle_config.pk_weapon_damage_rate/100;
+                DAMAGE_RATE(battle_config.pk_weapon_damage_rate);
             if (flag&BF_MAGIC)
-                damage = damage * battle_config.pk_magic_damage_rate/100;
+                DAMAGE_RATE(battle_config.pk_magic_damage_rate);
             if (flag&BF_MISC)
-                damage = damage * battle_config.pk_misc_damage_rate/100;
+                DAMAGE_RATE(battle_config.pk_misc_damage_rate);
         } else { //Normal attacks get reductions based on range.
             if (flag & BF_SHORT)
-                damage = damage * battle_config.pk_short_damage_rate/100;
+                DAMAGE_RATE(battle_config.pk_short_damage_rate);
             if (flag & BF_LONG)
-                damage = damage * battle_config.pk_long_damage_rate/100;
+                DAMAGE_RATE(battle_config.pk_long_damage_rate);
         }
         if (!damage) damage  = 1;
     }
@@ -1251,7 +1257,7 @@
         if (map[bl->m].flag.battleground && (md->class_ == MOBID_BLUE_CRYST || md->class_ == MOBID_PINK_CRYST) && flag&BF_SKILL)
             return 0; // Crystal cannot receive skill damage on battlegrounds
     }
-
+	#define bcbgDAMAGE_RATE(a){ damage = (int)(damage * ((a)/100.0)); }
     switch (skill_num) {
         case PA_PRESSURE:
         case HW_GRAVITATION:
@@ -1262,17 +1268,17 @@
             if (flag&BF_SKILL) {
                 //Skills get a different reduction than non-skills. [Skotlex]
                 if (flag&BF_WEAPON)
-                    damage = damage * battle_config.bg_weapon_damage_rate/100;
+                    bcbgDAMAGE_RATE(battle_config.bg_weapon_damage_rate);
                 if (flag&BF_MAGIC)
-                    damage = damage * battle_config.bg_magic_damage_rate/100;
+                    bcbgDAMAGE_RATE(battle_config.bg_magic_damage_rate);
                 if (flag&BF_MISC)
-                    damage = damage * battle_config.bg_misc_damage_rate/100;
+                    bcbgDAMAGE_RATE(battle_config.bg_misc_damage_rate);
             } else {
                 //Normal attacks get reductions based on range.
                 if (flag&BF_SHORT)
-                    damage = damage * battle_config.bg_short_damage_rate/100;
+                    bcbgDAMAGE_RATE(battle_config.bg_short_damage_rate);
                 if (flag&BF_LONG)
-                    damage = damage * battle_config.bg_long_damage_rate/100;
+                    bcbgDAMAGE_RATE(battle_config.bg_long_damage_rate);
             }
 
             if (!damage) damage = 1;
@@ -1291,7 +1297,7 @@
 
     if (!damage) //No reductions to make.
         return 0;
-
+#define bcgdDAMAGE_RATE(a){ damage = (int)(damage * ((a)/100.0));}
     if (md && md->guardian_data) {
         if (class_ == MOBID_EMPERIUM && flag&BF_SKILL) {
             //Skill immunity.
@@ -1331,16 +1337,16 @@
             */
             if (flag & BF_SKILL) { //Skills get a different reduction than non-skills. [Skotlex]
                 if (flag&BF_WEAPON)
-                    damage = damage * battle_config.gvg_weapon_damage_rate/100;
+                    bcgdDAMAGE_RATE(battle_config.gvg_weapon_damage_rate);
                 if (flag&BF_MAGIC)
-                    damage = damage * battle_config.gvg_magic_damage_rate/100;
+                    bcgdDAMAGE_RATE(battle_config.gvg_magic_damage_rate);
                 if (flag&BF_MISC)
-                    damage = damage * battle_config.gvg_misc_damage_rate/100;
+                    bcgdDAMAGE_RATE(battle_config.gvg_misc_damage_rate);
             } else { //Normal attacks get reductions based on range.
                 if (flag & BF_SHORT)
-                    damage = damage * battle_config.gvg_short_damage_rate/100;
+                    bcgdDAMAGE_RATE(battle_config.gvg_short_damage_rate);
                 if (flag & BF_LONG)
-                    damage = damage * battle_config.gvg_long_damage_rate/100;
+                    bcgdDAMAGE_RATE(battle_config.gvg_long_damage_rate);
             }
             if (!damage) damage  = 1;
     }
@@ -1539,9 +1545,9 @@
 
         //SizeFix only for players
         if (!(sd->special_state.no_sizefix || (flag&8)))
-            damage = damage*(type==EQI_HAND_L?
+            damage = (int)(damage*((type==EQI_HAND_L?
                              sd->left_weapon.atkmods[t_size]:
-                             sd->right_weapon.atkmods[t_size])/100;
+                             sd->right_weapon.atkmods[t_size])/100.0));
     }
 
     //Finally, add baseatk
@@ -1557,12 +1563,12 @@
             if (sd->left_weapon.overrefine)
                 damage += rnd()%sd->left_weapon.overrefine+1;
             if (sd->weapon_atk_rate[sd->weapontype2])
-                damage += damage*sd->weapon_atk_rate[sd->weapontype2]/100;;
+                damage += (int)(damage*(sd->weapon_atk_rate[sd->weapontype2]/100.0));
         } else { //Right hand
             if (sd->right_weapon.overrefine)
                 damage += rnd()%sd->right_weapon.overrefine+1;
             if (sd->weapon_atk_rate[sd->weapontype1])
-                damage += damage*sd->weapon_atk_rate[sd->weapontype1]/100;;
+                damage += (int)(damage*(sd->weapon_atk_rate[sd->weapontype1]/100.0));
         }
     }
     return damage;
@@ -2019,11 +2025,13 @@
 
         //Assuming that 99% of the cases we will not need to check for the flag.rh... we don't.
         //ATK_RATE scales the damage. 100 = no change. 50 is halved, 200 is doubled, etc
-#define ATK_RATE( a ) { wd.damage= wd.damage*(a)/100 ; if(flag.lh) wd.damage2= wd.damage2*(a)/100; }
-#define ATK_RATE2( a , b ) { wd.damage= wd.damage*(a)/100 ; if(flag.lh) wd.damage2= wd.damage2*(b)/100; }
+#define ATK_RATE( a ) { wd.damage= (int)(wd.damage*((a)/100.0)); if(flag.lh) wd.damage2= (int)(wd.damage2*((a)/100.0)); }
+#define ATK_RATE1( a ) { wd.damage= (int)(wd.damage*((a)/100.0)); }
+#define ATK_RATE2( a ) { wd.damage2= (int)(wd.damage2*((a)/100.0)); }
+#define ATK_RATE3( a , b ) { wd.damage= (int)(wd.damage*((a)/100.0)) ; if(flag.lh) wd.damage2= wd.damage2*(b)/100; }
         //Adds dmg%. 100 = +100% (double) damage. 10 = +10% damage
-#define ATK_ADDRATE( a ) { wd.damage+= wd.damage*(a)/100 ; if(flag.lh) wd.damage2+= wd.damage2*(a)/100; }
-#define ATK_ADDRATE2( a , b ) { wd.damage+= wd.damage*(a)/100 ; if(flag.lh) wd.damage2+= wd.damage2*(b)/100; }
+#define ATK_ADDRATE( a ) { wd.damage+= (int)(wd.damage * ((a)/100.0)); if(flag.lh) wd.damage2+= (int)(wd.damage2*((a)/100.0)); }
+#define ATK_ADDRATE2( a , b ) { wd.damage+= (int)(wd.damage*((a)/100.0)); if(flag.lh) wd.damage2+= (int)(wd.damage*((b)/100.0)); }
         //Adds an absolute value to damage. 100 = +100 damage
 #define ATK_ADD( a ) { wd.damage+= a; if (flag.lh) wd.damage2+= a; }
 #define ATK_ADD2( a , b ) { wd.damage+= a; if (flag.lh) wd.damage2+= b; }
@@ -2036,7 +2044,7 @@
                 status_set_hp(src, 1, 0);
                 break;
             case PA_SACRIFICE:
-                wd.damage = sstatus->max_hp* 9/100;
+                wd.damage = (int)(sstatus->max_hp* 0.09);
                 wd.damage2 = 0;
                 break;
 #ifndef RENEWAL
@@ -2106,7 +2114,7 @@
                                 i |= 16; // for ex. shuriken must not be influenced by DEX
                         }
                     wd.damage = battle_calc_base_damage(sstatus, &sstatus->rhw, sc, tstatus->size, sd, i);
-                    if (flag.lh)
+					if (flag.lh)
                         wd.damage2 = battle_calc_base_damage(sstatus, &sstatus->lhw, sc, tstatus->size, sd, i);
 
                     if (nk&NK_SPLASHSPLIT) { // Divide ATK among targets
@@ -3167,13 +3175,13 @@
              * Formula: (1+(900-def1)/9)%
              **/
             if (def1 > 900) def1 = 900;
-            ATK_RATE2(
+            ATK_RATE3(
                 flag.idef ?100:(flag.pdef ?(int)(flag.pdef *(def1+vit_def)):(1+(900-def1)/9)),
                 flag.idef2?100:(flag.pdef2?(int)(flag.pdef2*(def1+vit_def)):(1+(900-def1)/9))
             );
 #else
             if (def1 > 100) def1 = 100;
-            ATK_RATE2(
+            ATK_RATE3(
                 flag.idef ?100:(flag.pdef ?(int)(flag.pdef *(def1+vit_def)):(100-def1)),
                 flag.idef2?100:(flag.pdef2?(int)(flag.pdef2*(def1+vit_def)):(100-def1))
             );
@@ -3357,22 +3365,26 @@
             flag.lh=0;
         } else if (flag.rh && flag.lh) { //Dual-wield
             if (wd.damage) {
-                if ((skill = pc_checkskill(sd,AS_RIGHT)))
-                    wd.damage = wd.damage * (50 + (skill * 10))/100;
-                else if ((skill = pc_checkskill(sd,KO_RIGHT)))
-                    wd.damage = wd.damage * (70 + (skill * 10))/100;
+                if ((skill = pc_checkskill(sd,AS_RIGHT))){
+                    ATK_RATE1(50 + (skill * 10)); }
+                else if ((skill = pc_checkskill(sd,KO_RIGHT))){
+                    ATK_RATE1(70 + (skill * 10)); }
                 if (wd.damage < 1) wd.damage = 1;
             }
             if (wd.damage2) {
                 if ((skill = pc_checkskill(sd,AS_LEFT)))
-                    wd.damage2 = wd.damage2 * (30 + (skill * 10))/100;
-                else if ((skill = pc_checkskill(sd,KO_LEFT)))
-                    wd.damage2 = wd.damage2 * (50 + (skill * 10))/100;
-                if (wd.damage2 < 1) wd.damage2 = 1;
+				{
+                    ATK_RATE2(30 + (skill * 10));
+                }
+				else if ((skill = pc_checkskill(sd,KO_LEFT)))
+				{
+                    ATK_RATE2(50 + (skill * 10));
+                }
+				if (wd.damage2 < 1) wd.damage2 = 1;
             }
         } else if (sd->status.weapon == W_KATAR && !skill_num) { //Katars (offhand damage only applies to normal attacks, tested on Aegis 10.2)
             skill = pc_checkskill(sd,TF_DOUBLE);
-            wd.damage2 = wd.damage * (1 + (skill * 2))/100;
+            ATK_RATE2(1 + (skill * 2));
 
             if (wd.damage && !wd.damage2) wd.damage2 = 1;
             flag.lh = 1;
@@ -3406,7 +3418,7 @@
                 wd.damage = battle_calc_gvg_damage(src,target,wd.damage,wd.div_,skill_num,skill_lv,wd.flag);
             else if (map[target->m].flag.battleground)
                 wd.damage = battle_calc_bg_damage(src,target,wd.damage,wd.div_,skill_num,skill_lv,wd.flag);
-            wd.damage2 = (d2*100/d1)*wd.damage/100;
+            wd.damage2 = (int)(((int)(d2*(100.0/d1)))*(wd.damage/100.0));
             if (wd.damage > 1 && wd.damage2 < 1) wd.damage2 = 1;
             wd.damage-=wd.damage2;
         }
@@ -3420,7 +3432,7 @@
          )) &&
         rnd()%100 < tsc->data[SC_REJECTSWORD]->val2
        ) {
-        wd.damage = wd.damage * 50 / 100;
+        wd.damage >>= 1;
         status_fix_damage(target,src,wd.damage,clif_damage(target,src,gettick(),0,0,wd.damage,0,0,0));
         clif_skill_nodamage(target,target,ST_REJECTSWORD,tsc->data[SC_REJECTSWORD]->val1,1);
         if (--(tsc->data[SC_REJECTSWORD]->val3) <= 0)
@@ -3568,9 +3580,9 @@
     if (!flag.infdef) { //No need to do the math for plants
 
         //MATK_RATE scales the damage. 100 = no change. 50 is halved, 200 is doubled, etc
-#define MATK_RATE( a ) { ad.damage= ad.damage*(a)/100; }
+#define MATK_RATE( a ) { ad.damage= (int)(ad.damage*((a)/100.0)); }
         //Adds dmg%. 100 = +100% (double) damage. 10 = +10% damage
-#define MATK_ADDRATE( a ) { ad.damage+= ad.damage*(a)/100; }
+#define MATK_ADDRATE( a ) { ad.damage+= (int)(ad.damage*((a)/100.0)); }
         //Adds an absolute value to damage. 100 = +100 damage
 #define MATK_ADD( a ) { ad.damage+= a; }
 
@@ -4071,12 +4083,12 @@
              * Damage = Magic Attack * 111.5/(111.5+eMDEF) - sMDEF
              **/
             if (mdef < -111) mdef = -111; // value smaller -111 brings back the damage to origin up to -223.
-            ad.damage = ad.damage * 1115 / (1115 + mdef * 10) - mdef2;
+            ad.damage = ((int)(ad.damage * (1115.0 / (1115 + mdef * 10)))) - mdef2;
 #else
             if (battle_config.magic_defense_type)
                 ad.damage = ad.damage - mdef*battle_config.magic_defense_type - mdef2;
             else
-                ad.damage = ad.damage * (100-mdef)/100 - mdef2;
+                ad.damage = ((int)(ad.damage * ((100-mdef)/100.0))) - mdef2;
 #endif
         }
 
@@ -4101,7 +4113,7 @@
             ad.damage = battle_attr_fix(src, target, wd.damage + ad.damage, s_ele, tstatus->def_ele, tstatus->ele_lv) * (100 + 40*skill_lv)/100;
             if (src == target) {
                 if (src->type == BL_PC)
-                    ad.damage = ad.damage/2;
+                    ad.damage >>= 1; //ad.damage/2;
                 else
                     ad.damage = 0;
             }
@@ -4248,14 +4260,10 @@
             break;
         case CR_ACIDDEMONSTRATION: // updated the formula based on a Japanese formula found to be exact [Reddozen]
             if (tstatus->vit+sstatus->int_) //crash fix
-                md.damage = (int)((int64)7*tstatus->vit*sstatus->int_*sstatus->int_ / (10*(tstatus->vit+sstatus->int_)));
+                md.damage = (int)(7*tstatus->vit*sstatus->int_*(sstatus->int_ / (10.0*(tstatus->vit+sstatus->int_))));
             else
                 md.damage = 0;
             if (tsd) md.damage>>=1;
-            if (md.damage < 0 || md.damage > INT_MAX>>1)
-                //Overflow prevention, will anyone whine if I cap it to a few billion?
-                //Not capped to INT_MAX to give some room for further damage increase.
-                md.damage = INT_MAX>>1;
             break;
         case NJ_ZENYNAGE:
         case KO_MUCHANAGE:
@@ -4265,13 +4273,13 @@
             if (is_boss(target))
                 md.damage=md.damage / (skill_num==NJ_ZENYNAGE?3:2);
             else if (tsd) // need confirmation for KO_MUCHANAGE
-                md.damage=md.damage/2;
+                md.damage >>=1; //md.damage/2;
             break;
         case GS_FLING:
             md.damage = sd?sd->status.job_level:status_get_lv(src);
             break;
         case HVAN_EXPLOSION:    //[orn]
-            md.damage = sstatus->max_hp * (50 + 50 * skill_lv) / 100 ;
+            md.damage = (int)(sstatus->max_hp * ((50 + 50 * skill_lv) / 100.0));
             break ;
         case ASC_BREAKER:
             md.damage = 500+rnd()%500 + 5*skill_lv * sstatus->int_;
@@ -4287,7 +4295,7 @@
         case RK_DRAGONBREATH:
             md.damage = ((status_get_hp(src) / 50) + (status_get_max_sp(src) / 4)) * skill_lv;
             RE_LVL_MDMOD(150);
-            if (sd) md.damage = md.damage * (100 + 5 * (pc_checkskill(sd,RK_DRAGONTRAINING) - 1)) / 100;
+            if (sd) md.damage = (int)(md.damage * ((100 + 5 * (pc_checkskill(sd,RK_DRAGONTRAINING) - 1)) / 100.0));
             md.flag |= BF_LONG|BF_WEAPON;
             break;
             /**
@@ -4321,7 +4329,7 @@
         case KO_HAPPOKUNAI: {
                 struct Damage wd = battle_calc_weapon_attack(src,target,skill_num,skill_lv,mflag);
                 short totaldef = tstatus->def2 + (short)status_get_def(target);
-                md.damage = wd.damage * 60 * (5 + skill_lv) / 100;
+                md.damage = (int)(wd.damage * (60 * (5 + skill_lv) / 100.0));
                 md.damage -= totaldef;
             }
             break;