diff --git a/WeldingComponents/WeldingCommon/Sequences/Main/SeqUploadWeldingList.cs b/WeldingComponents/WeldingCommon/Sequences/Main/SeqUploadWeldingList.cs
index 9e470ce..0a6041d 100644
--- a/WeldingComponents/WeldingCommon/Sequences/Main/SeqUploadWeldingList.cs
+++ b/WeldingComponents/WeldingCommon/Sequences/Main/SeqUploadWeldingList.cs
@@ -294,6 +294,7 @@ namespace WeldingCommon.Sequences {
             foreach (IDrawObject obj in objects) {
                 drawObjectCount += FuncLoadDrawObjectScannerParamSelected(obj);
             }
+            Debug.WriteLine($"Scanner Space Check({_Scanner.GetListSpace()})");
 
             return drawObjectCount;
         }
@@ -307,7 +308,6 @@ namespace WeldingCommon.Sequences {
                     count += FuncLoadDrawObjectScannerParamSelected(subObj);
                 }
             }
-
             return count;
         }
 
@@ -634,22 +634,23 @@ namespace WeldingCommon.Sequences {
                 int risingCount = (int)(StartDistance / length);
                 int fallingCount = (int)(EndDistance / length);
                 int totalCount = (int)(obj.Distance / length);
+                Log.I($"Ramping count >> firstCount({firstCount}) / risingCount({risingCount}) / fallingCount({fallingCount}) / totalCount({totalCount})");
 
                 // Power1    A -> Start Power, B -> End Power
                 float firstPower_A1 = percentLaser1 * (float)param.RampingStartAPower1 / 100;   // Ramping First Power 1
                 float firstPower_B1 = percentLaser1 * (float)param.RampingStartAPower2 / 100;   // Ramping First Power 2
                 float startPower_A1 = percentLaser1 * (float)param.RampingStartPower1 / 100;    // Ramping Start Power 1
-                float startPower_B1 = percentLaser1 * (float)param.RampingStartPower3 / 100;    // Ramping Start Power 3
+                float startPower_B1 = percentLaser1 * (float)param.RampingStartPower2 / 100;    // Ramping Start Power 3
                 float endPower_A1 = percentLaser1 * (float)param.RampingEndPower1 / 100;        // Ramping End Power 1
-                float endPower_B1 = percentLaser1 * (float)param.RampingEndPower3 / 100;        // Ramping End Power 3
+                float endPower_B1 = percentLaser1 * (float)param.RampingEndPower2 / 100;        // Ramping End Power 3
 
                 // Power2    A -> Start Power, B -> End Power
                 float firstPower_A2 = percentLaser2 * (float)param.RampingStartAPower1 / 100;   // Ramping First Power 1
                 float firstPower_B2 = percentLaser2 * (float)param.RampingStartAPower2 / 100;   // Ramping First Power 2
                 float startPower_A2 = percentLaser2 * (float)param.RampingStartPower1 / 100;    // Ramping Start Power 1
-                float startPower_B2 = percentLaser2 * (float)param.RampingStartPower3 / 100;    // Ramping Start Power 3
+                float startPower_B2 = percentLaser2 * (float)param.RampingStartPower2 / 100;    // Ramping Start Power 3
                 float endPower_A2 = percentLaser2 * (float)param.RampingEndPower1 / 100;        // Ramping End Power 1
-                float endPower_B2 = percentLaser2 * (float)param.RampingEndPower3 / 100;        // Ramping End Power 3
+                float endPower_B2 = percentLaser2 * (float)param.RampingEndPower2 / 100;        // Ramping End Power 3
 
                 double dx = (obj.P2.X - obj.P1.X) / obj.Distance * length;
                 double dy = (obj.P2.Y - obj.P1.Y) / obj.Distance * length;
@@ -659,7 +660,7 @@ namespace WeldingCommon.Sequences {
 
                 Log.I($"[Line Weld] Ramping Condition No({obj.No + 1}), Line Length : {obj.Distance}" +
                     $"(Start_A:{param.RampingStartADist}%, Dist {FirstDistance}mm {(float)param.RampingStartAPower1}% -> {(float)param.RampingStartAPower2}%) " +
-                    $"(Start_B:{param.RampingStartDist}%, Dist {StartDistance}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower3}%) " +
+                    $"(Start_B:{param.RampingStartDist}%, Dist {StartDistance}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower2}%) " +
                     $"(End:{param.RampingEndDist}%, Dist {EndDistance}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower3}%)");
 
 
@@ -667,27 +668,40 @@ namespace WeldingCommon.Sequences {
                     float power1 = percentLaser1;
                     float power2 = percentLaser2;
 
-                    // first Ramping은 Start 지점의 연속으로 Start Ramping과 이어서 한다.
                     if (iter <= (risingCount + firstCount)) {
-                        // power1은 startPower_A1 에서 startPower_B1 까지 변한다
-                        // float IntervalPerPower = (B - A) / Cnt
-                        // power1 = PowerA + (iter * IntervalPerPower);
                         if (iter <= firstCount) {
-                            if (iter == 0) {
+                            if (iter == 0 || firstCount == 0) {
                                 power1 = firstPower_A1;
                                 power2 = firstPower_A2;
                             } else {
                                 power1 = firstPower_A1 + (firstPower_B1 - firstPower_A1) * (iter / (float)firstCount);
                                 power2 = firstPower_A2 + (firstPower_B2 - firstPower_A2) * (iter / (float)firstCount);
                             }
-                        } else if ((iter - firstCount) <= risingCount) {
-                            power1 = startPower_A1 + (startPower_B1 - startPower_A1) * ((iter - firstCount) / (float)risingCount);
-                            power2 = startPower_A2 + (startPower_B2 - startPower_A2) * ((iter - firstCount) / (float)risingCount);
                         }
-                    } else if (iter >= totalCount - fallingCount) {
-                        // power1은 endPower_A1 에서 endPower_B1 까지 변한다
-                        power1 = endPower_B1 + (endPower_A1 - endPower_B1) * (totalCount - iter) / (float)fallingCount;
-                        power2 = endPower_B2 + (endPower_A2 - endPower_B2) * (totalCount - iter) / (float)fallingCount;
+                        else if ((iter - firstCount) <= risingCount) {
+                            if (risingCount == 0) {
+                                power1 = startPower_B1;
+                                power2 = startPower_B2;
+                            }
+                            else {
+                                power1 = startPower_A1 + (startPower_B1 - startPower_A1) * ((iter - firstCount) / (float)risingCount);
+                                power2 = startPower_A2 + (startPower_B2 - startPower_A2) * ((iter - firstCount) / (float)risingCount);
+                            }
+                        }
+                    }
+                    else if (iter >= totalCount - fallingCount) {
+                        if (fallingCount == 0) {
+                            power1 = endPower_A1;
+                            power2 = endPower_A2;
+                        }
+                        else {
+                            power1 = endPower_B1 + (endPower_A1 - endPower_B1) * (totalCount - iter) / (float)fallingCount;
+                            power2 = endPower_B2 + (endPower_A2 - endPower_B2) * (totalCount - iter) / (float)fallingCount;
+                        }
+                    }
+                    else {
+                        power1 = startPower_B1;
+                        power2 = startPower_B2;
                     }
 
                     _Scanner.WriteDA((uint)eAnalogPortOut.DA1, power1, eFunctionType.LIST);
@@ -839,8 +853,8 @@ namespace WeldingCommon.Sequences {
                 float startingPercentLaser_A1 = percentLaser1 * (float)param.RampingStartPower1 / 100 <= 100 ?
                                 percentLaser1 * (float)param.RampingStartPower1 / 100 : 100;
 
-                float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower3 / 100 <= 100 ?
-                                               percentLaser1 * (float)param.RampingStartPower3 / 100 : 100;
+                float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower2 / 100 <= 100 ?
+                                               percentLaser1 * (float)param.RampingStartPower2 / 100 : 100;
 
                 float risingEdgePercentLaser1 = 0;
                 float startingPercentLaser2 = percentLaser2 * (float)param.RampingStartPower2 / 100 <= 100 ?
@@ -1570,13 +1584,13 @@ namespace WeldingCommon.Sequences {
 
                 float startingPercentLaser_A1 = percentLaser1 * (float)param.RampingStartPower1 / 100 <= 100 ?
                                                 percentLaser1 * (float)param.RampingStartPower1 / 100 : 100;
-                float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower3 / 100 <= 100 ?
-                                                percentLaser1 * (float)param.RampingStartPower3 / 100 : 100;
+                float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower2 / 100 <= 100 ?
+                                                percentLaser1 * (float)param.RampingStartPower2 / 100 : 100;
 
                 float startingPercentLaser_A2 = percentLaser2 * (float)param.RampingStartPower1 / 100 <= 100 ?
                                                 percentLaser2 * (float)param.RampingStartPower1 / 100 : 100;
-                float startingPercentLaser_B2 = percentLaser2 * (float)param.RampingStartPower3 / 100 <= 100 ?
-                                                percentLaser2 * (float)param.RampingStartPower3 / 100 : 100;
+                float startingPercentLaser_B2 = percentLaser2 * (float)param.RampingStartPower2 / 100 <= 100 ?
+                                                percentLaser2 * (float)param.RampingStartPower2 / 100 : 100;
 
 
                 float risingEdgePercentLaser1 = 0;
@@ -1585,7 +1599,7 @@ namespace WeldingCommon.Sequences {
 
                 Log.I($"[Arc Weld] Ramping Condition No({obj.No + 1}), Arc Length : {obj.Length}, Arc Angle : {obj.SweepAngle} " +
                  $"(Start_A:{param.RampingStartADist}%, Dist {FirstAngle}mm {(float)param.RampingStartAPower1}% -> {(float)param.RampingStartAPower2}%) " +
-                 $"(Start_B:{param.RampingStartDist}%, Dist {StartAngle}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower3}%) " +
+                 $"(Start_B:{param.RampingStartDist}%, Dist {StartAngle}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower2}%) " +
                  $"(End:{param.RampingEndDist}%, Dist {EndAngle}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower3}%)");
 
 
@@ -1844,21 +1858,20 @@ namespace WeldingCommon.Sequences {
 
                     float startingPercentLaser_A1 = percentLaser1 * (float)param.RampingStartPower1 / 100 <= 100 ?
                                                     percentLaser1 * (float)param.RampingStartPower1 / 100 : 100;
-                    float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower3 / 100 <= 100 ?
-                                                    percentLaser1 * (float)param.RampingStartPower3 / 100 : 100;
+                    float startingPercentLaser_B1 = percentLaser1 * (float)param.RampingStartPower2 / 100 <= 100 ?
+                                                    percentLaser1 * (float)param.RampingStartPower2 / 100 : 100;
 
                     float startingPercentLaser_A2 = percentLaser2 * (float)param.RampingStartPower1 / 100 <= 100 ?
                                                     percentLaser2 * (float)param.RampingStartPower1 / 100 : 100;
-                    float startingPercentLaser_B2 = percentLaser2 * (float)param.RampingStartPower3 / 100 <= 100 ?
-                                                    percentLaser2 * (float)param.RampingStartPower3 / 100 : 100;
-
+                    float startingPercentLaser_B2 = percentLaser2 * (float)param.RampingStartPower2 / 100 <= 100 ?
+                                                    percentLaser2 * (float)param.RampingStartPower2 / 100 : 100;
 
                     float risingEdgePercentLaser1 = 0;
                     float risingEdgePercentLaser2 = 0;
 
                     Log.I($"[Arc3P Weld] Ramping Condition No({obj.No + 1}), Arc Angle : {obj.SweepAngle} " +
                             $"(Start_A:{param.RampingStartADist}%, Dist {FirstAngle}mm {(float)param.RampingStartAPower1}% -> {(float)param.RampingStartAPower2}%) " +
-                            $"(Start_B:{param.RampingStartDist}%, Dist {StartAngle}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower3}%) " +
+                            $"(Start_B:{param.RampingStartDist}%, Dist {StartAngle}mm {(float)param.RampingStartPower1}% -> {(float)param.RampingStartPower2}%) " +
                             $"(End:{param.RampingEndDist}%, Dist {EndAngle}mm {(float)param.RampingEndPower1}% -> {(float)param.RampingEndPower3}%)");
 
 
@@ -2105,7 +2118,7 @@ namespace WeldingCommon.Sequences {
 
                     // A -> Start Power,    B -> End Power
                     float startingPercentLaser_A1 = Math.Min(percentLaser1 * (float)param.RampingStartPower1 / 100, 100);
-                    float startingPercentLaser_B1 = Math.Min(percentLaser1 * (float)param.RampingStartPower3 / 100, 100);
+                    float startingPercentLaser_B1 = Math.Min(percentLaser1 * (float)param.RampingStartPower2 / 100, 100);
 
                     // 2170은 Power를 사용하지 않는다.
                     float startingPercentLaser2 = 0;        // Math.Min(percentLaser2 * (float)param.RampingStartPower2 / 100, 100);