diff --git a/addons/frag/CfgAmmo.hpp b/addons/frag/CfgAmmo.hpp
index 8ad76e6ae8..8d965e8d2e 100644
--- a/addons/frag/CfgAmmo.hpp
+++ b/addons/frag/CfgAmmo.hpp
@@ -8,6 +8,9 @@ class CfgAmmo {
     //class ace_arty_105mm_m1_m782_delay: ace_arty_105mm_m1_m782_prox {
     //    ACE_FRAG_SKIP = 1;
     //};
+    
+    #include "CfgAmmoReflections.hpp"
+    
     class Bo_GBU12_LGB;
     class Nou_GBU12 : Bo_GBU12_LGB {
         ACE_FRAG_CLASSES[] = {"ACE_frag_large", "ACE_frag_large", "ACE_frag_large_HD", "ACE_frag_large", "ACE_frag_huge", "ACE_frag_huge_HD", "ACE_frag_huge"};
diff --git a/addons/frag/CfgAmmoReflections.hpp b/addons/frag/CfgAmmoReflections.hpp
new file mode 100644
index 0000000000..8e481a9cd0
--- /dev/null
+++ b/addons/frag/CfgAmmoReflections.hpp
@@ -0,0 +1,2523 @@
+//CfgAmmoReflections.hpp
+
+#define ACE_EXPLOSION_REFLECTION(range, hit) class ace_explosion_reflection_##range##_##hit : ace_explosion_reflection_base { indirectHitRange = range; indirectHit = hit; dangerRadiusHit = range*3; suppressionRadiusHit = range*2; };
+class Sh_120mm_HE;
+class ace_explosion_reflection_base : Sh_120mm_HE {
+    CraterWaterEffects = "";
+    CraterEffects = "";
+    effectsMissile = "";
+    ExplosionEffects = "";
+    effectFlare = "";
+    class HitEffects {
+        hitWater = "";
+    };
+    multiSoundHit[] = {};
+    explosionTime = 0.0001;
+    explosive = 1;
+    soundFakeFall[] = {};
+    typicalSpeed = 0;
+    model = "\A3\Weapons_F\empty.p3d";
+    craterShape = "\A3\weapons_f\empty.p3d";
+};
+
+ACE_EXPLOSION_REFLECTION(2,10);
+ACE_EXPLOSION_REFLECTION(2,20);
+ACE_EXPLOSION_REFLECTION(2,30);
+ACE_EXPLOSION_REFLECTION(2,40);
+ACE_EXPLOSION_REFLECTION(2,50);
+ACE_EXPLOSION_REFLECTION(2,60);
+ACE_EXPLOSION_REFLECTION(2,70);
+ACE_EXPLOSION_REFLECTION(2,80);
+ACE_EXPLOSION_REFLECTION(2,90);
+ACE_EXPLOSION_REFLECTION(2,100);
+ACE_EXPLOSION_REFLECTION(2,110);
+ACE_EXPLOSION_REFLECTION(2,120);
+ACE_EXPLOSION_REFLECTION(2,130);
+ACE_EXPLOSION_REFLECTION(2,140);
+ACE_EXPLOSION_REFLECTION(2,150);
+ACE_EXPLOSION_REFLECTION(2,160);
+ACE_EXPLOSION_REFLECTION(2,170);
+ACE_EXPLOSION_REFLECTION(2,180);
+ACE_EXPLOSION_REFLECTION(2,190);
+ACE_EXPLOSION_REFLECTION(2,200);
+ACE_EXPLOSION_REFLECTION(2,210);
+ACE_EXPLOSION_REFLECTION(2,220);
+ACE_EXPLOSION_REFLECTION(2,230);
+ACE_EXPLOSION_REFLECTION(2,240);
+ACE_EXPLOSION_REFLECTION(2,250);
+ACE_EXPLOSION_REFLECTION(2,260);
+ACE_EXPLOSION_REFLECTION(2,270);
+ACE_EXPLOSION_REFLECTION(2,280);
+ACE_EXPLOSION_REFLECTION(2,290);
+ACE_EXPLOSION_REFLECTION(2,300);
+ACE_EXPLOSION_REFLECTION(2,310);
+ACE_EXPLOSION_REFLECTION(2,320);
+ACE_EXPLOSION_REFLECTION(2,330);
+ACE_EXPLOSION_REFLECTION(2,340);
+ACE_EXPLOSION_REFLECTION(2,350);
+ACE_EXPLOSION_REFLECTION(2,360);
+ACE_EXPLOSION_REFLECTION(2,370);
+ACE_EXPLOSION_REFLECTION(2,380);
+ACE_EXPLOSION_REFLECTION(2,390);
+ACE_EXPLOSION_REFLECTION(2,400);
+ACE_EXPLOSION_REFLECTION(2,410);
+ACE_EXPLOSION_REFLECTION(2,420);
+ACE_EXPLOSION_REFLECTION(2,430);
+ACE_EXPLOSION_REFLECTION(2,440);
+ACE_EXPLOSION_REFLECTION(2,450);
+ACE_EXPLOSION_REFLECTION(2,460);
+ACE_EXPLOSION_REFLECTION(2,470);
+ACE_EXPLOSION_REFLECTION(2,480);
+ACE_EXPLOSION_REFLECTION(2,490);
+ACE_EXPLOSION_REFLECTION(2,500);
+ACE_EXPLOSION_REFLECTION(4,10);
+ACE_EXPLOSION_REFLECTION(4,20);
+ACE_EXPLOSION_REFLECTION(4,30);
+ACE_EXPLOSION_REFLECTION(4,40);
+ACE_EXPLOSION_REFLECTION(4,50);
+ACE_EXPLOSION_REFLECTION(4,60);
+ACE_EXPLOSION_REFLECTION(4,70);
+ACE_EXPLOSION_REFLECTION(4,80);
+ACE_EXPLOSION_REFLECTION(4,90);
+ACE_EXPLOSION_REFLECTION(4,100);
+ACE_EXPLOSION_REFLECTION(4,110);
+ACE_EXPLOSION_REFLECTION(4,120);
+ACE_EXPLOSION_REFLECTION(4,130);
+ACE_EXPLOSION_REFLECTION(4,140);
+ACE_EXPLOSION_REFLECTION(4,150);
+ACE_EXPLOSION_REFLECTION(4,160);
+ACE_EXPLOSION_REFLECTION(4,170);
+ACE_EXPLOSION_REFLECTION(4,180);
+ACE_EXPLOSION_REFLECTION(4,190);
+ACE_EXPLOSION_REFLECTION(4,200);
+ACE_EXPLOSION_REFLECTION(4,210);
+ACE_EXPLOSION_REFLECTION(4,220);
+ACE_EXPLOSION_REFLECTION(4,230);
+ACE_EXPLOSION_REFLECTION(4,240);
+ACE_EXPLOSION_REFLECTION(4,250);
+ACE_EXPLOSION_REFLECTION(4,260);
+ACE_EXPLOSION_REFLECTION(4,270);
+ACE_EXPLOSION_REFLECTION(4,280);
+ACE_EXPLOSION_REFLECTION(4,290);
+ACE_EXPLOSION_REFLECTION(4,300);
+ACE_EXPLOSION_REFLECTION(4,310);
+ACE_EXPLOSION_REFLECTION(4,320);
+ACE_EXPLOSION_REFLECTION(4,330);
+ACE_EXPLOSION_REFLECTION(4,340);
+ACE_EXPLOSION_REFLECTION(4,350);
+ACE_EXPLOSION_REFLECTION(4,360);
+ACE_EXPLOSION_REFLECTION(4,370);
+ACE_EXPLOSION_REFLECTION(4,380);
+ACE_EXPLOSION_REFLECTION(4,390);
+ACE_EXPLOSION_REFLECTION(4,400);
+ACE_EXPLOSION_REFLECTION(4,410);
+ACE_EXPLOSION_REFLECTION(4,420);
+ACE_EXPLOSION_REFLECTION(4,430);
+ACE_EXPLOSION_REFLECTION(4,440);
+ACE_EXPLOSION_REFLECTION(4,450);
+ACE_EXPLOSION_REFLECTION(4,460);
+ACE_EXPLOSION_REFLECTION(4,470);
+ACE_EXPLOSION_REFLECTION(4,480);
+ACE_EXPLOSION_REFLECTION(4,490);
+ACE_EXPLOSION_REFLECTION(4,500);
+ACE_EXPLOSION_REFLECTION(6,10);
+ACE_EXPLOSION_REFLECTION(6,20);
+ACE_EXPLOSION_REFLECTION(6,30);
+ACE_EXPLOSION_REFLECTION(6,40);
+ACE_EXPLOSION_REFLECTION(6,50);
+ACE_EXPLOSION_REFLECTION(6,60);
+ACE_EXPLOSION_REFLECTION(6,70);
+ACE_EXPLOSION_REFLECTION(6,80);
+ACE_EXPLOSION_REFLECTION(6,90);
+ACE_EXPLOSION_REFLECTION(6,100);
+ACE_EXPLOSION_REFLECTION(6,110);
+ACE_EXPLOSION_REFLECTION(6,120);
+ACE_EXPLOSION_REFLECTION(6,130);
+ACE_EXPLOSION_REFLECTION(6,140);
+ACE_EXPLOSION_REFLECTION(6,150);
+ACE_EXPLOSION_REFLECTION(6,160);
+ACE_EXPLOSION_REFLECTION(6,170);
+ACE_EXPLOSION_REFLECTION(6,180);
+ACE_EXPLOSION_REFLECTION(6,190);
+ACE_EXPLOSION_REFLECTION(6,200);
+ACE_EXPLOSION_REFLECTION(6,210);
+ACE_EXPLOSION_REFLECTION(6,220);
+ACE_EXPLOSION_REFLECTION(6,230);
+ACE_EXPLOSION_REFLECTION(6,240);
+ACE_EXPLOSION_REFLECTION(6,250);
+ACE_EXPLOSION_REFLECTION(6,260);
+ACE_EXPLOSION_REFLECTION(6,270);
+ACE_EXPLOSION_REFLECTION(6,280);
+ACE_EXPLOSION_REFLECTION(6,290);
+ACE_EXPLOSION_REFLECTION(6,300);
+ACE_EXPLOSION_REFLECTION(6,310);
+ACE_EXPLOSION_REFLECTION(6,320);
+ACE_EXPLOSION_REFLECTION(6,330);
+ACE_EXPLOSION_REFLECTION(6,340);
+ACE_EXPLOSION_REFLECTION(6,350);
+ACE_EXPLOSION_REFLECTION(6,360);
+ACE_EXPLOSION_REFLECTION(6,370);
+ACE_EXPLOSION_REFLECTION(6,380);
+ACE_EXPLOSION_REFLECTION(6,390);
+ACE_EXPLOSION_REFLECTION(6,400);
+ACE_EXPLOSION_REFLECTION(6,410);
+ACE_EXPLOSION_REFLECTION(6,420);
+ACE_EXPLOSION_REFLECTION(6,430);
+ACE_EXPLOSION_REFLECTION(6,440);
+ACE_EXPLOSION_REFLECTION(6,450);
+ACE_EXPLOSION_REFLECTION(6,460);
+ACE_EXPLOSION_REFLECTION(6,470);
+ACE_EXPLOSION_REFLECTION(6,480);
+ACE_EXPLOSION_REFLECTION(6,490);
+ACE_EXPLOSION_REFLECTION(6,500);
+ACE_EXPLOSION_REFLECTION(8,10);
+ACE_EXPLOSION_REFLECTION(8,20);
+ACE_EXPLOSION_REFLECTION(8,30);
+ACE_EXPLOSION_REFLECTION(8,40);
+ACE_EXPLOSION_REFLECTION(8,50);
+ACE_EXPLOSION_REFLECTION(8,60);
+ACE_EXPLOSION_REFLECTION(8,70);
+ACE_EXPLOSION_REFLECTION(8,80);
+ACE_EXPLOSION_REFLECTION(8,90);
+ACE_EXPLOSION_REFLECTION(8,100);
+ACE_EXPLOSION_REFLECTION(8,110);
+ACE_EXPLOSION_REFLECTION(8,120);
+ACE_EXPLOSION_REFLECTION(8,130);
+ACE_EXPLOSION_REFLECTION(8,140);
+ACE_EXPLOSION_REFLECTION(8,150);
+ACE_EXPLOSION_REFLECTION(8,160);
+ACE_EXPLOSION_REFLECTION(8,170);
+ACE_EXPLOSION_REFLECTION(8,180);
+ACE_EXPLOSION_REFLECTION(8,190);
+ACE_EXPLOSION_REFLECTION(8,200);
+ACE_EXPLOSION_REFLECTION(8,210);
+ACE_EXPLOSION_REFLECTION(8,220);
+ACE_EXPLOSION_REFLECTION(8,230);
+ACE_EXPLOSION_REFLECTION(8,240);
+ACE_EXPLOSION_REFLECTION(8,250);
+ACE_EXPLOSION_REFLECTION(8,260);
+ACE_EXPLOSION_REFLECTION(8,270);
+ACE_EXPLOSION_REFLECTION(8,280);
+ACE_EXPLOSION_REFLECTION(8,290);
+ACE_EXPLOSION_REFLECTION(8,300);
+ACE_EXPLOSION_REFLECTION(8,310);
+ACE_EXPLOSION_REFLECTION(8,320);
+ACE_EXPLOSION_REFLECTION(8,330);
+ACE_EXPLOSION_REFLECTION(8,340);
+ACE_EXPLOSION_REFLECTION(8,350);
+ACE_EXPLOSION_REFLECTION(8,360);
+ACE_EXPLOSION_REFLECTION(8,370);
+ACE_EXPLOSION_REFLECTION(8,380);
+ACE_EXPLOSION_REFLECTION(8,390);
+ACE_EXPLOSION_REFLECTION(8,400);
+ACE_EXPLOSION_REFLECTION(8,410);
+ACE_EXPLOSION_REFLECTION(8,420);
+ACE_EXPLOSION_REFLECTION(8,430);
+ACE_EXPLOSION_REFLECTION(8,440);
+ACE_EXPLOSION_REFLECTION(8,450);
+ACE_EXPLOSION_REFLECTION(8,460);
+ACE_EXPLOSION_REFLECTION(8,470);
+ACE_EXPLOSION_REFLECTION(8,480);
+ACE_EXPLOSION_REFLECTION(8,490);
+ACE_EXPLOSION_REFLECTION(8,500);
+ACE_EXPLOSION_REFLECTION(10,10);
+ACE_EXPLOSION_REFLECTION(10,20);
+ACE_EXPLOSION_REFLECTION(10,30);
+ACE_EXPLOSION_REFLECTION(10,40);
+ACE_EXPLOSION_REFLECTION(10,50);
+ACE_EXPLOSION_REFLECTION(10,60);
+ACE_EXPLOSION_REFLECTION(10,70);
+ACE_EXPLOSION_REFLECTION(10,80);
+ACE_EXPLOSION_REFLECTION(10,90);
+ACE_EXPLOSION_REFLECTION(10,100);
+ACE_EXPLOSION_REFLECTION(10,110);
+ACE_EXPLOSION_REFLECTION(10,120);
+ACE_EXPLOSION_REFLECTION(10,130);
+ACE_EXPLOSION_REFLECTION(10,140);
+ACE_EXPLOSION_REFLECTION(10,150);
+ACE_EXPLOSION_REFLECTION(10,160);
+ACE_EXPLOSION_REFLECTION(10,170);
+ACE_EXPLOSION_REFLECTION(10,180);
+ACE_EXPLOSION_REFLECTION(10,190);
+ACE_EXPLOSION_REFLECTION(10,200);
+ACE_EXPLOSION_REFLECTION(10,210);
+ACE_EXPLOSION_REFLECTION(10,220);
+ACE_EXPLOSION_REFLECTION(10,230);
+ACE_EXPLOSION_REFLECTION(10,240);
+ACE_EXPLOSION_REFLECTION(10,250);
+ACE_EXPLOSION_REFLECTION(10,260);
+ACE_EXPLOSION_REFLECTION(10,270);
+ACE_EXPLOSION_REFLECTION(10,280);
+ACE_EXPLOSION_REFLECTION(10,290);
+ACE_EXPLOSION_REFLECTION(10,300);
+ACE_EXPLOSION_REFLECTION(10,310);
+ACE_EXPLOSION_REFLECTION(10,320);
+ACE_EXPLOSION_REFLECTION(10,330);
+ACE_EXPLOSION_REFLECTION(10,340);
+ACE_EXPLOSION_REFLECTION(10,350);
+ACE_EXPLOSION_REFLECTION(10,360);
+ACE_EXPLOSION_REFLECTION(10,370);
+ACE_EXPLOSION_REFLECTION(10,380);
+ACE_EXPLOSION_REFLECTION(10,390);
+ACE_EXPLOSION_REFLECTION(10,400);
+ACE_EXPLOSION_REFLECTION(10,410);
+ACE_EXPLOSION_REFLECTION(10,420);
+ACE_EXPLOSION_REFLECTION(10,430);
+ACE_EXPLOSION_REFLECTION(10,440);
+ACE_EXPLOSION_REFLECTION(10,450);
+ACE_EXPLOSION_REFLECTION(10,460);
+ACE_EXPLOSION_REFLECTION(10,470);
+ACE_EXPLOSION_REFLECTION(10,480);
+ACE_EXPLOSION_REFLECTION(10,490);
+ACE_EXPLOSION_REFLECTION(10,500);
+ACE_EXPLOSION_REFLECTION(12,10);
+ACE_EXPLOSION_REFLECTION(12,20);
+ACE_EXPLOSION_REFLECTION(12,30);
+ACE_EXPLOSION_REFLECTION(12,40);
+ACE_EXPLOSION_REFLECTION(12,50);
+ACE_EXPLOSION_REFLECTION(12,60);
+ACE_EXPLOSION_REFLECTION(12,70);
+ACE_EXPLOSION_REFLECTION(12,80);
+ACE_EXPLOSION_REFLECTION(12,90);
+ACE_EXPLOSION_REFLECTION(12,100);
+ACE_EXPLOSION_REFLECTION(12,110);
+ACE_EXPLOSION_REFLECTION(12,120);
+ACE_EXPLOSION_REFLECTION(12,130);
+ACE_EXPLOSION_REFLECTION(12,140);
+ACE_EXPLOSION_REFLECTION(12,150);
+ACE_EXPLOSION_REFLECTION(12,160);
+ACE_EXPLOSION_REFLECTION(12,170);
+ACE_EXPLOSION_REFLECTION(12,180);
+ACE_EXPLOSION_REFLECTION(12,190);
+ACE_EXPLOSION_REFLECTION(12,200);
+ACE_EXPLOSION_REFLECTION(12,210);
+ACE_EXPLOSION_REFLECTION(12,220);
+ACE_EXPLOSION_REFLECTION(12,230);
+ACE_EXPLOSION_REFLECTION(12,240);
+ACE_EXPLOSION_REFLECTION(12,250);
+ACE_EXPLOSION_REFLECTION(12,260);
+ACE_EXPLOSION_REFLECTION(12,270);
+ACE_EXPLOSION_REFLECTION(12,280);
+ACE_EXPLOSION_REFLECTION(12,290);
+ACE_EXPLOSION_REFLECTION(12,300);
+ACE_EXPLOSION_REFLECTION(12,310);
+ACE_EXPLOSION_REFLECTION(12,320);
+ACE_EXPLOSION_REFLECTION(12,330);
+ACE_EXPLOSION_REFLECTION(12,340);
+ACE_EXPLOSION_REFLECTION(12,350);
+ACE_EXPLOSION_REFLECTION(12,360);
+ACE_EXPLOSION_REFLECTION(12,370);
+ACE_EXPLOSION_REFLECTION(12,380);
+ACE_EXPLOSION_REFLECTION(12,390);
+ACE_EXPLOSION_REFLECTION(12,400);
+ACE_EXPLOSION_REFLECTION(12,410);
+ACE_EXPLOSION_REFLECTION(12,420);
+ACE_EXPLOSION_REFLECTION(12,430);
+ACE_EXPLOSION_REFLECTION(12,440);
+ACE_EXPLOSION_REFLECTION(12,450);
+ACE_EXPLOSION_REFLECTION(12,460);
+ACE_EXPLOSION_REFLECTION(12,470);
+ACE_EXPLOSION_REFLECTION(12,480);
+ACE_EXPLOSION_REFLECTION(12,490);
+ACE_EXPLOSION_REFLECTION(12,500);
+ACE_EXPLOSION_REFLECTION(14,10);
+ACE_EXPLOSION_REFLECTION(14,20);
+ACE_EXPLOSION_REFLECTION(14,30);
+ACE_EXPLOSION_REFLECTION(14,40);
+ACE_EXPLOSION_REFLECTION(14,50);
+ACE_EXPLOSION_REFLECTION(14,60);
+ACE_EXPLOSION_REFLECTION(14,70);
+ACE_EXPLOSION_REFLECTION(14,80);
+ACE_EXPLOSION_REFLECTION(14,90);
+ACE_EXPLOSION_REFLECTION(14,100);
+ACE_EXPLOSION_REFLECTION(14,110);
+ACE_EXPLOSION_REFLECTION(14,120);
+ACE_EXPLOSION_REFLECTION(14,130);
+ACE_EXPLOSION_REFLECTION(14,140);
+ACE_EXPLOSION_REFLECTION(14,150);
+ACE_EXPLOSION_REFLECTION(14,160);
+ACE_EXPLOSION_REFLECTION(14,170);
+ACE_EXPLOSION_REFLECTION(14,180);
+ACE_EXPLOSION_REFLECTION(14,190);
+ACE_EXPLOSION_REFLECTION(14,200);
+ACE_EXPLOSION_REFLECTION(14,210);
+ACE_EXPLOSION_REFLECTION(14,220);
+ACE_EXPLOSION_REFLECTION(14,230);
+ACE_EXPLOSION_REFLECTION(14,240);
+ACE_EXPLOSION_REFLECTION(14,250);
+ACE_EXPLOSION_REFLECTION(14,260);
+ACE_EXPLOSION_REFLECTION(14,270);
+ACE_EXPLOSION_REFLECTION(14,280);
+ACE_EXPLOSION_REFLECTION(14,290);
+ACE_EXPLOSION_REFLECTION(14,300);
+ACE_EXPLOSION_REFLECTION(14,310);
+ACE_EXPLOSION_REFLECTION(14,320);
+ACE_EXPLOSION_REFLECTION(14,330);
+ACE_EXPLOSION_REFLECTION(14,340);
+ACE_EXPLOSION_REFLECTION(14,350);
+ACE_EXPLOSION_REFLECTION(14,360);
+ACE_EXPLOSION_REFLECTION(14,370);
+ACE_EXPLOSION_REFLECTION(14,380);
+ACE_EXPLOSION_REFLECTION(14,390);
+ACE_EXPLOSION_REFLECTION(14,400);
+ACE_EXPLOSION_REFLECTION(14,410);
+ACE_EXPLOSION_REFLECTION(14,420);
+ACE_EXPLOSION_REFLECTION(14,430);
+ACE_EXPLOSION_REFLECTION(14,440);
+ACE_EXPLOSION_REFLECTION(14,450);
+ACE_EXPLOSION_REFLECTION(14,460);
+ACE_EXPLOSION_REFLECTION(14,470);
+ACE_EXPLOSION_REFLECTION(14,480);
+ACE_EXPLOSION_REFLECTION(14,490);
+ACE_EXPLOSION_REFLECTION(14,500);
+ACE_EXPLOSION_REFLECTION(16,10);
+ACE_EXPLOSION_REFLECTION(16,20);
+ACE_EXPLOSION_REFLECTION(16,30);
+ACE_EXPLOSION_REFLECTION(16,40);
+ACE_EXPLOSION_REFLECTION(16,50);
+ACE_EXPLOSION_REFLECTION(16,60);
+ACE_EXPLOSION_REFLECTION(16,70);
+ACE_EXPLOSION_REFLECTION(16,80);
+ACE_EXPLOSION_REFLECTION(16,90);
+ACE_EXPLOSION_REFLECTION(16,100);
+ACE_EXPLOSION_REFLECTION(16,110);
+ACE_EXPLOSION_REFLECTION(16,120);
+ACE_EXPLOSION_REFLECTION(16,130);
+ACE_EXPLOSION_REFLECTION(16,140);
+ACE_EXPLOSION_REFLECTION(16,150);
+ACE_EXPLOSION_REFLECTION(16,160);
+ACE_EXPLOSION_REFLECTION(16,170);
+ACE_EXPLOSION_REFLECTION(16,180);
+ACE_EXPLOSION_REFLECTION(16,190);
+ACE_EXPLOSION_REFLECTION(16,200);
+ACE_EXPLOSION_REFLECTION(16,210);
+ACE_EXPLOSION_REFLECTION(16,220);
+ACE_EXPLOSION_REFLECTION(16,230);
+ACE_EXPLOSION_REFLECTION(16,240);
+ACE_EXPLOSION_REFLECTION(16,250);
+ACE_EXPLOSION_REFLECTION(16,260);
+ACE_EXPLOSION_REFLECTION(16,270);
+ACE_EXPLOSION_REFLECTION(16,280);
+ACE_EXPLOSION_REFLECTION(16,290);
+ACE_EXPLOSION_REFLECTION(16,300);
+ACE_EXPLOSION_REFLECTION(16,310);
+ACE_EXPLOSION_REFLECTION(16,320);
+ACE_EXPLOSION_REFLECTION(16,330);
+ACE_EXPLOSION_REFLECTION(16,340);
+ACE_EXPLOSION_REFLECTION(16,350);
+ACE_EXPLOSION_REFLECTION(16,360);
+ACE_EXPLOSION_REFLECTION(16,370);
+ACE_EXPLOSION_REFLECTION(16,380);
+ACE_EXPLOSION_REFLECTION(16,390);
+ACE_EXPLOSION_REFLECTION(16,400);
+ACE_EXPLOSION_REFLECTION(16,410);
+ACE_EXPLOSION_REFLECTION(16,420);
+ACE_EXPLOSION_REFLECTION(16,430);
+ACE_EXPLOSION_REFLECTION(16,440);
+ACE_EXPLOSION_REFLECTION(16,450);
+ACE_EXPLOSION_REFLECTION(16,460);
+ACE_EXPLOSION_REFLECTION(16,470);
+ACE_EXPLOSION_REFLECTION(16,480);
+ACE_EXPLOSION_REFLECTION(16,490);
+ACE_EXPLOSION_REFLECTION(16,500);
+ACE_EXPLOSION_REFLECTION(18,10);
+ACE_EXPLOSION_REFLECTION(18,20);
+ACE_EXPLOSION_REFLECTION(18,30);
+ACE_EXPLOSION_REFLECTION(18,40);
+ACE_EXPLOSION_REFLECTION(18,50);
+ACE_EXPLOSION_REFLECTION(18,60);
+ACE_EXPLOSION_REFLECTION(18,70);
+ACE_EXPLOSION_REFLECTION(18,80);
+ACE_EXPLOSION_REFLECTION(18,90);
+ACE_EXPLOSION_REFLECTION(18,100);
+ACE_EXPLOSION_REFLECTION(18,110);
+ACE_EXPLOSION_REFLECTION(18,120);
+ACE_EXPLOSION_REFLECTION(18,130);
+ACE_EXPLOSION_REFLECTION(18,140);
+ACE_EXPLOSION_REFLECTION(18,150);
+ACE_EXPLOSION_REFLECTION(18,160);
+ACE_EXPLOSION_REFLECTION(18,170);
+ACE_EXPLOSION_REFLECTION(18,180);
+ACE_EXPLOSION_REFLECTION(18,190);
+ACE_EXPLOSION_REFLECTION(18,200);
+ACE_EXPLOSION_REFLECTION(18,210);
+ACE_EXPLOSION_REFLECTION(18,220);
+ACE_EXPLOSION_REFLECTION(18,230);
+ACE_EXPLOSION_REFLECTION(18,240);
+ACE_EXPLOSION_REFLECTION(18,250);
+ACE_EXPLOSION_REFLECTION(18,260);
+ACE_EXPLOSION_REFLECTION(18,270);
+ACE_EXPLOSION_REFLECTION(18,280);
+ACE_EXPLOSION_REFLECTION(18,290);
+ACE_EXPLOSION_REFLECTION(18,300);
+ACE_EXPLOSION_REFLECTION(18,310);
+ACE_EXPLOSION_REFLECTION(18,320);
+ACE_EXPLOSION_REFLECTION(18,330);
+ACE_EXPLOSION_REFLECTION(18,340);
+ACE_EXPLOSION_REFLECTION(18,350);
+ACE_EXPLOSION_REFLECTION(18,360);
+ACE_EXPLOSION_REFLECTION(18,370);
+ACE_EXPLOSION_REFLECTION(18,380);
+ACE_EXPLOSION_REFLECTION(18,390);
+ACE_EXPLOSION_REFLECTION(18,400);
+ACE_EXPLOSION_REFLECTION(18,410);
+ACE_EXPLOSION_REFLECTION(18,420);
+ACE_EXPLOSION_REFLECTION(18,430);
+ACE_EXPLOSION_REFLECTION(18,440);
+ACE_EXPLOSION_REFLECTION(18,450);
+ACE_EXPLOSION_REFLECTION(18,460);
+ACE_EXPLOSION_REFLECTION(18,470);
+ACE_EXPLOSION_REFLECTION(18,480);
+ACE_EXPLOSION_REFLECTION(18,490);
+ACE_EXPLOSION_REFLECTION(18,500);
+ACE_EXPLOSION_REFLECTION(20,10);
+ACE_EXPLOSION_REFLECTION(20,20);
+ACE_EXPLOSION_REFLECTION(20,30);
+ACE_EXPLOSION_REFLECTION(20,40);
+ACE_EXPLOSION_REFLECTION(20,50);
+ACE_EXPLOSION_REFLECTION(20,60);
+ACE_EXPLOSION_REFLECTION(20,70);
+ACE_EXPLOSION_REFLECTION(20,80);
+ACE_EXPLOSION_REFLECTION(20,90);
+ACE_EXPLOSION_REFLECTION(20,100);
+ACE_EXPLOSION_REFLECTION(20,110);
+ACE_EXPLOSION_REFLECTION(20,120);
+ACE_EXPLOSION_REFLECTION(20,130);
+ACE_EXPLOSION_REFLECTION(20,140);
+ACE_EXPLOSION_REFLECTION(20,150);
+ACE_EXPLOSION_REFLECTION(20,160);
+ACE_EXPLOSION_REFLECTION(20,170);
+ACE_EXPLOSION_REFLECTION(20,180);
+ACE_EXPLOSION_REFLECTION(20,190);
+ACE_EXPLOSION_REFLECTION(20,200);
+ACE_EXPLOSION_REFLECTION(20,210);
+ACE_EXPLOSION_REFLECTION(20,220);
+ACE_EXPLOSION_REFLECTION(20,230);
+ACE_EXPLOSION_REFLECTION(20,240);
+ACE_EXPLOSION_REFLECTION(20,250);
+ACE_EXPLOSION_REFLECTION(20,260);
+ACE_EXPLOSION_REFLECTION(20,270);
+ACE_EXPLOSION_REFLECTION(20,280);
+ACE_EXPLOSION_REFLECTION(20,290);
+ACE_EXPLOSION_REFLECTION(20,300);
+ACE_EXPLOSION_REFLECTION(20,310);
+ACE_EXPLOSION_REFLECTION(20,320);
+ACE_EXPLOSION_REFLECTION(20,330);
+ACE_EXPLOSION_REFLECTION(20,340);
+ACE_EXPLOSION_REFLECTION(20,350);
+ACE_EXPLOSION_REFLECTION(20,360);
+ACE_EXPLOSION_REFLECTION(20,370);
+ACE_EXPLOSION_REFLECTION(20,380);
+ACE_EXPLOSION_REFLECTION(20,390);
+ACE_EXPLOSION_REFLECTION(20,400);
+ACE_EXPLOSION_REFLECTION(20,410);
+ACE_EXPLOSION_REFLECTION(20,420);
+ACE_EXPLOSION_REFLECTION(20,430);
+ACE_EXPLOSION_REFLECTION(20,440);
+ACE_EXPLOSION_REFLECTION(20,450);
+ACE_EXPLOSION_REFLECTION(20,460);
+ACE_EXPLOSION_REFLECTION(20,470);
+ACE_EXPLOSION_REFLECTION(20,480);
+ACE_EXPLOSION_REFLECTION(20,490);
+ACE_EXPLOSION_REFLECTION(20,500);
+ACE_EXPLOSION_REFLECTION(22,10);
+ACE_EXPLOSION_REFLECTION(22,20);
+ACE_EXPLOSION_REFLECTION(22,30);
+ACE_EXPLOSION_REFLECTION(22,40);
+ACE_EXPLOSION_REFLECTION(22,50);
+ACE_EXPLOSION_REFLECTION(22,60);
+ACE_EXPLOSION_REFLECTION(22,70);
+ACE_EXPLOSION_REFLECTION(22,80);
+ACE_EXPLOSION_REFLECTION(22,90);
+ACE_EXPLOSION_REFLECTION(22,100);
+ACE_EXPLOSION_REFLECTION(22,110);
+ACE_EXPLOSION_REFLECTION(22,120);
+ACE_EXPLOSION_REFLECTION(22,130);
+ACE_EXPLOSION_REFLECTION(22,140);
+ACE_EXPLOSION_REFLECTION(22,150);
+ACE_EXPLOSION_REFLECTION(22,160);
+ACE_EXPLOSION_REFLECTION(22,170);
+ACE_EXPLOSION_REFLECTION(22,180);
+ACE_EXPLOSION_REFLECTION(22,190);
+ACE_EXPLOSION_REFLECTION(22,200);
+ACE_EXPLOSION_REFLECTION(22,210);
+ACE_EXPLOSION_REFLECTION(22,220);
+ACE_EXPLOSION_REFLECTION(22,230);
+ACE_EXPLOSION_REFLECTION(22,240);
+ACE_EXPLOSION_REFLECTION(22,250);
+ACE_EXPLOSION_REFLECTION(22,260);
+ACE_EXPLOSION_REFLECTION(22,270);
+ACE_EXPLOSION_REFLECTION(22,280);
+ACE_EXPLOSION_REFLECTION(22,290);
+ACE_EXPLOSION_REFLECTION(22,300);
+ACE_EXPLOSION_REFLECTION(22,310);
+ACE_EXPLOSION_REFLECTION(22,320);
+ACE_EXPLOSION_REFLECTION(22,330);
+ACE_EXPLOSION_REFLECTION(22,340);
+ACE_EXPLOSION_REFLECTION(22,350);
+ACE_EXPLOSION_REFLECTION(22,360);
+ACE_EXPLOSION_REFLECTION(22,370);
+ACE_EXPLOSION_REFLECTION(22,380);
+ACE_EXPLOSION_REFLECTION(22,390);
+ACE_EXPLOSION_REFLECTION(22,400);
+ACE_EXPLOSION_REFLECTION(22,410);
+ACE_EXPLOSION_REFLECTION(22,420);
+ACE_EXPLOSION_REFLECTION(22,430);
+ACE_EXPLOSION_REFLECTION(22,440);
+ACE_EXPLOSION_REFLECTION(22,450);
+ACE_EXPLOSION_REFLECTION(22,460);
+ACE_EXPLOSION_REFLECTION(22,470);
+ACE_EXPLOSION_REFLECTION(22,480);
+ACE_EXPLOSION_REFLECTION(22,490);
+ACE_EXPLOSION_REFLECTION(22,500);
+ACE_EXPLOSION_REFLECTION(24,10);
+ACE_EXPLOSION_REFLECTION(24,20);
+ACE_EXPLOSION_REFLECTION(24,30);
+ACE_EXPLOSION_REFLECTION(24,40);
+ACE_EXPLOSION_REFLECTION(24,50);
+ACE_EXPLOSION_REFLECTION(24,60);
+ACE_EXPLOSION_REFLECTION(24,70);
+ACE_EXPLOSION_REFLECTION(24,80);
+ACE_EXPLOSION_REFLECTION(24,90);
+ACE_EXPLOSION_REFLECTION(24,100);
+ACE_EXPLOSION_REFLECTION(24,110);
+ACE_EXPLOSION_REFLECTION(24,120);
+ACE_EXPLOSION_REFLECTION(24,130);
+ACE_EXPLOSION_REFLECTION(24,140);
+ACE_EXPLOSION_REFLECTION(24,150);
+ACE_EXPLOSION_REFLECTION(24,160);
+ACE_EXPLOSION_REFLECTION(24,170);
+ACE_EXPLOSION_REFLECTION(24,180);
+ACE_EXPLOSION_REFLECTION(24,190);
+ACE_EXPLOSION_REFLECTION(24,200);
+ACE_EXPLOSION_REFLECTION(24,210);
+ACE_EXPLOSION_REFLECTION(24,220);
+ACE_EXPLOSION_REFLECTION(24,230);
+ACE_EXPLOSION_REFLECTION(24,240);
+ACE_EXPLOSION_REFLECTION(24,250);
+ACE_EXPLOSION_REFLECTION(24,260);
+ACE_EXPLOSION_REFLECTION(24,270);
+ACE_EXPLOSION_REFLECTION(24,280);
+ACE_EXPLOSION_REFLECTION(24,290);
+ACE_EXPLOSION_REFLECTION(24,300);
+ACE_EXPLOSION_REFLECTION(24,310);
+ACE_EXPLOSION_REFLECTION(24,320);
+ACE_EXPLOSION_REFLECTION(24,330);
+ACE_EXPLOSION_REFLECTION(24,340);
+ACE_EXPLOSION_REFLECTION(24,350);
+ACE_EXPLOSION_REFLECTION(24,360);
+ACE_EXPLOSION_REFLECTION(24,370);
+ACE_EXPLOSION_REFLECTION(24,380);
+ACE_EXPLOSION_REFLECTION(24,390);
+ACE_EXPLOSION_REFLECTION(24,400);
+ACE_EXPLOSION_REFLECTION(24,410);
+ACE_EXPLOSION_REFLECTION(24,420);
+ACE_EXPLOSION_REFLECTION(24,430);
+ACE_EXPLOSION_REFLECTION(24,440);
+ACE_EXPLOSION_REFLECTION(24,450);
+ACE_EXPLOSION_REFLECTION(24,460);
+ACE_EXPLOSION_REFLECTION(24,470);
+ACE_EXPLOSION_REFLECTION(24,480);
+ACE_EXPLOSION_REFLECTION(24,490);
+ACE_EXPLOSION_REFLECTION(24,500);
+ACE_EXPLOSION_REFLECTION(26,10);
+ACE_EXPLOSION_REFLECTION(26,20);
+ACE_EXPLOSION_REFLECTION(26,30);
+ACE_EXPLOSION_REFLECTION(26,40);
+ACE_EXPLOSION_REFLECTION(26,50);
+ACE_EXPLOSION_REFLECTION(26,60);
+ACE_EXPLOSION_REFLECTION(26,70);
+ACE_EXPLOSION_REFLECTION(26,80);
+ACE_EXPLOSION_REFLECTION(26,90);
+ACE_EXPLOSION_REFLECTION(26,100);
+ACE_EXPLOSION_REFLECTION(26,110);
+ACE_EXPLOSION_REFLECTION(26,120);
+ACE_EXPLOSION_REFLECTION(26,130);
+ACE_EXPLOSION_REFLECTION(26,140);
+ACE_EXPLOSION_REFLECTION(26,150);
+ACE_EXPLOSION_REFLECTION(26,160);
+ACE_EXPLOSION_REFLECTION(26,170);
+ACE_EXPLOSION_REFLECTION(26,180);
+ACE_EXPLOSION_REFLECTION(26,190);
+ACE_EXPLOSION_REFLECTION(26,200);
+ACE_EXPLOSION_REFLECTION(26,210);
+ACE_EXPLOSION_REFLECTION(26,220);
+ACE_EXPLOSION_REFLECTION(26,230);
+ACE_EXPLOSION_REFLECTION(26,240);
+ACE_EXPLOSION_REFLECTION(26,250);
+ACE_EXPLOSION_REFLECTION(26,260);
+ACE_EXPLOSION_REFLECTION(26,270);
+ACE_EXPLOSION_REFLECTION(26,280);
+ACE_EXPLOSION_REFLECTION(26,290);
+ACE_EXPLOSION_REFLECTION(26,300);
+ACE_EXPLOSION_REFLECTION(26,310);
+ACE_EXPLOSION_REFLECTION(26,320);
+ACE_EXPLOSION_REFLECTION(26,330);
+ACE_EXPLOSION_REFLECTION(26,340);
+ACE_EXPLOSION_REFLECTION(26,350);
+ACE_EXPLOSION_REFLECTION(26,360);
+ACE_EXPLOSION_REFLECTION(26,370);
+ACE_EXPLOSION_REFLECTION(26,380);
+ACE_EXPLOSION_REFLECTION(26,390);
+ACE_EXPLOSION_REFLECTION(26,400);
+ACE_EXPLOSION_REFLECTION(26,410);
+ACE_EXPLOSION_REFLECTION(26,420);
+ACE_EXPLOSION_REFLECTION(26,430);
+ACE_EXPLOSION_REFLECTION(26,440);
+ACE_EXPLOSION_REFLECTION(26,450);
+ACE_EXPLOSION_REFLECTION(26,460);
+ACE_EXPLOSION_REFLECTION(26,470);
+ACE_EXPLOSION_REFLECTION(26,480);
+ACE_EXPLOSION_REFLECTION(26,490);
+ACE_EXPLOSION_REFLECTION(26,500);
+ACE_EXPLOSION_REFLECTION(28,10);
+ACE_EXPLOSION_REFLECTION(28,20);
+ACE_EXPLOSION_REFLECTION(28,30);
+ACE_EXPLOSION_REFLECTION(28,40);
+ACE_EXPLOSION_REFLECTION(28,50);
+ACE_EXPLOSION_REFLECTION(28,60);
+ACE_EXPLOSION_REFLECTION(28,70);
+ACE_EXPLOSION_REFLECTION(28,80);
+ACE_EXPLOSION_REFLECTION(28,90);
+ACE_EXPLOSION_REFLECTION(28,100);
+ACE_EXPLOSION_REFLECTION(28,110);
+ACE_EXPLOSION_REFLECTION(28,120);
+ACE_EXPLOSION_REFLECTION(28,130);
+ACE_EXPLOSION_REFLECTION(28,140);
+ACE_EXPLOSION_REFLECTION(28,150);
+ACE_EXPLOSION_REFLECTION(28,160);
+ACE_EXPLOSION_REFLECTION(28,170);
+ACE_EXPLOSION_REFLECTION(28,180);
+ACE_EXPLOSION_REFLECTION(28,190);
+ACE_EXPLOSION_REFLECTION(28,200);
+ACE_EXPLOSION_REFLECTION(28,210);
+ACE_EXPLOSION_REFLECTION(28,220);
+ACE_EXPLOSION_REFLECTION(28,230);
+ACE_EXPLOSION_REFLECTION(28,240);
+ACE_EXPLOSION_REFLECTION(28,250);
+ACE_EXPLOSION_REFLECTION(28,260);
+ACE_EXPLOSION_REFLECTION(28,270);
+ACE_EXPLOSION_REFLECTION(28,280);
+ACE_EXPLOSION_REFLECTION(28,290);
+ACE_EXPLOSION_REFLECTION(28,300);
+ACE_EXPLOSION_REFLECTION(28,310);
+ACE_EXPLOSION_REFLECTION(28,320);
+ACE_EXPLOSION_REFLECTION(28,330);
+ACE_EXPLOSION_REFLECTION(28,340);
+ACE_EXPLOSION_REFLECTION(28,350);
+ACE_EXPLOSION_REFLECTION(28,360);
+ACE_EXPLOSION_REFLECTION(28,370);
+ACE_EXPLOSION_REFLECTION(28,380);
+ACE_EXPLOSION_REFLECTION(28,390);
+ACE_EXPLOSION_REFLECTION(28,400);
+ACE_EXPLOSION_REFLECTION(28,410);
+ACE_EXPLOSION_REFLECTION(28,420);
+ACE_EXPLOSION_REFLECTION(28,430);
+ACE_EXPLOSION_REFLECTION(28,440);
+ACE_EXPLOSION_REFLECTION(28,450);
+ACE_EXPLOSION_REFLECTION(28,460);
+ACE_EXPLOSION_REFLECTION(28,470);
+ACE_EXPLOSION_REFLECTION(28,480);
+ACE_EXPLOSION_REFLECTION(28,490);
+ACE_EXPLOSION_REFLECTION(28,500);
+ACE_EXPLOSION_REFLECTION(30,10);
+ACE_EXPLOSION_REFLECTION(30,20);
+ACE_EXPLOSION_REFLECTION(30,30);
+ACE_EXPLOSION_REFLECTION(30,40);
+ACE_EXPLOSION_REFLECTION(30,50);
+ACE_EXPLOSION_REFLECTION(30,60);
+ACE_EXPLOSION_REFLECTION(30,70);
+ACE_EXPLOSION_REFLECTION(30,80);
+ACE_EXPLOSION_REFLECTION(30,90);
+ACE_EXPLOSION_REFLECTION(30,100);
+ACE_EXPLOSION_REFLECTION(30,110);
+ACE_EXPLOSION_REFLECTION(30,120);
+ACE_EXPLOSION_REFLECTION(30,130);
+ACE_EXPLOSION_REFLECTION(30,140);
+ACE_EXPLOSION_REFLECTION(30,150);
+ACE_EXPLOSION_REFLECTION(30,160);
+ACE_EXPLOSION_REFLECTION(30,170);
+ACE_EXPLOSION_REFLECTION(30,180);
+ACE_EXPLOSION_REFLECTION(30,190);
+ACE_EXPLOSION_REFLECTION(30,200);
+ACE_EXPLOSION_REFLECTION(30,210);
+ACE_EXPLOSION_REFLECTION(30,220);
+ACE_EXPLOSION_REFLECTION(30,230);
+ACE_EXPLOSION_REFLECTION(30,240);
+ACE_EXPLOSION_REFLECTION(30,250);
+ACE_EXPLOSION_REFLECTION(30,260);
+ACE_EXPLOSION_REFLECTION(30,270);
+ACE_EXPLOSION_REFLECTION(30,280);
+ACE_EXPLOSION_REFLECTION(30,290);
+ACE_EXPLOSION_REFLECTION(30,300);
+ACE_EXPLOSION_REFLECTION(30,310);
+ACE_EXPLOSION_REFLECTION(30,320);
+ACE_EXPLOSION_REFLECTION(30,330);
+ACE_EXPLOSION_REFLECTION(30,340);
+ACE_EXPLOSION_REFLECTION(30,350);
+ACE_EXPLOSION_REFLECTION(30,360);
+ACE_EXPLOSION_REFLECTION(30,370);
+ACE_EXPLOSION_REFLECTION(30,380);
+ACE_EXPLOSION_REFLECTION(30,390);
+ACE_EXPLOSION_REFLECTION(30,400);
+ACE_EXPLOSION_REFLECTION(30,410);
+ACE_EXPLOSION_REFLECTION(30,420);
+ACE_EXPLOSION_REFLECTION(30,430);
+ACE_EXPLOSION_REFLECTION(30,440);
+ACE_EXPLOSION_REFLECTION(30,450);
+ACE_EXPLOSION_REFLECTION(30,460);
+ACE_EXPLOSION_REFLECTION(30,470);
+ACE_EXPLOSION_REFLECTION(30,480);
+ACE_EXPLOSION_REFLECTION(30,490);
+ACE_EXPLOSION_REFLECTION(30,500);
+ACE_EXPLOSION_REFLECTION(32,10);
+ACE_EXPLOSION_REFLECTION(32,20);
+ACE_EXPLOSION_REFLECTION(32,30);
+ACE_EXPLOSION_REFLECTION(32,40);
+ACE_EXPLOSION_REFLECTION(32,50);
+ACE_EXPLOSION_REFLECTION(32,60);
+ACE_EXPLOSION_REFLECTION(32,70);
+ACE_EXPLOSION_REFLECTION(32,80);
+ACE_EXPLOSION_REFLECTION(32,90);
+ACE_EXPLOSION_REFLECTION(32,100);
+ACE_EXPLOSION_REFLECTION(32,110);
+ACE_EXPLOSION_REFLECTION(32,120);
+ACE_EXPLOSION_REFLECTION(32,130);
+ACE_EXPLOSION_REFLECTION(32,140);
+ACE_EXPLOSION_REFLECTION(32,150);
+ACE_EXPLOSION_REFLECTION(32,160);
+ACE_EXPLOSION_REFLECTION(32,170);
+ACE_EXPLOSION_REFLECTION(32,180);
+ACE_EXPLOSION_REFLECTION(32,190);
+ACE_EXPLOSION_REFLECTION(32,200);
+ACE_EXPLOSION_REFLECTION(32,210);
+ACE_EXPLOSION_REFLECTION(32,220);
+ACE_EXPLOSION_REFLECTION(32,230);
+ACE_EXPLOSION_REFLECTION(32,240);
+ACE_EXPLOSION_REFLECTION(32,250);
+ACE_EXPLOSION_REFLECTION(32,260);
+ACE_EXPLOSION_REFLECTION(32,270);
+ACE_EXPLOSION_REFLECTION(32,280);
+ACE_EXPLOSION_REFLECTION(32,290);
+ACE_EXPLOSION_REFLECTION(32,300);
+ACE_EXPLOSION_REFLECTION(32,310);
+ACE_EXPLOSION_REFLECTION(32,320);
+ACE_EXPLOSION_REFLECTION(32,330);
+ACE_EXPLOSION_REFLECTION(32,340);
+ACE_EXPLOSION_REFLECTION(32,350);
+ACE_EXPLOSION_REFLECTION(32,360);
+ACE_EXPLOSION_REFLECTION(32,370);
+ACE_EXPLOSION_REFLECTION(32,380);
+ACE_EXPLOSION_REFLECTION(32,390);
+ACE_EXPLOSION_REFLECTION(32,400);
+ACE_EXPLOSION_REFLECTION(32,410);
+ACE_EXPLOSION_REFLECTION(32,420);
+ACE_EXPLOSION_REFLECTION(32,430);
+ACE_EXPLOSION_REFLECTION(32,440);
+ACE_EXPLOSION_REFLECTION(32,450);
+ACE_EXPLOSION_REFLECTION(32,460);
+ACE_EXPLOSION_REFLECTION(32,470);
+ACE_EXPLOSION_REFLECTION(32,480);
+ACE_EXPLOSION_REFLECTION(32,490);
+ACE_EXPLOSION_REFLECTION(32,500);
+ACE_EXPLOSION_REFLECTION(34,10);
+ACE_EXPLOSION_REFLECTION(34,20);
+ACE_EXPLOSION_REFLECTION(34,30);
+ACE_EXPLOSION_REFLECTION(34,40);
+ACE_EXPLOSION_REFLECTION(34,50);
+ACE_EXPLOSION_REFLECTION(34,60);
+ACE_EXPLOSION_REFLECTION(34,70);
+ACE_EXPLOSION_REFLECTION(34,80);
+ACE_EXPLOSION_REFLECTION(34,90);
+ACE_EXPLOSION_REFLECTION(34,100);
+ACE_EXPLOSION_REFLECTION(34,110);
+ACE_EXPLOSION_REFLECTION(34,120);
+ACE_EXPLOSION_REFLECTION(34,130);
+ACE_EXPLOSION_REFLECTION(34,140);
+ACE_EXPLOSION_REFLECTION(34,150);
+ACE_EXPLOSION_REFLECTION(34,160);
+ACE_EXPLOSION_REFLECTION(34,170);
+ACE_EXPLOSION_REFLECTION(34,180);
+ACE_EXPLOSION_REFLECTION(34,190);
+ACE_EXPLOSION_REFLECTION(34,200);
+ACE_EXPLOSION_REFLECTION(34,210);
+ACE_EXPLOSION_REFLECTION(34,220);
+ACE_EXPLOSION_REFLECTION(34,230);
+ACE_EXPLOSION_REFLECTION(34,240);
+ACE_EXPLOSION_REFLECTION(34,250);
+ACE_EXPLOSION_REFLECTION(34,260);
+ACE_EXPLOSION_REFLECTION(34,270);
+ACE_EXPLOSION_REFLECTION(34,280);
+ACE_EXPLOSION_REFLECTION(34,290);
+ACE_EXPLOSION_REFLECTION(34,300);
+ACE_EXPLOSION_REFLECTION(34,310);
+ACE_EXPLOSION_REFLECTION(34,320);
+ACE_EXPLOSION_REFLECTION(34,330);
+ACE_EXPLOSION_REFLECTION(34,340);
+ACE_EXPLOSION_REFLECTION(34,350);
+ACE_EXPLOSION_REFLECTION(34,360);
+ACE_EXPLOSION_REFLECTION(34,370);
+ACE_EXPLOSION_REFLECTION(34,380);
+ACE_EXPLOSION_REFLECTION(34,390);
+ACE_EXPLOSION_REFLECTION(34,400);
+ACE_EXPLOSION_REFLECTION(34,410);
+ACE_EXPLOSION_REFLECTION(34,420);
+ACE_EXPLOSION_REFLECTION(34,430);
+ACE_EXPLOSION_REFLECTION(34,440);
+ACE_EXPLOSION_REFLECTION(34,450);
+ACE_EXPLOSION_REFLECTION(34,460);
+ACE_EXPLOSION_REFLECTION(34,470);
+ACE_EXPLOSION_REFLECTION(34,480);
+ACE_EXPLOSION_REFLECTION(34,490);
+ACE_EXPLOSION_REFLECTION(34,500);
+ACE_EXPLOSION_REFLECTION(36,10);
+ACE_EXPLOSION_REFLECTION(36,20);
+ACE_EXPLOSION_REFLECTION(36,30);
+ACE_EXPLOSION_REFLECTION(36,40);
+ACE_EXPLOSION_REFLECTION(36,50);
+ACE_EXPLOSION_REFLECTION(36,60);
+ACE_EXPLOSION_REFLECTION(36,70);
+ACE_EXPLOSION_REFLECTION(36,80);
+ACE_EXPLOSION_REFLECTION(36,90);
+ACE_EXPLOSION_REFLECTION(36,100);
+ACE_EXPLOSION_REFLECTION(36,110);
+ACE_EXPLOSION_REFLECTION(36,120);
+ACE_EXPLOSION_REFLECTION(36,130);
+ACE_EXPLOSION_REFLECTION(36,140);
+ACE_EXPLOSION_REFLECTION(36,150);
+ACE_EXPLOSION_REFLECTION(36,160);
+ACE_EXPLOSION_REFLECTION(36,170);
+ACE_EXPLOSION_REFLECTION(36,180);
+ACE_EXPLOSION_REFLECTION(36,190);
+ACE_EXPLOSION_REFLECTION(36,200);
+ACE_EXPLOSION_REFLECTION(36,210);
+ACE_EXPLOSION_REFLECTION(36,220);
+ACE_EXPLOSION_REFLECTION(36,230);
+ACE_EXPLOSION_REFLECTION(36,240);
+ACE_EXPLOSION_REFLECTION(36,250);
+ACE_EXPLOSION_REFLECTION(36,260);
+ACE_EXPLOSION_REFLECTION(36,270);
+ACE_EXPLOSION_REFLECTION(36,280);
+ACE_EXPLOSION_REFLECTION(36,290);
+ACE_EXPLOSION_REFLECTION(36,300);
+ACE_EXPLOSION_REFLECTION(36,310);
+ACE_EXPLOSION_REFLECTION(36,320);
+ACE_EXPLOSION_REFLECTION(36,330);
+ACE_EXPLOSION_REFLECTION(36,340);
+ACE_EXPLOSION_REFLECTION(36,350);
+ACE_EXPLOSION_REFLECTION(36,360);
+ACE_EXPLOSION_REFLECTION(36,370);
+ACE_EXPLOSION_REFLECTION(36,380);
+ACE_EXPLOSION_REFLECTION(36,390);
+ACE_EXPLOSION_REFLECTION(36,400);
+ACE_EXPLOSION_REFLECTION(36,410);
+ACE_EXPLOSION_REFLECTION(36,420);
+ACE_EXPLOSION_REFLECTION(36,430);
+ACE_EXPLOSION_REFLECTION(36,440);
+ACE_EXPLOSION_REFLECTION(36,450);
+ACE_EXPLOSION_REFLECTION(36,460);
+ACE_EXPLOSION_REFLECTION(36,470);
+ACE_EXPLOSION_REFLECTION(36,480);
+ACE_EXPLOSION_REFLECTION(36,490);
+ACE_EXPLOSION_REFLECTION(36,500);
+ACE_EXPLOSION_REFLECTION(38,10);
+ACE_EXPLOSION_REFLECTION(38,20);
+ACE_EXPLOSION_REFLECTION(38,30);
+ACE_EXPLOSION_REFLECTION(38,40);
+ACE_EXPLOSION_REFLECTION(38,50);
+ACE_EXPLOSION_REFLECTION(38,60);
+ACE_EXPLOSION_REFLECTION(38,70);
+ACE_EXPLOSION_REFLECTION(38,80);
+ACE_EXPLOSION_REFLECTION(38,90);
+ACE_EXPLOSION_REFLECTION(38,100);
+ACE_EXPLOSION_REFLECTION(38,110);
+ACE_EXPLOSION_REFLECTION(38,120);
+ACE_EXPLOSION_REFLECTION(38,130);
+ACE_EXPLOSION_REFLECTION(38,140);
+ACE_EXPLOSION_REFLECTION(38,150);
+ACE_EXPLOSION_REFLECTION(38,160);
+ACE_EXPLOSION_REFLECTION(38,170);
+ACE_EXPLOSION_REFLECTION(38,180);
+ACE_EXPLOSION_REFLECTION(38,190);
+ACE_EXPLOSION_REFLECTION(38,200);
+ACE_EXPLOSION_REFLECTION(38,210);
+ACE_EXPLOSION_REFLECTION(38,220);
+ACE_EXPLOSION_REFLECTION(38,230);
+ACE_EXPLOSION_REFLECTION(38,240);
+ACE_EXPLOSION_REFLECTION(38,250);
+ACE_EXPLOSION_REFLECTION(38,260);
+ACE_EXPLOSION_REFLECTION(38,270);
+ACE_EXPLOSION_REFLECTION(38,280);
+ACE_EXPLOSION_REFLECTION(38,290);
+ACE_EXPLOSION_REFLECTION(38,300);
+ACE_EXPLOSION_REFLECTION(38,310);
+ACE_EXPLOSION_REFLECTION(38,320);
+ACE_EXPLOSION_REFLECTION(38,330);
+ACE_EXPLOSION_REFLECTION(38,340);
+ACE_EXPLOSION_REFLECTION(38,350);
+ACE_EXPLOSION_REFLECTION(38,360);
+ACE_EXPLOSION_REFLECTION(38,370);
+ACE_EXPLOSION_REFLECTION(38,380);
+ACE_EXPLOSION_REFLECTION(38,390);
+ACE_EXPLOSION_REFLECTION(38,400);
+ACE_EXPLOSION_REFLECTION(38,410);
+ACE_EXPLOSION_REFLECTION(38,420);
+ACE_EXPLOSION_REFLECTION(38,430);
+ACE_EXPLOSION_REFLECTION(38,440);
+ACE_EXPLOSION_REFLECTION(38,450);
+ACE_EXPLOSION_REFLECTION(38,460);
+ACE_EXPLOSION_REFLECTION(38,470);
+ACE_EXPLOSION_REFLECTION(38,480);
+ACE_EXPLOSION_REFLECTION(38,490);
+ACE_EXPLOSION_REFLECTION(38,500);
+ACE_EXPLOSION_REFLECTION(40,10);
+ACE_EXPLOSION_REFLECTION(40,20);
+ACE_EXPLOSION_REFLECTION(40,30);
+ACE_EXPLOSION_REFLECTION(40,40);
+ACE_EXPLOSION_REFLECTION(40,50);
+ACE_EXPLOSION_REFLECTION(40,60);
+ACE_EXPLOSION_REFLECTION(40,70);
+ACE_EXPLOSION_REFLECTION(40,80);
+ACE_EXPLOSION_REFLECTION(40,90);
+ACE_EXPLOSION_REFLECTION(40,100);
+ACE_EXPLOSION_REFLECTION(40,110);
+ACE_EXPLOSION_REFLECTION(40,120);
+ACE_EXPLOSION_REFLECTION(40,130);
+ACE_EXPLOSION_REFLECTION(40,140);
+ACE_EXPLOSION_REFLECTION(40,150);
+ACE_EXPLOSION_REFLECTION(40,160);
+ACE_EXPLOSION_REFLECTION(40,170);
+ACE_EXPLOSION_REFLECTION(40,180);
+ACE_EXPLOSION_REFLECTION(40,190);
+ACE_EXPLOSION_REFLECTION(40,200);
+ACE_EXPLOSION_REFLECTION(40,210);
+ACE_EXPLOSION_REFLECTION(40,220);
+ACE_EXPLOSION_REFLECTION(40,230);
+ACE_EXPLOSION_REFLECTION(40,240);
+ACE_EXPLOSION_REFLECTION(40,250);
+ACE_EXPLOSION_REFLECTION(40,260);
+ACE_EXPLOSION_REFLECTION(40,270);
+ACE_EXPLOSION_REFLECTION(40,280);
+ACE_EXPLOSION_REFLECTION(40,290);
+ACE_EXPLOSION_REFLECTION(40,300);
+ACE_EXPLOSION_REFLECTION(40,310);
+ACE_EXPLOSION_REFLECTION(40,320);
+ACE_EXPLOSION_REFLECTION(40,330);
+ACE_EXPLOSION_REFLECTION(40,340);
+ACE_EXPLOSION_REFLECTION(40,350);
+ACE_EXPLOSION_REFLECTION(40,360);
+ACE_EXPLOSION_REFLECTION(40,370);
+ACE_EXPLOSION_REFLECTION(40,380);
+ACE_EXPLOSION_REFLECTION(40,390);
+ACE_EXPLOSION_REFLECTION(40,400);
+ACE_EXPLOSION_REFLECTION(40,410);
+ACE_EXPLOSION_REFLECTION(40,420);
+ACE_EXPLOSION_REFLECTION(40,430);
+ACE_EXPLOSION_REFLECTION(40,440);
+ACE_EXPLOSION_REFLECTION(40,450);
+ACE_EXPLOSION_REFLECTION(40,460);
+ACE_EXPLOSION_REFLECTION(40,470);
+ACE_EXPLOSION_REFLECTION(40,480);
+ACE_EXPLOSION_REFLECTION(40,490);
+ACE_EXPLOSION_REFLECTION(40,500);
+ACE_EXPLOSION_REFLECTION(42,10);
+ACE_EXPLOSION_REFLECTION(42,20);
+ACE_EXPLOSION_REFLECTION(42,30);
+ACE_EXPLOSION_REFLECTION(42,40);
+ACE_EXPLOSION_REFLECTION(42,50);
+ACE_EXPLOSION_REFLECTION(42,60);
+ACE_EXPLOSION_REFLECTION(42,70);
+ACE_EXPLOSION_REFLECTION(42,80);
+ACE_EXPLOSION_REFLECTION(42,90);
+ACE_EXPLOSION_REFLECTION(42,100);
+ACE_EXPLOSION_REFLECTION(42,110);
+ACE_EXPLOSION_REFLECTION(42,120);
+ACE_EXPLOSION_REFLECTION(42,130);
+ACE_EXPLOSION_REFLECTION(42,140);
+ACE_EXPLOSION_REFLECTION(42,150);
+ACE_EXPLOSION_REFLECTION(42,160);
+ACE_EXPLOSION_REFLECTION(42,170);
+ACE_EXPLOSION_REFLECTION(42,180);
+ACE_EXPLOSION_REFLECTION(42,190);
+ACE_EXPLOSION_REFLECTION(42,200);
+ACE_EXPLOSION_REFLECTION(42,210);
+ACE_EXPLOSION_REFLECTION(42,220);
+ACE_EXPLOSION_REFLECTION(42,230);
+ACE_EXPLOSION_REFLECTION(42,240);
+ACE_EXPLOSION_REFLECTION(42,250);
+ACE_EXPLOSION_REFLECTION(42,260);
+ACE_EXPLOSION_REFLECTION(42,270);
+ACE_EXPLOSION_REFLECTION(42,280);
+ACE_EXPLOSION_REFLECTION(42,290);
+ACE_EXPLOSION_REFLECTION(42,300);
+ACE_EXPLOSION_REFLECTION(42,310);
+ACE_EXPLOSION_REFLECTION(42,320);
+ACE_EXPLOSION_REFLECTION(42,330);
+ACE_EXPLOSION_REFLECTION(42,340);
+ACE_EXPLOSION_REFLECTION(42,350);
+ACE_EXPLOSION_REFLECTION(42,360);
+ACE_EXPLOSION_REFLECTION(42,370);
+ACE_EXPLOSION_REFLECTION(42,380);
+ACE_EXPLOSION_REFLECTION(42,390);
+ACE_EXPLOSION_REFLECTION(42,400);
+ACE_EXPLOSION_REFLECTION(42,410);
+ACE_EXPLOSION_REFLECTION(42,420);
+ACE_EXPLOSION_REFLECTION(42,430);
+ACE_EXPLOSION_REFLECTION(42,440);
+ACE_EXPLOSION_REFLECTION(42,450);
+ACE_EXPLOSION_REFLECTION(42,460);
+ACE_EXPLOSION_REFLECTION(42,470);
+ACE_EXPLOSION_REFLECTION(42,480);
+ACE_EXPLOSION_REFLECTION(42,490);
+ACE_EXPLOSION_REFLECTION(42,500);
+ACE_EXPLOSION_REFLECTION(44,10);
+ACE_EXPLOSION_REFLECTION(44,20);
+ACE_EXPLOSION_REFLECTION(44,30);
+ACE_EXPLOSION_REFLECTION(44,40);
+ACE_EXPLOSION_REFLECTION(44,50);
+ACE_EXPLOSION_REFLECTION(44,60);
+ACE_EXPLOSION_REFLECTION(44,70);
+ACE_EXPLOSION_REFLECTION(44,80);
+ACE_EXPLOSION_REFLECTION(44,90);
+ACE_EXPLOSION_REFLECTION(44,100);
+ACE_EXPLOSION_REFLECTION(44,110);
+ACE_EXPLOSION_REFLECTION(44,120);
+ACE_EXPLOSION_REFLECTION(44,130);
+ACE_EXPLOSION_REFLECTION(44,140);
+ACE_EXPLOSION_REFLECTION(44,150);
+ACE_EXPLOSION_REFLECTION(44,160);
+ACE_EXPLOSION_REFLECTION(44,170);
+ACE_EXPLOSION_REFLECTION(44,180);
+ACE_EXPLOSION_REFLECTION(44,190);
+ACE_EXPLOSION_REFLECTION(44,200);
+ACE_EXPLOSION_REFLECTION(44,210);
+ACE_EXPLOSION_REFLECTION(44,220);
+ACE_EXPLOSION_REFLECTION(44,230);
+ACE_EXPLOSION_REFLECTION(44,240);
+ACE_EXPLOSION_REFLECTION(44,250);
+ACE_EXPLOSION_REFLECTION(44,260);
+ACE_EXPLOSION_REFLECTION(44,270);
+ACE_EXPLOSION_REFLECTION(44,280);
+ACE_EXPLOSION_REFLECTION(44,290);
+ACE_EXPLOSION_REFLECTION(44,300);
+ACE_EXPLOSION_REFLECTION(44,310);
+ACE_EXPLOSION_REFLECTION(44,320);
+ACE_EXPLOSION_REFLECTION(44,330);
+ACE_EXPLOSION_REFLECTION(44,340);
+ACE_EXPLOSION_REFLECTION(44,350);
+ACE_EXPLOSION_REFLECTION(44,360);
+ACE_EXPLOSION_REFLECTION(44,370);
+ACE_EXPLOSION_REFLECTION(44,380);
+ACE_EXPLOSION_REFLECTION(44,390);
+ACE_EXPLOSION_REFLECTION(44,400);
+ACE_EXPLOSION_REFLECTION(44,410);
+ACE_EXPLOSION_REFLECTION(44,420);
+ACE_EXPLOSION_REFLECTION(44,430);
+ACE_EXPLOSION_REFLECTION(44,440);
+ACE_EXPLOSION_REFLECTION(44,450);
+ACE_EXPLOSION_REFLECTION(44,460);
+ACE_EXPLOSION_REFLECTION(44,470);
+ACE_EXPLOSION_REFLECTION(44,480);
+ACE_EXPLOSION_REFLECTION(44,490);
+ACE_EXPLOSION_REFLECTION(44,500);
+ACE_EXPLOSION_REFLECTION(46,10);
+ACE_EXPLOSION_REFLECTION(46,20);
+ACE_EXPLOSION_REFLECTION(46,30);
+ACE_EXPLOSION_REFLECTION(46,40);
+ACE_EXPLOSION_REFLECTION(46,50);
+ACE_EXPLOSION_REFLECTION(46,60);
+ACE_EXPLOSION_REFLECTION(46,70);
+ACE_EXPLOSION_REFLECTION(46,80);
+ACE_EXPLOSION_REFLECTION(46,90);
+ACE_EXPLOSION_REFLECTION(46,100);
+ACE_EXPLOSION_REFLECTION(46,110);
+ACE_EXPLOSION_REFLECTION(46,120);
+ACE_EXPLOSION_REFLECTION(46,130);
+ACE_EXPLOSION_REFLECTION(46,140);
+ACE_EXPLOSION_REFLECTION(46,150);
+ACE_EXPLOSION_REFLECTION(46,160);
+ACE_EXPLOSION_REFLECTION(46,170);
+ACE_EXPLOSION_REFLECTION(46,180);
+ACE_EXPLOSION_REFLECTION(46,190);
+ACE_EXPLOSION_REFLECTION(46,200);
+ACE_EXPLOSION_REFLECTION(46,210);
+ACE_EXPLOSION_REFLECTION(46,220);
+ACE_EXPLOSION_REFLECTION(46,230);
+ACE_EXPLOSION_REFLECTION(46,240);
+ACE_EXPLOSION_REFLECTION(46,250);
+ACE_EXPLOSION_REFLECTION(46,260);
+ACE_EXPLOSION_REFLECTION(46,270);
+ACE_EXPLOSION_REFLECTION(46,280);
+ACE_EXPLOSION_REFLECTION(46,290);
+ACE_EXPLOSION_REFLECTION(46,300);
+ACE_EXPLOSION_REFLECTION(46,310);
+ACE_EXPLOSION_REFLECTION(46,320);
+ACE_EXPLOSION_REFLECTION(46,330);
+ACE_EXPLOSION_REFLECTION(46,340);
+ACE_EXPLOSION_REFLECTION(46,350);
+ACE_EXPLOSION_REFLECTION(46,360);
+ACE_EXPLOSION_REFLECTION(46,370);
+ACE_EXPLOSION_REFLECTION(46,380);
+ACE_EXPLOSION_REFLECTION(46,390);
+ACE_EXPLOSION_REFLECTION(46,400);
+ACE_EXPLOSION_REFLECTION(46,410);
+ACE_EXPLOSION_REFLECTION(46,420);
+ACE_EXPLOSION_REFLECTION(46,430);
+ACE_EXPLOSION_REFLECTION(46,440);
+ACE_EXPLOSION_REFLECTION(46,450);
+ACE_EXPLOSION_REFLECTION(46,460);
+ACE_EXPLOSION_REFLECTION(46,470);
+ACE_EXPLOSION_REFLECTION(46,480);
+ACE_EXPLOSION_REFLECTION(46,490);
+ACE_EXPLOSION_REFLECTION(46,500);
+ACE_EXPLOSION_REFLECTION(48,10);
+ACE_EXPLOSION_REFLECTION(48,20);
+ACE_EXPLOSION_REFLECTION(48,30);
+ACE_EXPLOSION_REFLECTION(48,40);
+ACE_EXPLOSION_REFLECTION(48,50);
+ACE_EXPLOSION_REFLECTION(48,60);
+ACE_EXPLOSION_REFLECTION(48,70);
+ACE_EXPLOSION_REFLECTION(48,80);
+ACE_EXPLOSION_REFLECTION(48,90);
+ACE_EXPLOSION_REFLECTION(48,100);
+ACE_EXPLOSION_REFLECTION(48,110);
+ACE_EXPLOSION_REFLECTION(48,120);
+ACE_EXPLOSION_REFLECTION(48,130);
+ACE_EXPLOSION_REFLECTION(48,140);
+ACE_EXPLOSION_REFLECTION(48,150);
+ACE_EXPLOSION_REFLECTION(48,160);
+ACE_EXPLOSION_REFLECTION(48,170);
+ACE_EXPLOSION_REFLECTION(48,180);
+ACE_EXPLOSION_REFLECTION(48,190);
+ACE_EXPLOSION_REFLECTION(48,200);
+ACE_EXPLOSION_REFLECTION(48,210);
+ACE_EXPLOSION_REFLECTION(48,220);
+ACE_EXPLOSION_REFLECTION(48,230);
+ACE_EXPLOSION_REFLECTION(48,240);
+ACE_EXPLOSION_REFLECTION(48,250);
+ACE_EXPLOSION_REFLECTION(48,260);
+ACE_EXPLOSION_REFLECTION(48,270);
+ACE_EXPLOSION_REFLECTION(48,280);
+ACE_EXPLOSION_REFLECTION(48,290);
+ACE_EXPLOSION_REFLECTION(48,300);
+ACE_EXPLOSION_REFLECTION(48,310);
+ACE_EXPLOSION_REFLECTION(48,320);
+ACE_EXPLOSION_REFLECTION(48,330);
+ACE_EXPLOSION_REFLECTION(48,340);
+ACE_EXPLOSION_REFLECTION(48,350);
+ACE_EXPLOSION_REFLECTION(48,360);
+ACE_EXPLOSION_REFLECTION(48,370);
+ACE_EXPLOSION_REFLECTION(48,380);
+ACE_EXPLOSION_REFLECTION(48,390);
+ACE_EXPLOSION_REFLECTION(48,400);
+ACE_EXPLOSION_REFLECTION(48,410);
+ACE_EXPLOSION_REFLECTION(48,420);
+ACE_EXPLOSION_REFLECTION(48,430);
+ACE_EXPLOSION_REFLECTION(48,440);
+ACE_EXPLOSION_REFLECTION(48,450);
+ACE_EXPLOSION_REFLECTION(48,460);
+ACE_EXPLOSION_REFLECTION(48,470);
+ACE_EXPLOSION_REFLECTION(48,480);
+ACE_EXPLOSION_REFLECTION(48,490);
+ACE_EXPLOSION_REFLECTION(48,500);
+ACE_EXPLOSION_REFLECTION(50,10);
+ACE_EXPLOSION_REFLECTION(50,20);
+ACE_EXPLOSION_REFLECTION(50,30);
+ACE_EXPLOSION_REFLECTION(50,40);
+ACE_EXPLOSION_REFLECTION(50,50);
+ACE_EXPLOSION_REFLECTION(50,60);
+ACE_EXPLOSION_REFLECTION(50,70);
+ACE_EXPLOSION_REFLECTION(50,80);
+ACE_EXPLOSION_REFLECTION(50,90);
+ACE_EXPLOSION_REFLECTION(50,100);
+ACE_EXPLOSION_REFLECTION(50,110);
+ACE_EXPLOSION_REFLECTION(50,120);
+ACE_EXPLOSION_REFLECTION(50,130);
+ACE_EXPLOSION_REFLECTION(50,140);
+ACE_EXPLOSION_REFLECTION(50,150);
+ACE_EXPLOSION_REFLECTION(50,160);
+ACE_EXPLOSION_REFLECTION(50,170);
+ACE_EXPLOSION_REFLECTION(50,180);
+ACE_EXPLOSION_REFLECTION(50,190);
+ACE_EXPLOSION_REFLECTION(50,200);
+ACE_EXPLOSION_REFLECTION(50,210);
+ACE_EXPLOSION_REFLECTION(50,220);
+ACE_EXPLOSION_REFLECTION(50,230);
+ACE_EXPLOSION_REFLECTION(50,240);
+ACE_EXPLOSION_REFLECTION(50,250);
+ACE_EXPLOSION_REFLECTION(50,260);
+ACE_EXPLOSION_REFLECTION(50,270);
+ACE_EXPLOSION_REFLECTION(50,280);
+ACE_EXPLOSION_REFLECTION(50,290);
+ACE_EXPLOSION_REFLECTION(50,300);
+ACE_EXPLOSION_REFLECTION(50,310);
+ACE_EXPLOSION_REFLECTION(50,320);
+ACE_EXPLOSION_REFLECTION(50,330);
+ACE_EXPLOSION_REFLECTION(50,340);
+ACE_EXPLOSION_REFLECTION(50,350);
+ACE_EXPLOSION_REFLECTION(50,360);
+ACE_EXPLOSION_REFLECTION(50,370);
+ACE_EXPLOSION_REFLECTION(50,380);
+ACE_EXPLOSION_REFLECTION(50,390);
+ACE_EXPLOSION_REFLECTION(50,400);
+ACE_EXPLOSION_REFLECTION(50,410);
+ACE_EXPLOSION_REFLECTION(50,420);
+ACE_EXPLOSION_REFLECTION(50,430);
+ACE_EXPLOSION_REFLECTION(50,440);
+ACE_EXPLOSION_REFLECTION(50,450);
+ACE_EXPLOSION_REFLECTION(50,460);
+ACE_EXPLOSION_REFLECTION(50,470);
+ACE_EXPLOSION_REFLECTION(50,480);
+ACE_EXPLOSION_REFLECTION(50,490);
+ACE_EXPLOSION_REFLECTION(50,500);
+ACE_EXPLOSION_REFLECTION(52,10);
+ACE_EXPLOSION_REFLECTION(52,20);
+ACE_EXPLOSION_REFLECTION(52,30);
+ACE_EXPLOSION_REFLECTION(52,40);
+ACE_EXPLOSION_REFLECTION(52,50);
+ACE_EXPLOSION_REFLECTION(52,60);
+ACE_EXPLOSION_REFLECTION(52,70);
+ACE_EXPLOSION_REFLECTION(52,80);
+ACE_EXPLOSION_REFLECTION(52,90);
+ACE_EXPLOSION_REFLECTION(52,100);
+ACE_EXPLOSION_REFLECTION(52,110);
+ACE_EXPLOSION_REFLECTION(52,120);
+ACE_EXPLOSION_REFLECTION(52,130);
+ACE_EXPLOSION_REFLECTION(52,140);
+ACE_EXPLOSION_REFLECTION(52,150);
+ACE_EXPLOSION_REFLECTION(52,160);
+ACE_EXPLOSION_REFLECTION(52,170);
+ACE_EXPLOSION_REFLECTION(52,180);
+ACE_EXPLOSION_REFLECTION(52,190);
+ACE_EXPLOSION_REFLECTION(52,200);
+ACE_EXPLOSION_REFLECTION(52,210);
+ACE_EXPLOSION_REFLECTION(52,220);
+ACE_EXPLOSION_REFLECTION(52,230);
+ACE_EXPLOSION_REFLECTION(52,240);
+ACE_EXPLOSION_REFLECTION(52,250);
+ACE_EXPLOSION_REFLECTION(52,260);
+ACE_EXPLOSION_REFLECTION(52,270);
+ACE_EXPLOSION_REFLECTION(52,280);
+ACE_EXPLOSION_REFLECTION(52,290);
+ACE_EXPLOSION_REFLECTION(52,300);
+ACE_EXPLOSION_REFLECTION(52,310);
+ACE_EXPLOSION_REFLECTION(52,320);
+ACE_EXPLOSION_REFLECTION(52,330);
+ACE_EXPLOSION_REFLECTION(52,340);
+ACE_EXPLOSION_REFLECTION(52,350);
+ACE_EXPLOSION_REFLECTION(52,360);
+ACE_EXPLOSION_REFLECTION(52,370);
+ACE_EXPLOSION_REFLECTION(52,380);
+ACE_EXPLOSION_REFLECTION(52,390);
+ACE_EXPLOSION_REFLECTION(52,400);
+ACE_EXPLOSION_REFLECTION(52,410);
+ACE_EXPLOSION_REFLECTION(52,420);
+ACE_EXPLOSION_REFLECTION(52,430);
+ACE_EXPLOSION_REFLECTION(52,440);
+ACE_EXPLOSION_REFLECTION(52,450);
+ACE_EXPLOSION_REFLECTION(52,460);
+ACE_EXPLOSION_REFLECTION(52,470);
+ACE_EXPLOSION_REFLECTION(52,480);
+ACE_EXPLOSION_REFLECTION(52,490);
+ACE_EXPLOSION_REFLECTION(52,500);
+ACE_EXPLOSION_REFLECTION(54,10);
+ACE_EXPLOSION_REFLECTION(54,20);
+ACE_EXPLOSION_REFLECTION(54,30);
+ACE_EXPLOSION_REFLECTION(54,40);
+ACE_EXPLOSION_REFLECTION(54,50);
+ACE_EXPLOSION_REFLECTION(54,60);
+ACE_EXPLOSION_REFLECTION(54,70);
+ACE_EXPLOSION_REFLECTION(54,80);
+ACE_EXPLOSION_REFLECTION(54,90);
+ACE_EXPLOSION_REFLECTION(54,100);
+ACE_EXPLOSION_REFLECTION(54,110);
+ACE_EXPLOSION_REFLECTION(54,120);
+ACE_EXPLOSION_REFLECTION(54,130);
+ACE_EXPLOSION_REFLECTION(54,140);
+ACE_EXPLOSION_REFLECTION(54,150);
+ACE_EXPLOSION_REFLECTION(54,160);
+ACE_EXPLOSION_REFLECTION(54,170);
+ACE_EXPLOSION_REFLECTION(54,180);
+ACE_EXPLOSION_REFLECTION(54,190);
+ACE_EXPLOSION_REFLECTION(54,200);
+ACE_EXPLOSION_REFLECTION(54,210);
+ACE_EXPLOSION_REFLECTION(54,220);
+ACE_EXPLOSION_REFLECTION(54,230);
+ACE_EXPLOSION_REFLECTION(54,240);
+ACE_EXPLOSION_REFLECTION(54,250);
+ACE_EXPLOSION_REFLECTION(54,260);
+ACE_EXPLOSION_REFLECTION(54,270);
+ACE_EXPLOSION_REFLECTION(54,280);
+ACE_EXPLOSION_REFLECTION(54,290);
+ACE_EXPLOSION_REFLECTION(54,300);
+ACE_EXPLOSION_REFLECTION(54,310);
+ACE_EXPLOSION_REFLECTION(54,320);
+ACE_EXPLOSION_REFLECTION(54,330);
+ACE_EXPLOSION_REFLECTION(54,340);
+ACE_EXPLOSION_REFLECTION(54,350);
+ACE_EXPLOSION_REFLECTION(54,360);
+ACE_EXPLOSION_REFLECTION(54,370);
+ACE_EXPLOSION_REFLECTION(54,380);
+ACE_EXPLOSION_REFLECTION(54,390);
+ACE_EXPLOSION_REFLECTION(54,400);
+ACE_EXPLOSION_REFLECTION(54,410);
+ACE_EXPLOSION_REFLECTION(54,420);
+ACE_EXPLOSION_REFLECTION(54,430);
+ACE_EXPLOSION_REFLECTION(54,440);
+ACE_EXPLOSION_REFLECTION(54,450);
+ACE_EXPLOSION_REFLECTION(54,460);
+ACE_EXPLOSION_REFLECTION(54,470);
+ACE_EXPLOSION_REFLECTION(54,480);
+ACE_EXPLOSION_REFLECTION(54,490);
+ACE_EXPLOSION_REFLECTION(54,500);
+ACE_EXPLOSION_REFLECTION(56,10);
+ACE_EXPLOSION_REFLECTION(56,20);
+ACE_EXPLOSION_REFLECTION(56,30);
+ACE_EXPLOSION_REFLECTION(56,40);
+ACE_EXPLOSION_REFLECTION(56,50);
+ACE_EXPLOSION_REFLECTION(56,60);
+ACE_EXPLOSION_REFLECTION(56,70);
+ACE_EXPLOSION_REFLECTION(56,80);
+ACE_EXPLOSION_REFLECTION(56,90);
+ACE_EXPLOSION_REFLECTION(56,100);
+ACE_EXPLOSION_REFLECTION(56,110);
+ACE_EXPLOSION_REFLECTION(56,120);
+ACE_EXPLOSION_REFLECTION(56,130);
+ACE_EXPLOSION_REFLECTION(56,140);
+ACE_EXPLOSION_REFLECTION(56,150);
+ACE_EXPLOSION_REFLECTION(56,160);
+ACE_EXPLOSION_REFLECTION(56,170);
+ACE_EXPLOSION_REFLECTION(56,180);
+ACE_EXPLOSION_REFLECTION(56,190);
+ACE_EXPLOSION_REFLECTION(56,200);
+ACE_EXPLOSION_REFLECTION(56,210);
+ACE_EXPLOSION_REFLECTION(56,220);
+ACE_EXPLOSION_REFLECTION(56,230);
+ACE_EXPLOSION_REFLECTION(56,240);
+ACE_EXPLOSION_REFLECTION(56,250);
+ACE_EXPLOSION_REFLECTION(56,260);
+ACE_EXPLOSION_REFLECTION(56,270);
+ACE_EXPLOSION_REFLECTION(56,280);
+ACE_EXPLOSION_REFLECTION(56,290);
+ACE_EXPLOSION_REFLECTION(56,300);
+ACE_EXPLOSION_REFLECTION(56,310);
+ACE_EXPLOSION_REFLECTION(56,320);
+ACE_EXPLOSION_REFLECTION(56,330);
+ACE_EXPLOSION_REFLECTION(56,340);
+ACE_EXPLOSION_REFLECTION(56,350);
+ACE_EXPLOSION_REFLECTION(56,360);
+ACE_EXPLOSION_REFLECTION(56,370);
+ACE_EXPLOSION_REFLECTION(56,380);
+ACE_EXPLOSION_REFLECTION(56,390);
+ACE_EXPLOSION_REFLECTION(56,400);
+ACE_EXPLOSION_REFLECTION(56,410);
+ACE_EXPLOSION_REFLECTION(56,420);
+ACE_EXPLOSION_REFLECTION(56,430);
+ACE_EXPLOSION_REFLECTION(56,440);
+ACE_EXPLOSION_REFLECTION(56,450);
+ACE_EXPLOSION_REFLECTION(56,460);
+ACE_EXPLOSION_REFLECTION(56,470);
+ACE_EXPLOSION_REFLECTION(56,480);
+ACE_EXPLOSION_REFLECTION(56,490);
+ACE_EXPLOSION_REFLECTION(56,500);
+ACE_EXPLOSION_REFLECTION(58,10);
+ACE_EXPLOSION_REFLECTION(58,20);
+ACE_EXPLOSION_REFLECTION(58,30);
+ACE_EXPLOSION_REFLECTION(58,40);
+ACE_EXPLOSION_REFLECTION(58,50);
+ACE_EXPLOSION_REFLECTION(58,60);
+ACE_EXPLOSION_REFLECTION(58,70);
+ACE_EXPLOSION_REFLECTION(58,80);
+ACE_EXPLOSION_REFLECTION(58,90);
+ACE_EXPLOSION_REFLECTION(58,100);
+ACE_EXPLOSION_REFLECTION(58,110);
+ACE_EXPLOSION_REFLECTION(58,120);
+ACE_EXPLOSION_REFLECTION(58,130);
+ACE_EXPLOSION_REFLECTION(58,140);
+ACE_EXPLOSION_REFLECTION(58,150);
+ACE_EXPLOSION_REFLECTION(58,160);
+ACE_EXPLOSION_REFLECTION(58,170);
+ACE_EXPLOSION_REFLECTION(58,180);
+ACE_EXPLOSION_REFLECTION(58,190);
+ACE_EXPLOSION_REFLECTION(58,200);
+ACE_EXPLOSION_REFLECTION(58,210);
+ACE_EXPLOSION_REFLECTION(58,220);
+ACE_EXPLOSION_REFLECTION(58,230);
+ACE_EXPLOSION_REFLECTION(58,240);
+ACE_EXPLOSION_REFLECTION(58,250);
+ACE_EXPLOSION_REFLECTION(58,260);
+ACE_EXPLOSION_REFLECTION(58,270);
+ACE_EXPLOSION_REFLECTION(58,280);
+ACE_EXPLOSION_REFLECTION(58,290);
+ACE_EXPLOSION_REFLECTION(58,300);
+ACE_EXPLOSION_REFLECTION(58,310);
+ACE_EXPLOSION_REFLECTION(58,320);
+ACE_EXPLOSION_REFLECTION(58,330);
+ACE_EXPLOSION_REFLECTION(58,340);
+ACE_EXPLOSION_REFLECTION(58,350);
+ACE_EXPLOSION_REFLECTION(58,360);
+ACE_EXPLOSION_REFLECTION(58,370);
+ACE_EXPLOSION_REFLECTION(58,380);
+ACE_EXPLOSION_REFLECTION(58,390);
+ACE_EXPLOSION_REFLECTION(58,400);
+ACE_EXPLOSION_REFLECTION(58,410);
+ACE_EXPLOSION_REFLECTION(58,420);
+ACE_EXPLOSION_REFLECTION(58,430);
+ACE_EXPLOSION_REFLECTION(58,440);
+ACE_EXPLOSION_REFLECTION(58,450);
+ACE_EXPLOSION_REFLECTION(58,460);
+ACE_EXPLOSION_REFLECTION(58,470);
+ACE_EXPLOSION_REFLECTION(58,480);
+ACE_EXPLOSION_REFLECTION(58,490);
+ACE_EXPLOSION_REFLECTION(58,500);
+ACE_EXPLOSION_REFLECTION(60,10);
+ACE_EXPLOSION_REFLECTION(60,20);
+ACE_EXPLOSION_REFLECTION(60,30);
+ACE_EXPLOSION_REFLECTION(60,40);
+ACE_EXPLOSION_REFLECTION(60,50);
+ACE_EXPLOSION_REFLECTION(60,60);
+ACE_EXPLOSION_REFLECTION(60,70);
+ACE_EXPLOSION_REFLECTION(60,80);
+ACE_EXPLOSION_REFLECTION(60,90);
+ACE_EXPLOSION_REFLECTION(60,100);
+ACE_EXPLOSION_REFLECTION(60,110);
+ACE_EXPLOSION_REFLECTION(60,120);
+ACE_EXPLOSION_REFLECTION(60,130);
+ACE_EXPLOSION_REFLECTION(60,140);
+ACE_EXPLOSION_REFLECTION(60,150);
+ACE_EXPLOSION_REFLECTION(60,160);
+ACE_EXPLOSION_REFLECTION(60,170);
+ACE_EXPLOSION_REFLECTION(60,180);
+ACE_EXPLOSION_REFLECTION(60,190);
+ACE_EXPLOSION_REFLECTION(60,200);
+ACE_EXPLOSION_REFLECTION(60,210);
+ACE_EXPLOSION_REFLECTION(60,220);
+ACE_EXPLOSION_REFLECTION(60,230);
+ACE_EXPLOSION_REFLECTION(60,240);
+ACE_EXPLOSION_REFLECTION(60,250);
+ACE_EXPLOSION_REFLECTION(60,260);
+ACE_EXPLOSION_REFLECTION(60,270);
+ACE_EXPLOSION_REFLECTION(60,280);
+ACE_EXPLOSION_REFLECTION(60,290);
+ACE_EXPLOSION_REFLECTION(60,300);
+ACE_EXPLOSION_REFLECTION(60,310);
+ACE_EXPLOSION_REFLECTION(60,320);
+ACE_EXPLOSION_REFLECTION(60,330);
+ACE_EXPLOSION_REFLECTION(60,340);
+ACE_EXPLOSION_REFLECTION(60,350);
+ACE_EXPLOSION_REFLECTION(60,360);
+ACE_EXPLOSION_REFLECTION(60,370);
+ACE_EXPLOSION_REFLECTION(60,380);
+ACE_EXPLOSION_REFLECTION(60,390);
+ACE_EXPLOSION_REFLECTION(60,400);
+ACE_EXPLOSION_REFLECTION(60,410);
+ACE_EXPLOSION_REFLECTION(60,420);
+ACE_EXPLOSION_REFLECTION(60,430);
+ACE_EXPLOSION_REFLECTION(60,440);
+ACE_EXPLOSION_REFLECTION(60,450);
+ACE_EXPLOSION_REFLECTION(60,460);
+ACE_EXPLOSION_REFLECTION(60,470);
+ACE_EXPLOSION_REFLECTION(60,480);
+ACE_EXPLOSION_REFLECTION(60,490);
+ACE_EXPLOSION_REFLECTION(60,500);
+ACE_EXPLOSION_REFLECTION(62,10);
+ACE_EXPLOSION_REFLECTION(62,20);
+ACE_EXPLOSION_REFLECTION(62,30);
+ACE_EXPLOSION_REFLECTION(62,40);
+ACE_EXPLOSION_REFLECTION(62,50);
+ACE_EXPLOSION_REFLECTION(62,60);
+ACE_EXPLOSION_REFLECTION(62,70);
+ACE_EXPLOSION_REFLECTION(62,80);
+ACE_EXPLOSION_REFLECTION(62,90);
+ACE_EXPLOSION_REFLECTION(62,100);
+ACE_EXPLOSION_REFLECTION(62,110);
+ACE_EXPLOSION_REFLECTION(62,120);
+ACE_EXPLOSION_REFLECTION(62,130);
+ACE_EXPLOSION_REFLECTION(62,140);
+ACE_EXPLOSION_REFLECTION(62,150);
+ACE_EXPLOSION_REFLECTION(62,160);
+ACE_EXPLOSION_REFLECTION(62,170);
+ACE_EXPLOSION_REFLECTION(62,180);
+ACE_EXPLOSION_REFLECTION(62,190);
+ACE_EXPLOSION_REFLECTION(62,200);
+ACE_EXPLOSION_REFLECTION(62,210);
+ACE_EXPLOSION_REFLECTION(62,220);
+ACE_EXPLOSION_REFLECTION(62,230);
+ACE_EXPLOSION_REFLECTION(62,240);
+ACE_EXPLOSION_REFLECTION(62,250);
+ACE_EXPLOSION_REFLECTION(62,260);
+ACE_EXPLOSION_REFLECTION(62,270);
+ACE_EXPLOSION_REFLECTION(62,280);
+ACE_EXPLOSION_REFLECTION(62,290);
+ACE_EXPLOSION_REFLECTION(62,300);
+ACE_EXPLOSION_REFLECTION(62,310);
+ACE_EXPLOSION_REFLECTION(62,320);
+ACE_EXPLOSION_REFLECTION(62,330);
+ACE_EXPLOSION_REFLECTION(62,340);
+ACE_EXPLOSION_REFLECTION(62,350);
+ACE_EXPLOSION_REFLECTION(62,360);
+ACE_EXPLOSION_REFLECTION(62,370);
+ACE_EXPLOSION_REFLECTION(62,380);
+ACE_EXPLOSION_REFLECTION(62,390);
+ACE_EXPLOSION_REFLECTION(62,400);
+ACE_EXPLOSION_REFLECTION(62,410);
+ACE_EXPLOSION_REFLECTION(62,420);
+ACE_EXPLOSION_REFLECTION(62,430);
+ACE_EXPLOSION_REFLECTION(62,440);
+ACE_EXPLOSION_REFLECTION(62,450);
+ACE_EXPLOSION_REFLECTION(62,460);
+ACE_EXPLOSION_REFLECTION(62,470);
+ACE_EXPLOSION_REFLECTION(62,480);
+ACE_EXPLOSION_REFLECTION(62,490);
+ACE_EXPLOSION_REFLECTION(62,500);
+ACE_EXPLOSION_REFLECTION(64,10);
+ACE_EXPLOSION_REFLECTION(64,20);
+ACE_EXPLOSION_REFLECTION(64,30);
+ACE_EXPLOSION_REFLECTION(64,40);
+ACE_EXPLOSION_REFLECTION(64,50);
+ACE_EXPLOSION_REFLECTION(64,60);
+ACE_EXPLOSION_REFLECTION(64,70);
+ACE_EXPLOSION_REFLECTION(64,80);
+ACE_EXPLOSION_REFLECTION(64,90);
+ACE_EXPLOSION_REFLECTION(64,100);
+ACE_EXPLOSION_REFLECTION(64,110);
+ACE_EXPLOSION_REFLECTION(64,120);
+ACE_EXPLOSION_REFLECTION(64,130);
+ACE_EXPLOSION_REFLECTION(64,140);
+ACE_EXPLOSION_REFLECTION(64,150);
+ACE_EXPLOSION_REFLECTION(64,160);
+ACE_EXPLOSION_REFLECTION(64,170);
+ACE_EXPLOSION_REFLECTION(64,180);
+ACE_EXPLOSION_REFLECTION(64,190);
+ACE_EXPLOSION_REFLECTION(64,200);
+ACE_EXPLOSION_REFLECTION(64,210);
+ACE_EXPLOSION_REFLECTION(64,220);
+ACE_EXPLOSION_REFLECTION(64,230);
+ACE_EXPLOSION_REFLECTION(64,240);
+ACE_EXPLOSION_REFLECTION(64,250);
+ACE_EXPLOSION_REFLECTION(64,260);
+ACE_EXPLOSION_REFLECTION(64,270);
+ACE_EXPLOSION_REFLECTION(64,280);
+ACE_EXPLOSION_REFLECTION(64,290);
+ACE_EXPLOSION_REFLECTION(64,300);
+ACE_EXPLOSION_REFLECTION(64,310);
+ACE_EXPLOSION_REFLECTION(64,320);
+ACE_EXPLOSION_REFLECTION(64,330);
+ACE_EXPLOSION_REFLECTION(64,340);
+ACE_EXPLOSION_REFLECTION(64,350);
+ACE_EXPLOSION_REFLECTION(64,360);
+ACE_EXPLOSION_REFLECTION(64,370);
+ACE_EXPLOSION_REFLECTION(64,380);
+ACE_EXPLOSION_REFLECTION(64,390);
+ACE_EXPLOSION_REFLECTION(64,400);
+ACE_EXPLOSION_REFLECTION(64,410);
+ACE_EXPLOSION_REFLECTION(64,420);
+ACE_EXPLOSION_REFLECTION(64,430);
+ACE_EXPLOSION_REFLECTION(64,440);
+ACE_EXPLOSION_REFLECTION(64,450);
+ACE_EXPLOSION_REFLECTION(64,460);
+ACE_EXPLOSION_REFLECTION(64,470);
+ACE_EXPLOSION_REFLECTION(64,480);
+ACE_EXPLOSION_REFLECTION(64,490);
+ACE_EXPLOSION_REFLECTION(64,500);
+ACE_EXPLOSION_REFLECTION(66,10);
+ACE_EXPLOSION_REFLECTION(66,20);
+ACE_EXPLOSION_REFLECTION(66,30);
+ACE_EXPLOSION_REFLECTION(66,40);
+ACE_EXPLOSION_REFLECTION(66,50);
+ACE_EXPLOSION_REFLECTION(66,60);
+ACE_EXPLOSION_REFLECTION(66,70);
+ACE_EXPLOSION_REFLECTION(66,80);
+ACE_EXPLOSION_REFLECTION(66,90);
+ACE_EXPLOSION_REFLECTION(66,100);
+ACE_EXPLOSION_REFLECTION(66,110);
+ACE_EXPLOSION_REFLECTION(66,120);
+ACE_EXPLOSION_REFLECTION(66,130);
+ACE_EXPLOSION_REFLECTION(66,140);
+ACE_EXPLOSION_REFLECTION(66,150);
+ACE_EXPLOSION_REFLECTION(66,160);
+ACE_EXPLOSION_REFLECTION(66,170);
+ACE_EXPLOSION_REFLECTION(66,180);
+ACE_EXPLOSION_REFLECTION(66,190);
+ACE_EXPLOSION_REFLECTION(66,200);
+ACE_EXPLOSION_REFLECTION(66,210);
+ACE_EXPLOSION_REFLECTION(66,220);
+ACE_EXPLOSION_REFLECTION(66,230);
+ACE_EXPLOSION_REFLECTION(66,240);
+ACE_EXPLOSION_REFLECTION(66,250);
+ACE_EXPLOSION_REFLECTION(66,260);
+ACE_EXPLOSION_REFLECTION(66,270);
+ACE_EXPLOSION_REFLECTION(66,280);
+ACE_EXPLOSION_REFLECTION(66,290);
+ACE_EXPLOSION_REFLECTION(66,300);
+ACE_EXPLOSION_REFLECTION(66,310);
+ACE_EXPLOSION_REFLECTION(66,320);
+ACE_EXPLOSION_REFLECTION(66,330);
+ACE_EXPLOSION_REFLECTION(66,340);
+ACE_EXPLOSION_REFLECTION(66,350);
+ACE_EXPLOSION_REFLECTION(66,360);
+ACE_EXPLOSION_REFLECTION(66,370);
+ACE_EXPLOSION_REFLECTION(66,380);
+ACE_EXPLOSION_REFLECTION(66,390);
+ACE_EXPLOSION_REFLECTION(66,400);
+ACE_EXPLOSION_REFLECTION(66,410);
+ACE_EXPLOSION_REFLECTION(66,420);
+ACE_EXPLOSION_REFLECTION(66,430);
+ACE_EXPLOSION_REFLECTION(66,440);
+ACE_EXPLOSION_REFLECTION(66,450);
+ACE_EXPLOSION_REFLECTION(66,460);
+ACE_EXPLOSION_REFLECTION(66,470);
+ACE_EXPLOSION_REFLECTION(66,480);
+ACE_EXPLOSION_REFLECTION(66,490);
+ACE_EXPLOSION_REFLECTION(66,500);
+ACE_EXPLOSION_REFLECTION(68,10);
+ACE_EXPLOSION_REFLECTION(68,20);
+ACE_EXPLOSION_REFLECTION(68,30);
+ACE_EXPLOSION_REFLECTION(68,40);
+ACE_EXPLOSION_REFLECTION(68,50);
+ACE_EXPLOSION_REFLECTION(68,60);
+ACE_EXPLOSION_REFLECTION(68,70);
+ACE_EXPLOSION_REFLECTION(68,80);
+ACE_EXPLOSION_REFLECTION(68,90);
+ACE_EXPLOSION_REFLECTION(68,100);
+ACE_EXPLOSION_REFLECTION(68,110);
+ACE_EXPLOSION_REFLECTION(68,120);
+ACE_EXPLOSION_REFLECTION(68,130);
+ACE_EXPLOSION_REFLECTION(68,140);
+ACE_EXPLOSION_REFLECTION(68,150);
+ACE_EXPLOSION_REFLECTION(68,160);
+ACE_EXPLOSION_REFLECTION(68,170);
+ACE_EXPLOSION_REFLECTION(68,180);
+ACE_EXPLOSION_REFLECTION(68,190);
+ACE_EXPLOSION_REFLECTION(68,200);
+ACE_EXPLOSION_REFLECTION(68,210);
+ACE_EXPLOSION_REFLECTION(68,220);
+ACE_EXPLOSION_REFLECTION(68,230);
+ACE_EXPLOSION_REFLECTION(68,240);
+ACE_EXPLOSION_REFLECTION(68,250);
+ACE_EXPLOSION_REFLECTION(68,260);
+ACE_EXPLOSION_REFLECTION(68,270);
+ACE_EXPLOSION_REFLECTION(68,280);
+ACE_EXPLOSION_REFLECTION(68,290);
+ACE_EXPLOSION_REFLECTION(68,300);
+ACE_EXPLOSION_REFLECTION(68,310);
+ACE_EXPLOSION_REFLECTION(68,320);
+ACE_EXPLOSION_REFLECTION(68,330);
+ACE_EXPLOSION_REFLECTION(68,340);
+ACE_EXPLOSION_REFLECTION(68,350);
+ACE_EXPLOSION_REFLECTION(68,360);
+ACE_EXPLOSION_REFLECTION(68,370);
+ACE_EXPLOSION_REFLECTION(68,380);
+ACE_EXPLOSION_REFLECTION(68,390);
+ACE_EXPLOSION_REFLECTION(68,400);
+ACE_EXPLOSION_REFLECTION(68,410);
+ACE_EXPLOSION_REFLECTION(68,420);
+ACE_EXPLOSION_REFLECTION(68,430);
+ACE_EXPLOSION_REFLECTION(68,440);
+ACE_EXPLOSION_REFLECTION(68,450);
+ACE_EXPLOSION_REFLECTION(68,460);
+ACE_EXPLOSION_REFLECTION(68,470);
+ACE_EXPLOSION_REFLECTION(68,480);
+ACE_EXPLOSION_REFLECTION(68,490);
+ACE_EXPLOSION_REFLECTION(68,500);
+ACE_EXPLOSION_REFLECTION(70,10);
+ACE_EXPLOSION_REFLECTION(70,20);
+ACE_EXPLOSION_REFLECTION(70,30);
+ACE_EXPLOSION_REFLECTION(70,40);
+ACE_EXPLOSION_REFLECTION(70,50);
+ACE_EXPLOSION_REFLECTION(70,60);
+ACE_EXPLOSION_REFLECTION(70,70);
+ACE_EXPLOSION_REFLECTION(70,80);
+ACE_EXPLOSION_REFLECTION(70,90);
+ACE_EXPLOSION_REFLECTION(70,100);
+ACE_EXPLOSION_REFLECTION(70,110);
+ACE_EXPLOSION_REFLECTION(70,120);
+ACE_EXPLOSION_REFLECTION(70,130);
+ACE_EXPLOSION_REFLECTION(70,140);
+ACE_EXPLOSION_REFLECTION(70,150);
+ACE_EXPLOSION_REFLECTION(70,160);
+ACE_EXPLOSION_REFLECTION(70,170);
+ACE_EXPLOSION_REFLECTION(70,180);
+ACE_EXPLOSION_REFLECTION(70,190);
+ACE_EXPLOSION_REFLECTION(70,200);
+ACE_EXPLOSION_REFLECTION(70,210);
+ACE_EXPLOSION_REFLECTION(70,220);
+ACE_EXPLOSION_REFLECTION(70,230);
+ACE_EXPLOSION_REFLECTION(70,240);
+ACE_EXPLOSION_REFLECTION(70,250);
+ACE_EXPLOSION_REFLECTION(70,260);
+ACE_EXPLOSION_REFLECTION(70,270);
+ACE_EXPLOSION_REFLECTION(70,280);
+ACE_EXPLOSION_REFLECTION(70,290);
+ACE_EXPLOSION_REFLECTION(70,300);
+ACE_EXPLOSION_REFLECTION(70,310);
+ACE_EXPLOSION_REFLECTION(70,320);
+ACE_EXPLOSION_REFLECTION(70,330);
+ACE_EXPLOSION_REFLECTION(70,340);
+ACE_EXPLOSION_REFLECTION(70,350);
+ACE_EXPLOSION_REFLECTION(70,360);
+ACE_EXPLOSION_REFLECTION(70,370);
+ACE_EXPLOSION_REFLECTION(70,380);
+ACE_EXPLOSION_REFLECTION(70,390);
+ACE_EXPLOSION_REFLECTION(70,400);
+ACE_EXPLOSION_REFLECTION(70,410);
+ACE_EXPLOSION_REFLECTION(70,420);
+ACE_EXPLOSION_REFLECTION(70,430);
+ACE_EXPLOSION_REFLECTION(70,440);
+ACE_EXPLOSION_REFLECTION(70,450);
+ACE_EXPLOSION_REFLECTION(70,460);
+ACE_EXPLOSION_REFLECTION(70,470);
+ACE_EXPLOSION_REFLECTION(70,480);
+ACE_EXPLOSION_REFLECTION(70,490);
+ACE_EXPLOSION_REFLECTION(70,500);
+ACE_EXPLOSION_REFLECTION(72,10);
+ACE_EXPLOSION_REFLECTION(72,20);
+ACE_EXPLOSION_REFLECTION(72,30);
+ACE_EXPLOSION_REFLECTION(72,40);
+ACE_EXPLOSION_REFLECTION(72,50);
+ACE_EXPLOSION_REFLECTION(72,60);
+ACE_EXPLOSION_REFLECTION(72,70);
+ACE_EXPLOSION_REFLECTION(72,80);
+ACE_EXPLOSION_REFLECTION(72,90);
+ACE_EXPLOSION_REFLECTION(72,100);
+ACE_EXPLOSION_REFLECTION(72,110);
+ACE_EXPLOSION_REFLECTION(72,120);
+ACE_EXPLOSION_REFLECTION(72,130);
+ACE_EXPLOSION_REFLECTION(72,140);
+ACE_EXPLOSION_REFLECTION(72,150);
+ACE_EXPLOSION_REFLECTION(72,160);
+ACE_EXPLOSION_REFLECTION(72,170);
+ACE_EXPLOSION_REFLECTION(72,180);
+ACE_EXPLOSION_REFLECTION(72,190);
+ACE_EXPLOSION_REFLECTION(72,200);
+ACE_EXPLOSION_REFLECTION(72,210);
+ACE_EXPLOSION_REFLECTION(72,220);
+ACE_EXPLOSION_REFLECTION(72,230);
+ACE_EXPLOSION_REFLECTION(72,240);
+ACE_EXPLOSION_REFLECTION(72,250);
+ACE_EXPLOSION_REFLECTION(72,260);
+ACE_EXPLOSION_REFLECTION(72,270);
+ACE_EXPLOSION_REFLECTION(72,280);
+ACE_EXPLOSION_REFLECTION(72,290);
+ACE_EXPLOSION_REFLECTION(72,300);
+ACE_EXPLOSION_REFLECTION(72,310);
+ACE_EXPLOSION_REFLECTION(72,320);
+ACE_EXPLOSION_REFLECTION(72,330);
+ACE_EXPLOSION_REFLECTION(72,340);
+ACE_EXPLOSION_REFLECTION(72,350);
+ACE_EXPLOSION_REFLECTION(72,360);
+ACE_EXPLOSION_REFLECTION(72,370);
+ACE_EXPLOSION_REFLECTION(72,380);
+ACE_EXPLOSION_REFLECTION(72,390);
+ACE_EXPLOSION_REFLECTION(72,400);
+ACE_EXPLOSION_REFLECTION(72,410);
+ACE_EXPLOSION_REFLECTION(72,420);
+ACE_EXPLOSION_REFLECTION(72,430);
+ACE_EXPLOSION_REFLECTION(72,440);
+ACE_EXPLOSION_REFLECTION(72,450);
+ACE_EXPLOSION_REFLECTION(72,460);
+ACE_EXPLOSION_REFLECTION(72,470);
+ACE_EXPLOSION_REFLECTION(72,480);
+ACE_EXPLOSION_REFLECTION(72,490);
+ACE_EXPLOSION_REFLECTION(72,500);
+ACE_EXPLOSION_REFLECTION(74,10);
+ACE_EXPLOSION_REFLECTION(74,20);
+ACE_EXPLOSION_REFLECTION(74,30);
+ACE_EXPLOSION_REFLECTION(74,40);
+ACE_EXPLOSION_REFLECTION(74,50);
+ACE_EXPLOSION_REFLECTION(74,60);
+ACE_EXPLOSION_REFLECTION(74,70);
+ACE_EXPLOSION_REFLECTION(74,80);
+ACE_EXPLOSION_REFLECTION(74,90);
+ACE_EXPLOSION_REFLECTION(74,100);
+ACE_EXPLOSION_REFLECTION(74,110);
+ACE_EXPLOSION_REFLECTION(74,120);
+ACE_EXPLOSION_REFLECTION(74,130);
+ACE_EXPLOSION_REFLECTION(74,140);
+ACE_EXPLOSION_REFLECTION(74,150);
+ACE_EXPLOSION_REFLECTION(74,160);
+ACE_EXPLOSION_REFLECTION(74,170);
+ACE_EXPLOSION_REFLECTION(74,180);
+ACE_EXPLOSION_REFLECTION(74,190);
+ACE_EXPLOSION_REFLECTION(74,200);
+ACE_EXPLOSION_REFLECTION(74,210);
+ACE_EXPLOSION_REFLECTION(74,220);
+ACE_EXPLOSION_REFLECTION(74,230);
+ACE_EXPLOSION_REFLECTION(74,240);
+ACE_EXPLOSION_REFLECTION(74,250);
+ACE_EXPLOSION_REFLECTION(74,260);
+ACE_EXPLOSION_REFLECTION(74,270);
+ACE_EXPLOSION_REFLECTION(74,280);
+ACE_EXPLOSION_REFLECTION(74,290);
+ACE_EXPLOSION_REFLECTION(74,300);
+ACE_EXPLOSION_REFLECTION(74,310);
+ACE_EXPLOSION_REFLECTION(74,320);
+ACE_EXPLOSION_REFLECTION(74,330);
+ACE_EXPLOSION_REFLECTION(74,340);
+ACE_EXPLOSION_REFLECTION(74,350);
+ACE_EXPLOSION_REFLECTION(74,360);
+ACE_EXPLOSION_REFLECTION(74,370);
+ACE_EXPLOSION_REFLECTION(74,380);
+ACE_EXPLOSION_REFLECTION(74,390);
+ACE_EXPLOSION_REFLECTION(74,400);
+ACE_EXPLOSION_REFLECTION(74,410);
+ACE_EXPLOSION_REFLECTION(74,420);
+ACE_EXPLOSION_REFLECTION(74,430);
+ACE_EXPLOSION_REFLECTION(74,440);
+ACE_EXPLOSION_REFLECTION(74,450);
+ACE_EXPLOSION_REFLECTION(74,460);
+ACE_EXPLOSION_REFLECTION(74,470);
+ACE_EXPLOSION_REFLECTION(74,480);
+ACE_EXPLOSION_REFLECTION(74,490);
+ACE_EXPLOSION_REFLECTION(74,500);
+ACE_EXPLOSION_REFLECTION(76,10);
+ACE_EXPLOSION_REFLECTION(76,20);
+ACE_EXPLOSION_REFLECTION(76,30);
+ACE_EXPLOSION_REFLECTION(76,40);
+ACE_EXPLOSION_REFLECTION(76,50);
+ACE_EXPLOSION_REFLECTION(76,60);
+ACE_EXPLOSION_REFLECTION(76,70);
+ACE_EXPLOSION_REFLECTION(76,80);
+ACE_EXPLOSION_REFLECTION(76,90);
+ACE_EXPLOSION_REFLECTION(76,100);
+ACE_EXPLOSION_REFLECTION(76,110);
+ACE_EXPLOSION_REFLECTION(76,120);
+ACE_EXPLOSION_REFLECTION(76,130);
+ACE_EXPLOSION_REFLECTION(76,140);
+ACE_EXPLOSION_REFLECTION(76,150);
+ACE_EXPLOSION_REFLECTION(76,160);
+ACE_EXPLOSION_REFLECTION(76,170);
+ACE_EXPLOSION_REFLECTION(76,180);
+ACE_EXPLOSION_REFLECTION(76,190);
+ACE_EXPLOSION_REFLECTION(76,200);
+ACE_EXPLOSION_REFLECTION(76,210);
+ACE_EXPLOSION_REFLECTION(76,220);
+ACE_EXPLOSION_REFLECTION(76,230);
+ACE_EXPLOSION_REFLECTION(76,240);
+ACE_EXPLOSION_REFLECTION(76,250);
+ACE_EXPLOSION_REFLECTION(76,260);
+ACE_EXPLOSION_REFLECTION(76,270);
+ACE_EXPLOSION_REFLECTION(76,280);
+ACE_EXPLOSION_REFLECTION(76,290);
+ACE_EXPLOSION_REFLECTION(76,300);
+ACE_EXPLOSION_REFLECTION(76,310);
+ACE_EXPLOSION_REFLECTION(76,320);
+ACE_EXPLOSION_REFLECTION(76,330);
+ACE_EXPLOSION_REFLECTION(76,340);
+ACE_EXPLOSION_REFLECTION(76,350);
+ACE_EXPLOSION_REFLECTION(76,360);
+ACE_EXPLOSION_REFLECTION(76,370);
+ACE_EXPLOSION_REFLECTION(76,380);
+ACE_EXPLOSION_REFLECTION(76,390);
+ACE_EXPLOSION_REFLECTION(76,400);
+ACE_EXPLOSION_REFLECTION(76,410);
+ACE_EXPLOSION_REFLECTION(76,420);
+ACE_EXPLOSION_REFLECTION(76,430);
+ACE_EXPLOSION_REFLECTION(76,440);
+ACE_EXPLOSION_REFLECTION(76,450);
+ACE_EXPLOSION_REFLECTION(76,460);
+ACE_EXPLOSION_REFLECTION(76,470);
+ACE_EXPLOSION_REFLECTION(76,480);
+ACE_EXPLOSION_REFLECTION(76,490);
+ACE_EXPLOSION_REFLECTION(76,500);
+ACE_EXPLOSION_REFLECTION(78,10);
+ACE_EXPLOSION_REFLECTION(78,20);
+ACE_EXPLOSION_REFLECTION(78,30);
+ACE_EXPLOSION_REFLECTION(78,40);
+ACE_EXPLOSION_REFLECTION(78,50);
+ACE_EXPLOSION_REFLECTION(78,60);
+ACE_EXPLOSION_REFLECTION(78,70);
+ACE_EXPLOSION_REFLECTION(78,80);
+ACE_EXPLOSION_REFLECTION(78,90);
+ACE_EXPLOSION_REFLECTION(78,100);
+ACE_EXPLOSION_REFLECTION(78,110);
+ACE_EXPLOSION_REFLECTION(78,120);
+ACE_EXPLOSION_REFLECTION(78,130);
+ACE_EXPLOSION_REFLECTION(78,140);
+ACE_EXPLOSION_REFLECTION(78,150);
+ACE_EXPLOSION_REFLECTION(78,160);
+ACE_EXPLOSION_REFLECTION(78,170);
+ACE_EXPLOSION_REFLECTION(78,180);
+ACE_EXPLOSION_REFLECTION(78,190);
+ACE_EXPLOSION_REFLECTION(78,200);
+ACE_EXPLOSION_REFLECTION(78,210);
+ACE_EXPLOSION_REFLECTION(78,220);
+ACE_EXPLOSION_REFLECTION(78,230);
+ACE_EXPLOSION_REFLECTION(78,240);
+ACE_EXPLOSION_REFLECTION(78,250);
+ACE_EXPLOSION_REFLECTION(78,260);
+ACE_EXPLOSION_REFLECTION(78,270);
+ACE_EXPLOSION_REFLECTION(78,280);
+ACE_EXPLOSION_REFLECTION(78,290);
+ACE_EXPLOSION_REFLECTION(78,300);
+ACE_EXPLOSION_REFLECTION(78,310);
+ACE_EXPLOSION_REFLECTION(78,320);
+ACE_EXPLOSION_REFLECTION(78,330);
+ACE_EXPLOSION_REFLECTION(78,340);
+ACE_EXPLOSION_REFLECTION(78,350);
+ACE_EXPLOSION_REFLECTION(78,360);
+ACE_EXPLOSION_REFLECTION(78,370);
+ACE_EXPLOSION_REFLECTION(78,380);
+ACE_EXPLOSION_REFLECTION(78,390);
+ACE_EXPLOSION_REFLECTION(78,400);
+ACE_EXPLOSION_REFLECTION(78,410);
+ACE_EXPLOSION_REFLECTION(78,420);
+ACE_EXPLOSION_REFLECTION(78,430);
+ACE_EXPLOSION_REFLECTION(78,440);
+ACE_EXPLOSION_REFLECTION(78,450);
+ACE_EXPLOSION_REFLECTION(78,460);
+ACE_EXPLOSION_REFLECTION(78,470);
+ACE_EXPLOSION_REFLECTION(78,480);
+ACE_EXPLOSION_REFLECTION(78,490);
+ACE_EXPLOSION_REFLECTION(78,500);
+ACE_EXPLOSION_REFLECTION(80,10);
+ACE_EXPLOSION_REFLECTION(80,20);
+ACE_EXPLOSION_REFLECTION(80,30);
+ACE_EXPLOSION_REFLECTION(80,40);
+ACE_EXPLOSION_REFLECTION(80,50);
+ACE_EXPLOSION_REFLECTION(80,60);
+ACE_EXPLOSION_REFLECTION(80,70);
+ACE_EXPLOSION_REFLECTION(80,80);
+ACE_EXPLOSION_REFLECTION(80,90);
+ACE_EXPLOSION_REFLECTION(80,100);
+ACE_EXPLOSION_REFLECTION(80,110);
+ACE_EXPLOSION_REFLECTION(80,120);
+ACE_EXPLOSION_REFLECTION(80,130);
+ACE_EXPLOSION_REFLECTION(80,140);
+ACE_EXPLOSION_REFLECTION(80,150);
+ACE_EXPLOSION_REFLECTION(80,160);
+ACE_EXPLOSION_REFLECTION(80,170);
+ACE_EXPLOSION_REFLECTION(80,180);
+ACE_EXPLOSION_REFLECTION(80,190);
+ACE_EXPLOSION_REFLECTION(80,200);
+ACE_EXPLOSION_REFLECTION(80,210);
+ACE_EXPLOSION_REFLECTION(80,220);
+ACE_EXPLOSION_REFLECTION(80,230);
+ACE_EXPLOSION_REFLECTION(80,240);
+ACE_EXPLOSION_REFLECTION(80,250);
+ACE_EXPLOSION_REFLECTION(80,260);
+ACE_EXPLOSION_REFLECTION(80,270);
+ACE_EXPLOSION_REFLECTION(80,280);
+ACE_EXPLOSION_REFLECTION(80,290);
+ACE_EXPLOSION_REFLECTION(80,300);
+ACE_EXPLOSION_REFLECTION(80,310);
+ACE_EXPLOSION_REFLECTION(80,320);
+ACE_EXPLOSION_REFLECTION(80,330);
+ACE_EXPLOSION_REFLECTION(80,340);
+ACE_EXPLOSION_REFLECTION(80,350);
+ACE_EXPLOSION_REFLECTION(80,360);
+ACE_EXPLOSION_REFLECTION(80,370);
+ACE_EXPLOSION_REFLECTION(80,380);
+ACE_EXPLOSION_REFLECTION(80,390);
+ACE_EXPLOSION_REFLECTION(80,400);
+ACE_EXPLOSION_REFLECTION(80,410);
+ACE_EXPLOSION_REFLECTION(80,420);
+ACE_EXPLOSION_REFLECTION(80,430);
+ACE_EXPLOSION_REFLECTION(80,440);
+ACE_EXPLOSION_REFLECTION(80,450);
+ACE_EXPLOSION_REFLECTION(80,460);
+ACE_EXPLOSION_REFLECTION(80,470);
+ACE_EXPLOSION_REFLECTION(80,480);
+ACE_EXPLOSION_REFLECTION(80,490);
+ACE_EXPLOSION_REFLECTION(80,500);
+ACE_EXPLOSION_REFLECTION(82,10);
+ACE_EXPLOSION_REFLECTION(82,20);
+ACE_EXPLOSION_REFLECTION(82,30);
+ACE_EXPLOSION_REFLECTION(82,40);
+ACE_EXPLOSION_REFLECTION(82,50);
+ACE_EXPLOSION_REFLECTION(82,60);
+ACE_EXPLOSION_REFLECTION(82,70);
+ACE_EXPLOSION_REFLECTION(82,80);
+ACE_EXPLOSION_REFLECTION(82,90);
+ACE_EXPLOSION_REFLECTION(82,100);
+ACE_EXPLOSION_REFLECTION(82,110);
+ACE_EXPLOSION_REFLECTION(82,120);
+ACE_EXPLOSION_REFLECTION(82,130);
+ACE_EXPLOSION_REFLECTION(82,140);
+ACE_EXPLOSION_REFLECTION(82,150);
+ACE_EXPLOSION_REFLECTION(82,160);
+ACE_EXPLOSION_REFLECTION(82,170);
+ACE_EXPLOSION_REFLECTION(82,180);
+ACE_EXPLOSION_REFLECTION(82,190);
+ACE_EXPLOSION_REFLECTION(82,200);
+ACE_EXPLOSION_REFLECTION(82,210);
+ACE_EXPLOSION_REFLECTION(82,220);
+ACE_EXPLOSION_REFLECTION(82,230);
+ACE_EXPLOSION_REFLECTION(82,240);
+ACE_EXPLOSION_REFLECTION(82,250);
+ACE_EXPLOSION_REFLECTION(82,260);
+ACE_EXPLOSION_REFLECTION(82,270);
+ACE_EXPLOSION_REFLECTION(82,280);
+ACE_EXPLOSION_REFLECTION(82,290);
+ACE_EXPLOSION_REFLECTION(82,300);
+ACE_EXPLOSION_REFLECTION(82,310);
+ACE_EXPLOSION_REFLECTION(82,320);
+ACE_EXPLOSION_REFLECTION(82,330);
+ACE_EXPLOSION_REFLECTION(82,340);
+ACE_EXPLOSION_REFLECTION(82,350);
+ACE_EXPLOSION_REFLECTION(82,360);
+ACE_EXPLOSION_REFLECTION(82,370);
+ACE_EXPLOSION_REFLECTION(82,380);
+ACE_EXPLOSION_REFLECTION(82,390);
+ACE_EXPLOSION_REFLECTION(82,400);
+ACE_EXPLOSION_REFLECTION(82,410);
+ACE_EXPLOSION_REFLECTION(82,420);
+ACE_EXPLOSION_REFLECTION(82,430);
+ACE_EXPLOSION_REFLECTION(82,440);
+ACE_EXPLOSION_REFLECTION(82,450);
+ACE_EXPLOSION_REFLECTION(82,460);
+ACE_EXPLOSION_REFLECTION(82,470);
+ACE_EXPLOSION_REFLECTION(82,480);
+ACE_EXPLOSION_REFLECTION(82,490);
+ACE_EXPLOSION_REFLECTION(82,500);
+ACE_EXPLOSION_REFLECTION(84,10);
+ACE_EXPLOSION_REFLECTION(84,20);
+ACE_EXPLOSION_REFLECTION(84,30);
+ACE_EXPLOSION_REFLECTION(84,40);
+ACE_EXPLOSION_REFLECTION(84,50);
+ACE_EXPLOSION_REFLECTION(84,60);
+ACE_EXPLOSION_REFLECTION(84,70);
+ACE_EXPLOSION_REFLECTION(84,80);
+ACE_EXPLOSION_REFLECTION(84,90);
+ACE_EXPLOSION_REFLECTION(84,100);
+ACE_EXPLOSION_REFLECTION(84,110);
+ACE_EXPLOSION_REFLECTION(84,120);
+ACE_EXPLOSION_REFLECTION(84,130);
+ACE_EXPLOSION_REFLECTION(84,140);
+ACE_EXPLOSION_REFLECTION(84,150);
+ACE_EXPLOSION_REFLECTION(84,160);
+ACE_EXPLOSION_REFLECTION(84,170);
+ACE_EXPLOSION_REFLECTION(84,180);
+ACE_EXPLOSION_REFLECTION(84,190);
+ACE_EXPLOSION_REFLECTION(84,200);
+ACE_EXPLOSION_REFLECTION(84,210);
+ACE_EXPLOSION_REFLECTION(84,220);
+ACE_EXPLOSION_REFLECTION(84,230);
+ACE_EXPLOSION_REFLECTION(84,240);
+ACE_EXPLOSION_REFLECTION(84,250);
+ACE_EXPLOSION_REFLECTION(84,260);
+ACE_EXPLOSION_REFLECTION(84,270);
+ACE_EXPLOSION_REFLECTION(84,280);
+ACE_EXPLOSION_REFLECTION(84,290);
+ACE_EXPLOSION_REFLECTION(84,300);
+ACE_EXPLOSION_REFLECTION(84,310);
+ACE_EXPLOSION_REFLECTION(84,320);
+ACE_EXPLOSION_REFLECTION(84,330);
+ACE_EXPLOSION_REFLECTION(84,340);
+ACE_EXPLOSION_REFLECTION(84,350);
+ACE_EXPLOSION_REFLECTION(84,360);
+ACE_EXPLOSION_REFLECTION(84,370);
+ACE_EXPLOSION_REFLECTION(84,380);
+ACE_EXPLOSION_REFLECTION(84,390);
+ACE_EXPLOSION_REFLECTION(84,400);
+ACE_EXPLOSION_REFLECTION(84,410);
+ACE_EXPLOSION_REFLECTION(84,420);
+ACE_EXPLOSION_REFLECTION(84,430);
+ACE_EXPLOSION_REFLECTION(84,440);
+ACE_EXPLOSION_REFLECTION(84,450);
+ACE_EXPLOSION_REFLECTION(84,460);
+ACE_EXPLOSION_REFLECTION(84,470);
+ACE_EXPLOSION_REFLECTION(84,480);
+ACE_EXPLOSION_REFLECTION(84,490);
+ACE_EXPLOSION_REFLECTION(84,500);
+ACE_EXPLOSION_REFLECTION(86,10);
+ACE_EXPLOSION_REFLECTION(86,20);
+ACE_EXPLOSION_REFLECTION(86,30);
+ACE_EXPLOSION_REFLECTION(86,40);
+ACE_EXPLOSION_REFLECTION(86,50);
+ACE_EXPLOSION_REFLECTION(86,60);
+ACE_EXPLOSION_REFLECTION(86,70);
+ACE_EXPLOSION_REFLECTION(86,80);
+ACE_EXPLOSION_REFLECTION(86,90);
+ACE_EXPLOSION_REFLECTION(86,100);
+ACE_EXPLOSION_REFLECTION(86,110);
+ACE_EXPLOSION_REFLECTION(86,120);
+ACE_EXPLOSION_REFLECTION(86,130);
+ACE_EXPLOSION_REFLECTION(86,140);
+ACE_EXPLOSION_REFLECTION(86,150);
+ACE_EXPLOSION_REFLECTION(86,160);
+ACE_EXPLOSION_REFLECTION(86,170);
+ACE_EXPLOSION_REFLECTION(86,180);
+ACE_EXPLOSION_REFLECTION(86,190);
+ACE_EXPLOSION_REFLECTION(86,200);
+ACE_EXPLOSION_REFLECTION(86,210);
+ACE_EXPLOSION_REFLECTION(86,220);
+ACE_EXPLOSION_REFLECTION(86,230);
+ACE_EXPLOSION_REFLECTION(86,240);
+ACE_EXPLOSION_REFLECTION(86,250);
+ACE_EXPLOSION_REFLECTION(86,260);
+ACE_EXPLOSION_REFLECTION(86,270);
+ACE_EXPLOSION_REFLECTION(86,280);
+ACE_EXPLOSION_REFLECTION(86,290);
+ACE_EXPLOSION_REFLECTION(86,300);
+ACE_EXPLOSION_REFLECTION(86,310);
+ACE_EXPLOSION_REFLECTION(86,320);
+ACE_EXPLOSION_REFLECTION(86,330);
+ACE_EXPLOSION_REFLECTION(86,340);
+ACE_EXPLOSION_REFLECTION(86,350);
+ACE_EXPLOSION_REFLECTION(86,360);
+ACE_EXPLOSION_REFLECTION(86,370);
+ACE_EXPLOSION_REFLECTION(86,380);
+ACE_EXPLOSION_REFLECTION(86,390);
+ACE_EXPLOSION_REFLECTION(86,400);
+ACE_EXPLOSION_REFLECTION(86,410);
+ACE_EXPLOSION_REFLECTION(86,420);
+ACE_EXPLOSION_REFLECTION(86,430);
+ACE_EXPLOSION_REFLECTION(86,440);
+ACE_EXPLOSION_REFLECTION(86,450);
+ACE_EXPLOSION_REFLECTION(86,460);
+ACE_EXPLOSION_REFLECTION(86,470);
+ACE_EXPLOSION_REFLECTION(86,480);
+ACE_EXPLOSION_REFLECTION(86,490);
+ACE_EXPLOSION_REFLECTION(86,500);
+ACE_EXPLOSION_REFLECTION(88,10);
+ACE_EXPLOSION_REFLECTION(88,20);
+ACE_EXPLOSION_REFLECTION(88,30);
+ACE_EXPLOSION_REFLECTION(88,40);
+ACE_EXPLOSION_REFLECTION(88,50);
+ACE_EXPLOSION_REFLECTION(88,60);
+ACE_EXPLOSION_REFLECTION(88,70);
+ACE_EXPLOSION_REFLECTION(88,80);
+ACE_EXPLOSION_REFLECTION(88,90);
+ACE_EXPLOSION_REFLECTION(88,100);
+ACE_EXPLOSION_REFLECTION(88,110);
+ACE_EXPLOSION_REFLECTION(88,120);
+ACE_EXPLOSION_REFLECTION(88,130);
+ACE_EXPLOSION_REFLECTION(88,140);
+ACE_EXPLOSION_REFLECTION(88,150);
+ACE_EXPLOSION_REFLECTION(88,160);
+ACE_EXPLOSION_REFLECTION(88,170);
+ACE_EXPLOSION_REFLECTION(88,180);
+ACE_EXPLOSION_REFLECTION(88,190);
+ACE_EXPLOSION_REFLECTION(88,200);
+ACE_EXPLOSION_REFLECTION(88,210);
+ACE_EXPLOSION_REFLECTION(88,220);
+ACE_EXPLOSION_REFLECTION(88,230);
+ACE_EXPLOSION_REFLECTION(88,240);
+ACE_EXPLOSION_REFLECTION(88,250);
+ACE_EXPLOSION_REFLECTION(88,260);
+ACE_EXPLOSION_REFLECTION(88,270);
+ACE_EXPLOSION_REFLECTION(88,280);
+ACE_EXPLOSION_REFLECTION(88,290);
+ACE_EXPLOSION_REFLECTION(88,300);
+ACE_EXPLOSION_REFLECTION(88,310);
+ACE_EXPLOSION_REFLECTION(88,320);
+ACE_EXPLOSION_REFLECTION(88,330);
+ACE_EXPLOSION_REFLECTION(88,340);
+ACE_EXPLOSION_REFLECTION(88,350);
+ACE_EXPLOSION_REFLECTION(88,360);
+ACE_EXPLOSION_REFLECTION(88,370);
+ACE_EXPLOSION_REFLECTION(88,380);
+ACE_EXPLOSION_REFLECTION(88,390);
+ACE_EXPLOSION_REFLECTION(88,400);
+ACE_EXPLOSION_REFLECTION(88,410);
+ACE_EXPLOSION_REFLECTION(88,420);
+ACE_EXPLOSION_REFLECTION(88,430);
+ACE_EXPLOSION_REFLECTION(88,440);
+ACE_EXPLOSION_REFLECTION(88,450);
+ACE_EXPLOSION_REFLECTION(88,460);
+ACE_EXPLOSION_REFLECTION(88,470);
+ACE_EXPLOSION_REFLECTION(88,480);
+ACE_EXPLOSION_REFLECTION(88,490);
+ACE_EXPLOSION_REFLECTION(88,500);
+ACE_EXPLOSION_REFLECTION(90,10);
+ACE_EXPLOSION_REFLECTION(90,20);
+ACE_EXPLOSION_REFLECTION(90,30);
+ACE_EXPLOSION_REFLECTION(90,40);
+ACE_EXPLOSION_REFLECTION(90,50);
+ACE_EXPLOSION_REFLECTION(90,60);
+ACE_EXPLOSION_REFLECTION(90,70);
+ACE_EXPLOSION_REFLECTION(90,80);
+ACE_EXPLOSION_REFLECTION(90,90);
+ACE_EXPLOSION_REFLECTION(90,100);
+ACE_EXPLOSION_REFLECTION(90,110);
+ACE_EXPLOSION_REFLECTION(90,120);
+ACE_EXPLOSION_REFLECTION(90,130);
+ACE_EXPLOSION_REFLECTION(90,140);
+ACE_EXPLOSION_REFLECTION(90,150);
+ACE_EXPLOSION_REFLECTION(90,160);
+ACE_EXPLOSION_REFLECTION(90,170);
+ACE_EXPLOSION_REFLECTION(90,180);
+ACE_EXPLOSION_REFLECTION(90,190);
+ACE_EXPLOSION_REFLECTION(90,200);
+ACE_EXPLOSION_REFLECTION(90,210);
+ACE_EXPLOSION_REFLECTION(90,220);
+ACE_EXPLOSION_REFLECTION(90,230);
+ACE_EXPLOSION_REFLECTION(90,240);
+ACE_EXPLOSION_REFLECTION(90,250);
+ACE_EXPLOSION_REFLECTION(90,260);
+ACE_EXPLOSION_REFLECTION(90,270);
+ACE_EXPLOSION_REFLECTION(90,280);
+ACE_EXPLOSION_REFLECTION(90,290);
+ACE_EXPLOSION_REFLECTION(90,300);
+ACE_EXPLOSION_REFLECTION(90,310);
+ACE_EXPLOSION_REFLECTION(90,320);
+ACE_EXPLOSION_REFLECTION(90,330);
+ACE_EXPLOSION_REFLECTION(90,340);
+ACE_EXPLOSION_REFLECTION(90,350);
+ACE_EXPLOSION_REFLECTION(90,360);
+ACE_EXPLOSION_REFLECTION(90,370);
+ACE_EXPLOSION_REFLECTION(90,380);
+ACE_EXPLOSION_REFLECTION(90,390);
+ACE_EXPLOSION_REFLECTION(90,400);
+ACE_EXPLOSION_REFLECTION(90,410);
+ACE_EXPLOSION_REFLECTION(90,420);
+ACE_EXPLOSION_REFLECTION(90,430);
+ACE_EXPLOSION_REFLECTION(90,440);
+ACE_EXPLOSION_REFLECTION(90,450);
+ACE_EXPLOSION_REFLECTION(90,460);
+ACE_EXPLOSION_REFLECTION(90,470);
+ACE_EXPLOSION_REFLECTION(90,480);
+ACE_EXPLOSION_REFLECTION(90,490);
+ACE_EXPLOSION_REFLECTION(90,500);
+ACE_EXPLOSION_REFLECTION(92,10);
+ACE_EXPLOSION_REFLECTION(92,20);
+ACE_EXPLOSION_REFLECTION(92,30);
+ACE_EXPLOSION_REFLECTION(92,40);
+ACE_EXPLOSION_REFLECTION(92,50);
+ACE_EXPLOSION_REFLECTION(92,60);
+ACE_EXPLOSION_REFLECTION(92,70);
+ACE_EXPLOSION_REFLECTION(92,80);
+ACE_EXPLOSION_REFLECTION(92,90);
+ACE_EXPLOSION_REFLECTION(92,100);
+ACE_EXPLOSION_REFLECTION(92,110);
+ACE_EXPLOSION_REFLECTION(92,120);
+ACE_EXPLOSION_REFLECTION(92,130);
+ACE_EXPLOSION_REFLECTION(92,140);
+ACE_EXPLOSION_REFLECTION(92,150);
+ACE_EXPLOSION_REFLECTION(92,160);
+ACE_EXPLOSION_REFLECTION(92,170);
+ACE_EXPLOSION_REFLECTION(92,180);
+ACE_EXPLOSION_REFLECTION(92,190);
+ACE_EXPLOSION_REFLECTION(92,200);
+ACE_EXPLOSION_REFLECTION(92,210);
+ACE_EXPLOSION_REFLECTION(92,220);
+ACE_EXPLOSION_REFLECTION(92,230);
+ACE_EXPLOSION_REFLECTION(92,240);
+ACE_EXPLOSION_REFLECTION(92,250);
+ACE_EXPLOSION_REFLECTION(92,260);
+ACE_EXPLOSION_REFLECTION(92,270);
+ACE_EXPLOSION_REFLECTION(92,280);
+ACE_EXPLOSION_REFLECTION(92,290);
+ACE_EXPLOSION_REFLECTION(92,300);
+ACE_EXPLOSION_REFLECTION(92,310);
+ACE_EXPLOSION_REFLECTION(92,320);
+ACE_EXPLOSION_REFLECTION(92,330);
+ACE_EXPLOSION_REFLECTION(92,340);
+ACE_EXPLOSION_REFLECTION(92,350);
+ACE_EXPLOSION_REFLECTION(92,360);
+ACE_EXPLOSION_REFLECTION(92,370);
+ACE_EXPLOSION_REFLECTION(92,380);
+ACE_EXPLOSION_REFLECTION(92,390);
+ACE_EXPLOSION_REFLECTION(92,400);
+ACE_EXPLOSION_REFLECTION(92,410);
+ACE_EXPLOSION_REFLECTION(92,420);
+ACE_EXPLOSION_REFLECTION(92,430);
+ACE_EXPLOSION_REFLECTION(92,440);
+ACE_EXPLOSION_REFLECTION(92,450);
+ACE_EXPLOSION_REFLECTION(92,460);
+ACE_EXPLOSION_REFLECTION(92,470);
+ACE_EXPLOSION_REFLECTION(92,480);
+ACE_EXPLOSION_REFLECTION(92,490);
+ACE_EXPLOSION_REFLECTION(92,500);
+ACE_EXPLOSION_REFLECTION(94,10);
+ACE_EXPLOSION_REFLECTION(94,20);
+ACE_EXPLOSION_REFLECTION(94,30);
+ACE_EXPLOSION_REFLECTION(94,40);
+ACE_EXPLOSION_REFLECTION(94,50);
+ACE_EXPLOSION_REFLECTION(94,60);
+ACE_EXPLOSION_REFLECTION(94,70);
+ACE_EXPLOSION_REFLECTION(94,80);
+ACE_EXPLOSION_REFLECTION(94,90);
+ACE_EXPLOSION_REFLECTION(94,100);
+ACE_EXPLOSION_REFLECTION(94,110);
+ACE_EXPLOSION_REFLECTION(94,120);
+ACE_EXPLOSION_REFLECTION(94,130);
+ACE_EXPLOSION_REFLECTION(94,140);
+ACE_EXPLOSION_REFLECTION(94,150);
+ACE_EXPLOSION_REFLECTION(94,160);
+ACE_EXPLOSION_REFLECTION(94,170);
+ACE_EXPLOSION_REFLECTION(94,180);
+ACE_EXPLOSION_REFLECTION(94,190);
+ACE_EXPLOSION_REFLECTION(94,200);
+ACE_EXPLOSION_REFLECTION(94,210);
+ACE_EXPLOSION_REFLECTION(94,220);
+ACE_EXPLOSION_REFLECTION(94,230);
+ACE_EXPLOSION_REFLECTION(94,240);
+ACE_EXPLOSION_REFLECTION(94,250);
+ACE_EXPLOSION_REFLECTION(94,260);
+ACE_EXPLOSION_REFLECTION(94,270);
+ACE_EXPLOSION_REFLECTION(94,280);
+ACE_EXPLOSION_REFLECTION(94,290);
+ACE_EXPLOSION_REFLECTION(94,300);
+ACE_EXPLOSION_REFLECTION(94,310);
+ACE_EXPLOSION_REFLECTION(94,320);
+ACE_EXPLOSION_REFLECTION(94,330);
+ACE_EXPLOSION_REFLECTION(94,340);
+ACE_EXPLOSION_REFLECTION(94,350);
+ACE_EXPLOSION_REFLECTION(94,360);
+ACE_EXPLOSION_REFLECTION(94,370);
+ACE_EXPLOSION_REFLECTION(94,380);
+ACE_EXPLOSION_REFLECTION(94,390);
+ACE_EXPLOSION_REFLECTION(94,400);
+ACE_EXPLOSION_REFLECTION(94,410);
+ACE_EXPLOSION_REFLECTION(94,420);
+ACE_EXPLOSION_REFLECTION(94,430);
+ACE_EXPLOSION_REFLECTION(94,440);
+ACE_EXPLOSION_REFLECTION(94,450);
+ACE_EXPLOSION_REFLECTION(94,460);
+ACE_EXPLOSION_REFLECTION(94,470);
+ACE_EXPLOSION_REFLECTION(94,480);
+ACE_EXPLOSION_REFLECTION(94,490);
+ACE_EXPLOSION_REFLECTION(94,500);
+ACE_EXPLOSION_REFLECTION(96,10);
+ACE_EXPLOSION_REFLECTION(96,20);
+ACE_EXPLOSION_REFLECTION(96,30);
+ACE_EXPLOSION_REFLECTION(96,40);
+ACE_EXPLOSION_REFLECTION(96,50);
+ACE_EXPLOSION_REFLECTION(96,60);
+ACE_EXPLOSION_REFLECTION(96,70);
+ACE_EXPLOSION_REFLECTION(96,80);
+ACE_EXPLOSION_REFLECTION(96,90);
+ACE_EXPLOSION_REFLECTION(96,100);
+ACE_EXPLOSION_REFLECTION(96,110);
+ACE_EXPLOSION_REFLECTION(96,120);
+ACE_EXPLOSION_REFLECTION(96,130);
+ACE_EXPLOSION_REFLECTION(96,140);
+ACE_EXPLOSION_REFLECTION(96,150);
+ACE_EXPLOSION_REFLECTION(96,160);
+ACE_EXPLOSION_REFLECTION(96,170);
+ACE_EXPLOSION_REFLECTION(96,180);
+ACE_EXPLOSION_REFLECTION(96,190);
+ACE_EXPLOSION_REFLECTION(96,200);
+ACE_EXPLOSION_REFLECTION(96,210);
+ACE_EXPLOSION_REFLECTION(96,220);
+ACE_EXPLOSION_REFLECTION(96,230);
+ACE_EXPLOSION_REFLECTION(96,240);
+ACE_EXPLOSION_REFLECTION(96,250);
+ACE_EXPLOSION_REFLECTION(96,260);
+ACE_EXPLOSION_REFLECTION(96,270);
+ACE_EXPLOSION_REFLECTION(96,280);
+ACE_EXPLOSION_REFLECTION(96,290);
+ACE_EXPLOSION_REFLECTION(96,300);
+ACE_EXPLOSION_REFLECTION(96,310);
+ACE_EXPLOSION_REFLECTION(96,320);
+ACE_EXPLOSION_REFLECTION(96,330);
+ACE_EXPLOSION_REFLECTION(96,340);
+ACE_EXPLOSION_REFLECTION(96,350);
+ACE_EXPLOSION_REFLECTION(96,360);
+ACE_EXPLOSION_REFLECTION(96,370);
+ACE_EXPLOSION_REFLECTION(96,380);
+ACE_EXPLOSION_REFLECTION(96,390);
+ACE_EXPLOSION_REFLECTION(96,400);
+ACE_EXPLOSION_REFLECTION(96,410);
+ACE_EXPLOSION_REFLECTION(96,420);
+ACE_EXPLOSION_REFLECTION(96,430);
+ACE_EXPLOSION_REFLECTION(96,440);
+ACE_EXPLOSION_REFLECTION(96,450);
+ACE_EXPLOSION_REFLECTION(96,460);
+ACE_EXPLOSION_REFLECTION(96,470);
+ACE_EXPLOSION_REFLECTION(96,480);
+ACE_EXPLOSION_REFLECTION(96,490);
+ACE_EXPLOSION_REFLECTION(96,500);
+ACE_EXPLOSION_REFLECTION(98,10);
+ACE_EXPLOSION_REFLECTION(98,20);
+ACE_EXPLOSION_REFLECTION(98,30);
+ACE_EXPLOSION_REFLECTION(98,40);
+ACE_EXPLOSION_REFLECTION(98,50);
+ACE_EXPLOSION_REFLECTION(98,60);
+ACE_EXPLOSION_REFLECTION(98,70);
+ACE_EXPLOSION_REFLECTION(98,80);
+ACE_EXPLOSION_REFLECTION(98,90);
+ACE_EXPLOSION_REFLECTION(98,100);
+ACE_EXPLOSION_REFLECTION(98,110);
+ACE_EXPLOSION_REFLECTION(98,120);
+ACE_EXPLOSION_REFLECTION(98,130);
+ACE_EXPLOSION_REFLECTION(98,140);
+ACE_EXPLOSION_REFLECTION(98,150);
+ACE_EXPLOSION_REFLECTION(98,160);
+ACE_EXPLOSION_REFLECTION(98,170);
+ACE_EXPLOSION_REFLECTION(98,180);
+ACE_EXPLOSION_REFLECTION(98,190);
+ACE_EXPLOSION_REFLECTION(98,200);
+ACE_EXPLOSION_REFLECTION(98,210);
+ACE_EXPLOSION_REFLECTION(98,220);
+ACE_EXPLOSION_REFLECTION(98,230);
+ACE_EXPLOSION_REFLECTION(98,240);
+ACE_EXPLOSION_REFLECTION(98,250);
+ACE_EXPLOSION_REFLECTION(98,260);
+ACE_EXPLOSION_REFLECTION(98,270);
+ACE_EXPLOSION_REFLECTION(98,280);
+ACE_EXPLOSION_REFLECTION(98,290);
+ACE_EXPLOSION_REFLECTION(98,300);
+ACE_EXPLOSION_REFLECTION(98,310);
+ACE_EXPLOSION_REFLECTION(98,320);
+ACE_EXPLOSION_REFLECTION(98,330);
+ACE_EXPLOSION_REFLECTION(98,340);
+ACE_EXPLOSION_REFLECTION(98,350);
+ACE_EXPLOSION_REFLECTION(98,360);
+ACE_EXPLOSION_REFLECTION(98,370);
+ACE_EXPLOSION_REFLECTION(98,380);
+ACE_EXPLOSION_REFLECTION(98,390);
+ACE_EXPLOSION_REFLECTION(98,400);
+ACE_EXPLOSION_REFLECTION(98,410);
+ACE_EXPLOSION_REFLECTION(98,420);
+ACE_EXPLOSION_REFLECTION(98,430);
+ACE_EXPLOSION_REFLECTION(98,440);
+ACE_EXPLOSION_REFLECTION(98,450);
+ACE_EXPLOSION_REFLECTION(98,460);
+ACE_EXPLOSION_REFLECTION(98,470);
+ACE_EXPLOSION_REFLECTION(98,480);
+ACE_EXPLOSION_REFLECTION(98,490);
+ACE_EXPLOSION_REFLECTION(98,500);
+ACE_EXPLOSION_REFLECTION(100,10);
+ACE_EXPLOSION_REFLECTION(100,20);
+ACE_EXPLOSION_REFLECTION(100,30);
+ACE_EXPLOSION_REFLECTION(100,40);
+ACE_EXPLOSION_REFLECTION(100,50);
+ACE_EXPLOSION_REFLECTION(100,60);
+ACE_EXPLOSION_REFLECTION(100,70);
+ACE_EXPLOSION_REFLECTION(100,80);
+ACE_EXPLOSION_REFLECTION(100,90);
+ACE_EXPLOSION_REFLECTION(100,100);
+ACE_EXPLOSION_REFLECTION(100,110);
+ACE_EXPLOSION_REFLECTION(100,120);
+ACE_EXPLOSION_REFLECTION(100,130);
+ACE_EXPLOSION_REFLECTION(100,140);
+ACE_EXPLOSION_REFLECTION(100,150);
+ACE_EXPLOSION_REFLECTION(100,160);
+ACE_EXPLOSION_REFLECTION(100,170);
+ACE_EXPLOSION_REFLECTION(100,180);
+ACE_EXPLOSION_REFLECTION(100,190);
+ACE_EXPLOSION_REFLECTION(100,200);
+ACE_EXPLOSION_REFLECTION(100,210);
+ACE_EXPLOSION_REFLECTION(100,220);
+ACE_EXPLOSION_REFLECTION(100,230);
+ACE_EXPLOSION_REFLECTION(100,240);
+ACE_EXPLOSION_REFLECTION(100,250);
+ACE_EXPLOSION_REFLECTION(100,260);
+ACE_EXPLOSION_REFLECTION(100,270);
+ACE_EXPLOSION_REFLECTION(100,280);
+ACE_EXPLOSION_REFLECTION(100,290);
+ACE_EXPLOSION_REFLECTION(100,300);
+ACE_EXPLOSION_REFLECTION(100,310);
+ACE_EXPLOSION_REFLECTION(100,320);
+ACE_EXPLOSION_REFLECTION(100,330);
+ACE_EXPLOSION_REFLECTION(100,340);
+ACE_EXPLOSION_REFLECTION(100,350);
+ACE_EXPLOSION_REFLECTION(100,360);
+ACE_EXPLOSION_REFLECTION(100,370);
+ACE_EXPLOSION_REFLECTION(100,380);
+ACE_EXPLOSION_REFLECTION(100,390);
+ACE_EXPLOSION_REFLECTION(100,400);
+ACE_EXPLOSION_REFLECTION(100,410);
+ACE_EXPLOSION_REFLECTION(100,420);
+ACE_EXPLOSION_REFLECTION(100,430);
+ACE_EXPLOSION_REFLECTION(100,440);
+ACE_EXPLOSION_REFLECTION(100,450);
+ACE_EXPLOSION_REFLECTION(100,460);
+ACE_EXPLOSION_REFLECTION(100,470);
+ACE_EXPLOSION_REFLECTION(100,480);
+ACE_EXPLOSION_REFLECTION(100,490);
+ACE_EXPLOSION_REFLECTION(100,500);
+
diff --git a/addons/frag/XEH_pre_Init.sqf b/addons/frag/XEH_pre_Init.sqf
index 5b3aa36b18..4ec70bbc3d 100644
--- a/addons/frag/XEH_pre_Init.sqf
+++ b/addons/frag/XEH_pre_Init.sqf
@@ -9,6 +9,10 @@ PREP(trackFragRound);
 PREP(spallTrack);
 PREP(doSpall);
 PREP(vectorDiffFast);
+PREP(findReflections);
+PREP(doExplosions);
+PREP(doReflections);
+
 
 GVAR(trackedObjects) = [];
 GVAR(blackList) = [];
diff --git a/addons/frag/functions/fnc_doExplosions.sqf b/addons/frag/functions/fnc_doExplosions.sqf
new file mode 100644
index 0000000000..f2c20c2f1e
--- /dev/null
+++ b/addons/frag/functions/fnc_doExplosions.sqf
@@ -0,0 +1,26 @@
+//fnc_doExplosions.sqf
+#include "script_component.hpp"
+
+private ["_params", "_explosions", "_index", "_i", "_exp", "_refExp", "_bpos", "_hit", "_distance", "_indirectHitRange", "_depth"];
+_params = _this select 0;
+_explosions = _params select 0;
+_index = _params select 1;
+for "_i" from _index to ((_index+1) min (count _explosions)) do {
+    _exp = _explosions select _i;
+    _refExp = _exp select 0;
+    _bpos = _exp select 1;
+    _hit = _exp select 2;
+    _distance = _exp select 3;
+    _indirectHitRange = _exp select 4;
+    _depth = _exp select 5;
+    _refExp createVehicle (ASLtoATL _bpos);
+    // if(_hit >= 150 && _distance > _indirectHitRange) then {
+        // [_bpos, _refExp, _depth] call FUNC(doReflections);
+    // };
+};
+_index = _index + 1;
+if(_index >= (count _explosions)) then {
+    [(_this select 1)] call cba_fnc_removePerFrameHandler;
+} else {
+    _params set[1, _index];
+};
diff --git a/addons/frag/functions/fnc_doReflections.sqf b/addons/frag/functions/fnc_doReflections.sqf
new file mode 100644
index 0000000000..844ccb4c9b
--- /dev/null
+++ b/addons/frag/functions/fnc_doReflections.sqf
@@ -0,0 +1,22 @@
+//fnc_doReflections.sqf
+#include "script_component.hpp"
+
+private ["_pos", "_ammo", "_depth", "_hit", "_range", "_hitFactor", "_indirectHitRange", "_indirectHit", "_testParams"];
+
+_pos = _this select 0;
+_ammo = _this select 1;
+_depth = 1;
+if(count _this > 2) then {
+    _depth = _this select 2;
+};
+// TEST_ICONS pushBack [_pos, format["EXP!", _hit, _range, _hitFactor]];
+if(_depth <= 2) then {
+    _indirectHitRange = getNumber(configFile >> "CfgAmmo" >> _ammo >> "indirectHitRange");
+    _indirectHit = getNumber(configFile >> "CfgAmmo" >> _ammo >> "indirectHit");
+    
+    
+    
+    
+    _testParams = [_pos, [_indirectHitRange, _indirectHit], [], [], -4, _depth, 0];
+    [DFUNC(findReflections), 0.005, _testParams] call cba_fnc_addPerFrameHandler;
+};
diff --git a/addons/frag/functions/fnc_findReflections.sqf b/addons/frag/functions/fnc_findReflections.sqf
new file mode 100644
index 0000000000..75c4ee2ae6
--- /dev/null
+++ b/addons/frag/functions/fnc_findReflections.sqf
@@ -0,0 +1,130 @@
+//fnc_findReflections.sqf
+#include "script_component.hpp"
+
+private ["_split", "_radi", "_params", "_pos", "_explosiveInfo", "_los", "_nlos", "_zIndex", "_depth", "_indirectHitRange", 
+    "_indirectHit", "_distanceCount", "_lastPos", "_test", "_vec", "_testPos", "_buckets", "_excludes", "_bucketIndex", "_bucketPos", 
+    "_bucketList", "_c", "_index", "_blist", "_avgX", "_avgY", "_avgZ", "_bpos", "_distance", "_hitFactor", "_hit", "_range", "_refExp", 
+    "_rand", "_i", "_x", "_res", "_forEachIndex", "_explosions", "_can", "_dirvec"];
+
+
+_params = _this select 0;
+_pos = _params select 0;
+_explosiveInfo = _params select 1;
+_los = _params select 2;
+_nlos = _params select 3;
+_zIndex = _params select 4;
+_depth = _params select 5;
+_rand = _params select 6;
+
+_split = 15;
+_radi = (360/_split*_depth);
+
+// player sideChat format["p: %1", _explosiveInfo];
+_indirectHitRange = _explosiveInfo select 0;
+_indirectHit = _explosiveInfo select 1;
+_distanceCount = (floor _indirectHitRange*4) min 100;
+
+if(_zIndex < 5) then {
+    _lastPos = _pos;
+    _zAng = _zIndex*20+2;
+    if(_zAng > 80) then {
+        _radi = 1;
+        _zAng = 90;
+    };
+    for "_i" from 0 to _radi do {
+        _test = true;
+        _vec = [1, ((_i*_split)+_rand) mod 360, _zAng] call cba_fnc_polar2vect;
+        for "_x" from 1 to _distanceCount do {
+            _testPos = _pos vectorAdd (_vec vectorMultiply _x);
+            // drop ["\a3\data_f\Cl_basic","","Billboard",1,15,ASLtoATL _testPos,[0,0,0],1,1.275,1.0,0.0,[1],[[1,0,0,1]],[0],0.0,2.0,"","",""];
+            _res = lineIntersectsWith [_pos, _testPos];
+            if(count _res > 0) exitWith {
+                _test = false;
+                _nlos pushBack _lastPos;
+                // {
+                    // _x addEventHandler ["HandleDamage", { diag_log text format["this: %1", _this]; }];
+                // } forEach _res;
+                // drop ["\a3\data_f\Cl_basic","","Billboard",1,15,ASLtoATL _testPos,[0,0,0],1,1.275,1.0,0.0,[1],[[1,0,0,1]],[0],0.0,2.0,"","",""];
+                // TEST_PAIRS pushBack [_pos, _lastPos, [1,0,0,1]];
+                
+            };
+            // if(terrainIntersectASL [_pos, _testPos]) exitWith {};
+            _lastPos = _testPos;
+        };
+    };
+    _params set[4, _zIndex+1];
+} else {
+    _depth = _depth + 1;
+    _buckets = [];
+    _excludes = [];
+    _bucketIndex = 0;
+    _bucketPos = nil;
+    _bucketList = nil;
+    _c = 0;
+    while { count(_nlos) != count(_excludes) && _c < (count _nlos) } do {
+        scopeName "mainSearch";
+        {
+            if(!(_forEachIndex in _excludes)) then {
+                _index = _buckets pushBack [_x, [_x]];
+                _excludes pushBack _forEachIndex;
+                _bucketPos = _x;
+                _bucketList = (_buckets select _index) select 1;
+                breakTo "mainSearch";
+            };
+        } forEach _nlos;
+        {
+            if(!(_forEachIndex in _excludes)) then {
+                _testPos = _x;
+                if(_testPos vectorDistanceSqr _bucketPos <= 30) then {
+                    _bucketList pushBack _x;
+                    _excludes pushBack _forEachIndex;
+                };
+            };
+        } forEach _nlos;
+        _c = _c + 1;
+    };
+
+    // player sideChat format["c: %1", count _buckets];
+    _explosions = [];
+    {
+        _blist = _x select 1;
+        _avgX = 0;
+        _avgY = 0;
+        _avgZ = 0;
+        
+        {
+            _avgX = _avgX + (_x select 0);
+            _avgY = _avgY + (_x select 1);
+            _avgZ = _avgZ + (_x select 2);
+        } forEach _blist;
+        _c = count _blist;
+        _bpos = [_avgX/_c, _avgY/_c, _avgZ/_c];
+        
+        _distance = _pos vectorDistance _bpos;
+        _hitFactor = 1-(((_distance/(_indirectHitRange*4)) min 1) max 0);
+        // _hitFactor = 1/(_distance^2);
+        _hit = _indirectHit*_hitFactor;
+        _hit = (floor (_hit/4)) min 500;
+        _hit = _hit - (_hit%10);
+        _range = (floor (_indirectHitRange-(_distance/4))) min 100;
+        _range = _range - (_range%2);
+        
+        if(_hit >= 10 && _range > 0) then {
+            // TEST_ICONS pushBack [_bpos, format["h: %1, r: %2, hf: %3 d: %4 ihr: %5", _hit, _range, _hitFactor, _distance, _indirectHitRange*4]];
+            // TEST_PAIRS pushBack [_pos, _bpos, [1,0,0,1]];
+            _refExp = format["ace_explosion_reflection_%1_%2", _range, _hit];
+            // _refExp createVehicle (ASLtoATL _bpos);
+            // drop ["\a3\data_f\Cl_basic","","Billboard",1,15,ASLtoATL _bpos,[0,0,0],1,1.275,1.0,0.0,[1],[[1,0,0,1]],[0],0.0,2.0,"","",""];
+            
+            _explosions pushBack [_refExp, _bpos, _hit, _distance, _indirectHitRange/4, _depth];
+            
+        };
+        if(count _explosions > (_radi*2)/_depth) exitWith {};
+    } forEach _buckets;
+    // _can = "Land_Bricks_V4_F" createVehicle (ASLtoATL _pos);
+    // _dirvec = _pos vectorFromTo ((ATLtoASL (player modelToWorldVisual (player selectionPosition "Spine3"))));
+    // _dirvec = _dirvec vectorMultiply 100;
+    // _can setVelocity _dirvec;
+    [DFUNC(doExplosions), 0, [_explosions, 0]] call cba_fnc_addPerFrameHandler;
+    [(_this select 1)] call cba_fnc_removePerFrameHandler;
+};
diff --git a/addons/frag/functions/fnc_frago.sqf b/addons/frag/functions/fnc_frago.sqf
index 1b737dc70d..8c97baa209 100644
--- a/addons/frag/functions/fnc_frago.sqf
+++ b/addons/frag/functions/fnc_frago.sqf
@@ -111,8 +111,9 @@ _fragArcs set[360, 0];
     player sideChat format["_fragRange: %1", _fragRange];
     player sideChat format["_objects: %1", _objects];
 #endif
-_doRandom = false;
+_doRandom = true;
 if(_isArmed && (count _objects) > 0) then {
+    [_lastPos, _shellType] call FUNC(doReflections);
     {
         //if(random(1) > 0.5) then {
             _target = _x;
@@ -189,7 +190,7 @@ if(_isArmed && (count _objects) > 0) then {
         if(_fragCount > MAX_FRAG_COUNT) exitWith {};
     } forEach _objects;
     if(_fragCount > MAX_FRAG_COUNT) exitWith {};
-    _randomCount = (ceil((MAX_FRAG_COUNT-_fragCount)*0.1)) max 0;
+    _randomCount = ((ceil((MAX_FRAG_COUNT-_fragCount)*0.1)) max 0)+20;
     _sectorSize = 360 / (_randomCount max 1);
     // _doRandom = false;
     if(_doRandom) then {
@@ -222,6 +223,7 @@ if(_isArmed && (count _objects) > 0) then {
             _fragCount = _fragCount + 1;
         };
     };
+    
 };
 // #ifdef DEBUG_MODE_FULL
     // player sideChat format["total frags: %1", GVAR(TOTALFRAGS)];