diff --git a/doc/log/commit_log_v0.9i.txt b/doc/log/commit_log_v0.9i.txt
index 49aba2c..db7df62 100644
--- a/doc/log/commit_log_v0.9i.txt
+++ b/doc/log/commit_log_v0.9i.txt
@@ -1,3 +1,29 @@
+----------------
+Date: 2015-03-29
+Author: Sonny Jeon
+Subject: Fix for limit pin reporting compile-option
+
+- The limit pin reporting wasn’t working correctly due to calling the
+wrong similarly-named function. Verified to be working now.
+
+
+----------------
+Date: 2015-03-29
+Author: Sonny Jeon
+Subject: Commit history, logo license, full-arc fix.
+
+- Commit history added to repo, as an easier way for people to see view
+the changes over time.
+
+- Grbl logo copyright license added. All rights reserved with regards
+to the Grbl logo.
+
+- G2/3 full circles would sometime not execute. The problem was due to
+numerical round-off of a trig calculation. Added a machine epsilon
+define to help detect and correct for this problem. Tested and should
+not effect general operation of arcs.
+
+
 ----------------
 Date: 2015-03-27
 Author: Sungeun Jeon
diff --git a/grbl/config.h b/grbl/config.h
index 878b341..3375e5c 100644
--- a/grbl/config.h
+++ b/grbl/config.h
@@ -79,7 +79,7 @@
 // Number of homing cycles performed after when the machine initially jogs to limit switches.
 // This help in preventing overshoot and should improve repeatability. This value should be one or 
 // greater.
-#define N_HOMING_LOCATE_CYCLE 2 // Integer (1-128)
+#define N_HOMING_LOCATE_CYCLE 1 // Integer (1-128)
 
 // After homing, Grbl will set by default the entire machine space into negative space, as is typical
 // for professional CNC machines, regardless of where the limit switches are located. Uncomment this 
diff --git a/grbl/defaults.h b/grbl/defaults.h
index f21b31e..41bcf0f 100644
--- a/grbl/defaults.h
+++ b/grbl/defaults.h
@@ -49,7 +49,6 @@
   #define DEFAULT_JUNCTION_DEVIATION 0.02 // mm
   #define DEFAULT_ARC_TOLERANCE 0.002 // mm
   #define DEFAULT_REPORT_INCHES 0 // false
-  #define DEFAULT_AUTO_START 1 // true
   #define DEFAULT_INVERT_ST_ENABLE 0 // false
   #define DEFAULT_INVERT_LIMIT_PINS 0 // false
   #define DEFAULT_SOFT_LIMIT_ENABLE 0 // false
@@ -87,10 +86,9 @@
   #define DEFAULT_DIRECTION_INVERT_MASK ((1<<Y_AXIS)|(1<<Z_AXIS))  
   #define DEFAULT_STEPPER_IDLE_LOCK_TIME 25 // msec (0-254, 255 keeps steppers enabled)
   #define DEFAULT_STATUS_REPORT_MASK ((BITFLAG_RT_STATUS_MACHINE_POSITION)|(BITFLAG_RT_STATUS_WORK_POSITION))
-  #define DEFAULT_JUNCTION_DEVIATION 0.02 // mm
+  #define DEFAULT_JUNCTION_DEVIATION 0.01 // mm
   #define DEFAULT_ARC_TOLERANCE 0.002 // mm
   #define DEFAULT_REPORT_INCHES 0 // true
-  #define DEFAULT_AUTO_START 1 // true
   #define DEFAULT_INVERT_ST_ENABLE 0 // false
   #define DEFAULT_INVERT_LIMIT_PINS 0 // false
   #define DEFAULT_SOFT_LIMIT_ENABLE 0 // false
@@ -129,10 +127,9 @@
   #define DEFAULT_DIRECTION_INVERT_MASK ((1<<Y_AXIS)|(1<<Z_AXIS))  
   #define DEFAULT_STEPPER_IDLE_LOCK_TIME 255 // msec (0-254, 255 keeps steppers enabled)
   #define DEFAULT_STATUS_REPORT_MASK ((BITFLAG_RT_STATUS_MACHINE_POSITION)|(BITFLAG_RT_STATUS_WORK_POSITION))
-  #define DEFAULT_JUNCTION_DEVIATION 0.05 // mm
+  #define DEFAULT_JUNCTION_DEVIATION 0.02 // mm
   #define DEFAULT_ARC_TOLERANCE 0.002 // mm
   #define DEFAULT_REPORT_INCHES 0 // false
-  #define DEFAULT_AUTO_START 1 // true
   #define DEFAULT_INVERT_ST_ENABLE 0 // false
   #define DEFAULT_INVERT_LIMIT_PINS 0 // false  
   #define DEFAULT_SOFT_LIMIT_ENABLE 0 // false
@@ -171,10 +168,9 @@
   #define DEFAULT_DIRECTION_INVERT_MASK ((1<<X_AXIS)|(1<<Z_AXIS))
   #define DEFAULT_STEPPER_IDLE_LOCK_TIME 255 // msec (0-254, 255 keeps steppers enabled)
   #define DEFAULT_STATUS_REPORT_MASK ((BITFLAG_RT_STATUS_MACHINE_POSITION)|(BITFLAG_RT_STATUS_WORK_POSITION))
-  #define DEFAULT_JUNCTION_DEVIATION 0.05 // mm
+  #define DEFAULT_JUNCTION_DEVIATION 0.02 // mm
   #define DEFAULT_ARC_TOLERANCE 0.002 // mm
   #define DEFAULT_REPORT_INCHES 0 // false
-  #define DEFAULT_AUTO_START 1 // true
   #define DEFAULT_INVERT_ST_ENABLE 0 // false
   #define DEFAULT_INVERT_LIMIT_PINS 0 // false  
   #define DEFAULT_SOFT_LIMIT_ENABLE 0 // false
@@ -187,6 +183,46 @@
   #define DEFAULT_HOMING_PULLOFF 1.0 // mm  
 #endif
 
+#ifdef DEFAULTS_SHAPEOKO_3
+  // Description: Shapeoko CNC mill with three NEMA 23 stepper motors, driven by CarbideMotion
+  #define MICROSTEPS_XY 8
+  #define STEP_REVS_XY 200
+  #define MM_PER_REV_XY (2.0*20) // 2mm belt pitch, 20 pulley teeth
+  #define MICROSTEPS_Z 8
+  #define STEP_REVS_Z 200
+  #define MM_PER_REV_Z (2.0*20) // 2mm belt pitch, 20 pulley teeth
+  #define DEFAULT_X_STEPS_PER_MM (MICROSTEPS_XY*STEP_REVS_XY/MM_PER_REV_XY)
+  #define DEFAULT_Y_STEPS_PER_MM (MICROSTEPS_XY*STEP_REVS_XY/MM_PER_REV_XY)
+  #define DEFAULT_Z_STEPS_PER_MM (MICROSTEPS_Z*STEP_REVS_Z/MM_PER_REV_Z)
+  #define DEFAULT_X_MAX_RATE 5000.0 // mm/min
+  #define DEFAULT_Y_MAX_RATE 5000.0 // mm/min
+  #define DEFAULT_Z_MAX_RATE 5000.0 // mm/min
+  #define DEFAULT_X_ACCELERATION (400.0*60*60) // 400*60*60 mm/min^2 = 400 mm/sec^2
+  #define DEFAULT_Y_ACCELERATION (400.0*60*60) // 400*60*60 mm/min^2 = 400 mm/sec^2
+  #define DEFAULT_Z_ACCELERATION (400.0*60*60) // 400*60*60 mm/min^2 = 400 mm/sec^2
+  #define DEFAULT_X_MAX_TRAVEL 425.0 // mm
+  #define DEFAULT_Y_MAX_TRAVEL 465.0 // mm
+  #define DEFAULT_Z_MAX_TRAVEL 80.0 // mm
+  #define DEFAULT_STEP_PULSE_MICROSECONDS 10
+  #define DEFAULT_STEPPING_INVERT_MASK 0
+  #define DEFAULT_DIRECTION_INVERT_MASK ((1<<X_AXIS)|(1<<Z_AXIS))
+  #define DEFAULT_STEPPER_IDLE_LOCK_TIME 255 // msec (0-254, 255 keeps steppers enabled)
+  #define DEFAULT_STATUS_REPORT_MASK 255 // All enabled
+  #define DEFAULT_JUNCTION_DEVIATION 0.02 // mm
+  #define DEFAULT_ARC_TOLERANCE 0.01 // mm
+  #define DEFAULT_REPORT_INCHES 0 // false
+  #define DEFAULT_INVERT_ST_ENABLE 0 // false
+  #define DEFAULT_INVERT_LIMIT_PINS 0 // false  
+  #define DEFAULT_SOFT_LIMIT_ENABLE 0 // false
+  #define DEFAULT_HARD_LIMIT_ENABLE 0  // false
+  #define DEFAULT_HOMING_ENABLE 0  // false
+  #define DEFAULT_HOMING_DIR_MASK 0 // move positive dir
+  #define DEFAULT_HOMING_FEED_RATE 100.0 // mm/min
+  #define DEFAULT_HOMING_SEEK_RATE 1000.0 // mm/min
+  #define DEFAULT_HOMING_DEBOUNCE_DELAY 25 // msec (0-65k)
+  #define DEFAULT_HOMING_PULLOFF 5.0 // mm  
+#endif
+
 #ifdef DEFAULTS_ZEN_TOOLWORKS_7x7
   // Description: Zen Toolworks 7x7 mill with three Shinano SST43D2121 65oz-in NEMA 17 stepper motors.
   // Leadscrew is different from some ZTW kits, where most are 1.25mm/rev rather than 8.0mm/rev here.
@@ -214,7 +250,6 @@
   #define DEFAULT_JUNCTION_DEVIATION 0.02 // mm
   #define DEFAULT_ARC_TOLERANCE 0.002 // mm
   #define DEFAULT_REPORT_INCHES 0 // false
-  #define DEFAULT_AUTO_START 1 // true
   #define DEFAULT_INVERT_ST_ENABLE 0 // false
   #define DEFAULT_INVERT_LIMIT_PINS 0 // false  
   #define DEFAULT_SOFT_LIMIT_ENABLE 0 // false
@@ -250,7 +285,6 @@
   #define DEFAULT_JUNCTION_DEVIATION 0.02 // mm
   #define DEFAULT_ARC_TOLERANCE 0.002 // mm
   #define DEFAULT_REPORT_INCHES 0 // false
-  #define DEFAULT_AUTO_START 1 // true
   #define DEFAULT_INVERT_ST_ENABLE 0 // false
   #define DEFAULT_INVERT_LIMIT_PINS 0 // false
   #define DEFAULT_SOFT_LIMIT_ENABLE 0 // false
@@ -286,7 +320,6 @@
   #define DEFAULT_JUNCTION_DEVIATION 0.02 // mm
   #define DEFAULT_ARC_TOLERANCE 0.002 // mm
   #define DEFAULT_REPORT_INCHES 0 // false
-  #define DEFAULT_AUTO_START 1 // true
   #define DEFAULT_INVERT_ST_ENABLE 0 // false
   #define DEFAULT_INVERT_LIMIT_PINS 0 // false
   #define DEFAULT_SOFT_LIMIT_ENABLE 0 // false
diff --git a/grbl/gcode.c b/grbl/gcode.c
index db72aa2..b3093a8 100644
--- a/grbl/gcode.c
+++ b/grbl/gcode.c
@@ -219,7 +219,7 @@ uint8_t gc_execute_line(char *line)
               else { gc_block.modal.distance = DISTANCE_MODE_INCREMENTAL; } // G91
             } else {
               word_bit = MODAL_GROUP_G4;
-              if (mantissa != 10) { FAIL(STATUS_GCODE_UNSUPPORTED_COMMAND); } // [G90.1 not supported]
+              if ((mantissa != 10) || (int_value == 90)) { FAIL(STATUS_GCODE_UNSUPPORTED_COMMAND); } // [G90.1 not supported]
               mantissa = 0; // Set to zero to indicate valid non-integer G command.
               // Otherwise, arc IJK incremental mode is default. G91.1 does nothing.
             }
@@ -1028,18 +1028,41 @@ uint8_t gc_execute_line(char *line)
   // refill and can only be resumed by the cycle start run-time command.
   gc_state.modal.program_flow = gc_block.modal.program_flow;
   if (gc_state.modal.program_flow) { 
-    protocol_buffer_synchronize(); // Finish all remaining buffered motions. Program paused when complete.
-
-    sys.suspend = true;
-    protocol_execute_realtime(); // Suspend execution. For both program pause or program end.
-  
-    // If complete, reset to reload defaults (G92.2,G54,G17,G90,G94,M48,G40,M5,M9). Otherwise,
-    // re-enable program flow after pause complete, where cycle start will resume the program.
-    if (gc_state.modal.program_flow == PROGRAM_FLOW_COMPLETED) { mc_reset(); }
-    else { gc_state.modal.program_flow = PROGRAM_FLOW_RUNNING; } // Resume from program pause.
+	protocol_buffer_synchronize(); // Sync and finish all remaining buffered motions before moving on.
+	if (gc_state.modal.program_flow == PROGRAM_FLOW_PAUSED) {
+	  if (sys.state != STATE_CHECK_MODE) {
+		bit_true_atomic(sys.rt_exec_state, EXEC_FEED_HOLD); // Use feed hold for program pause.
+		protocol_execute_realtime(); // Execute suspend.
+	  }
+	} else { // == PROGRAM_FLOW_COMPLETED
+	  // Upon program complete, only a subset of g-codes reset to certain defaults, according to 
+	  // LinuxCNC's program end descriptions and testing. Only modal groups [G-code 1,2,3,5,7,12]
+	  // and [M-code 7,8,9] reset to [G1,G17,G90,G94,G40,G54,M5,M9,M48]. The remaining modal groups
+	  // [G-code 4,6,8,10,13,14,15] and [M-code 4,5,6] and the modal words [F,S,T,H] do not reset.
+	  gc_state.modal.motion = MOTION_MODE_LINEAR;
+	  gc_state.modal.plane_select = PLANE_SELECT_XY;
+	  gc_state.modal.distance = DISTANCE_MODE_ABSOLUTE;
+	  gc_state.modal.feed_rate = FEED_RATE_MODE_UNITS_PER_MIN;
+	  // gc_state.modal.cutter_comp = CUTTER_COMP_DISABLE; // Not supported.
+	  gc_state.modal.coord_select = 0; // G54
+	  gc_state.modal.spindle = SPINDLE_DISABLE;
+	  gc_state.modal.coolant = COOLANT_DISABLE;
+	  // gc_state.modal.override = OVERRIDE_DISABLE; // Not supported.
+	  
+	  // Execute coordinate change and spindle/coolant stop.
+	  if (sys.state != STATE_CHECK_MODE) {
+		if (!(settings_read_coord_data(gc_state.modal.coord_select,coordinate_data))) { FAIL(STATUS_SETTING_READ_FAIL); } 
+		memcpy(gc_state.coord_system,coordinate_data,sizeof(coordinate_data));
+		spindle_stop();
+		coolant_stop();		
+	  }
+	  
+	  report_feedback_message(MESSAGE_PROGRAM_END);
+	}
+    gc_state.modal.program_flow = PROGRAM_FLOW_RUNNING; // Reset program flow.
   }
     
-  // TODO: % to denote start of program. Sets auto cycle start?
+  // TODO: % to denote start of program.
   return(STATUS_OK);
 }
         
diff --git a/grbl/grbl.h b/grbl/grbl.h
index cc7765d..eb361d0 100644
--- a/grbl/grbl.h
+++ b/grbl/grbl.h
@@ -23,7 +23,7 @@
 
 // Grbl versioning system
 #define GRBL_VERSION "0.9i"
-#define GRBL_VERSION_BUILD "20150329"
+#define GRBL_VERSION_BUILD "20150516"
 
 // Define standard libraries used by Grbl.
 #include <avr/io.h>
diff --git a/grbl/limits.c b/grbl/limits.c
index 83d93d9..4df6f1e 100644
--- a/grbl/limits.c
+++ b/grbl/limits.c
@@ -22,9 +22,13 @@
 #include "grbl.h"
 
 
-// Homing axis search distance multiplier. Computed by this value times the axis max travel.
-#define HOMING_AXIS_SEARCH_SCALAR  1.5 // Must be > 1 to ensure limit switch will be engaged.
-
+// Homing axis search distance multiplier. Computed by this value times the cycle travel.
+#ifndef HOMING_AXIS_SEARCH_SCALAR
+  #define HOMING_AXIS_SEARCH_SCALAR  1.5 // Must be > 1 to ensure limit switch will be engaged.
+#endif
+#ifndef HOMING_AXIS_LOCATE_SCALAR
+  #define HOMING_AXIS_LOCATE_SCALAR  5.0 // Must be > 1 to ensure limit switch is cleared.
+#endif
 
 void limits_init() 
 {
@@ -126,16 +130,12 @@ void limits_go_home(uint8_t cycle_mask)
 {
   if (sys.abort) { return; } // Block if system reset has been issued.
 
-  // Initialize homing in search mode to quickly engage the specified cycle_mask limit switches.
-  bool approach = true;
-  float homing_rate = settings.homing_seek_rate;
-  uint8_t invert_pin, idx;
+  // Initialize
   uint8_t n_cycle = (2*N_HOMING_LOCATE_CYCLE+1);
-  float target[N_AXIS];
-  
   uint8_t limit_pin[N_AXIS], step_pin[N_AXIS];
-
+  float target[N_AXIS];
   float max_travel = 0.0;
+  uint8_t idx;
   for (idx=0; idx<N_AXIS; idx++) {  
     // Initialize limit and step pin masks
     limit_pin[idx] = get_limit_pin_mask(idx);
@@ -149,32 +149,33 @@ void limits_go_home(uint8_t cycle_mask)
       // NOTE: settings.max_travel[] is stored as a negative value.
       max_travel = max(max_travel,(-HOMING_AXIS_SEARCH_SCALAR)*settings.max_travel[idx]);
     }
-
   }
-  
-  plan_reset(); // Reset planner buffer to zero planner current position and to clear previous motions.
-  plan_sync_position(); // Sync planner position to current machine position.
-  
+
+  // Set search mode with approach at seek rate to quickly engage the specified cycle_mask limit switches.
+  bool approach = true;
+  float homing_rate = settings.homing_seek_rate;
+
+  uint8_t limit_state, axislock, n_active_axis;
   do {
-    // Initialize invert_pin boolean based on approach and invert pin user setting.
-    if (bit_isfalse(settings.flags,BITFLAG_INVERT_LIMIT_PINS)) { invert_pin = approach; }
-    else { invert_pin = !approach; }
+
+    system_convert_array_steps_to_mpos(target,sys.position);
 
     // Initialize and declare variables needed for homing routine.
-    uint8_t axislock = 0;
-    uint8_t n_active_axis = 0;
-    system_convert_array_steps_to_mpos(target,sys.position);  
+    axislock = 0;
+    n_active_axis = 0;
     for (idx=0; idx<N_AXIS; idx++) {
       // Set target location for active axes and setup computation for homing rate.
-      if (bit_istrue(cycle_mask,bit(idx))) { 
+      if (bit_istrue(cycle_mask,bit(idx))) {
         n_active_axis++;
+        sys.position[idx] = 0;
         // Set target direction based on cycle mask and homing cycle approach state.
+        // NOTE: This happens to compile smaller than any other implementation tried.
         if (bit_istrue(settings.homing_dir_mask,bit(idx))) {
-          if (approach) { target[idx] -= max_travel; }
-          else { target[idx] += max_travel; }
+          if (approach) { target[idx] = -max_travel; }
+          else { target[idx] = max_travel; }
         } else { 
-          if (approach) { target[idx] += max_travel; }
-          else { target[idx] -= max_travel; }
+          if (approach) { target[idx] = max_travel; }
+          else { target[idx] = -max_travel; }
         }        
         // Apply axislock to the step port pins active in this cycle.
         axislock |= step_pin[idx];
@@ -183,10 +184,10 @@ void limits_go_home(uint8_t cycle_mask)
     }
     homing_rate *= sqrt(n_active_axis); // [sqrt(N_AXIS)] Adjust so individual axes all move at homing rate.
     sys.homing_axis_lock = axislock;
-  
-    // Perform homing cycle. Planner buffer should be empty, as required to initiate the homing cycle.
-    uint8_t limit_state;
+
+    plan_sync_position(); // Sync planner position to current machine position.
     
+    // Perform homing cycle. Planner buffer should be empty, as required to initiate the homing cycle.
     #ifdef USE_LINE_NUMBERS
       plan_buffer_line(target, homing_rate, false, HOMING_CYCLE_LINE_NUMBER); // Bypass mc_line(). Directly plan homing motion.
     #else
@@ -195,36 +196,53 @@ void limits_go_home(uint8_t cycle_mask)
     
     st_prep_buffer(); // Prep and fill segment buffer from newly planned block.
     st_wake_up(); // Initiate motion
-    do {
-      // Check limit state. Lock out cycle axes when they change.
-      limit_state = LIMIT_PIN;
-      if (invert_pin) { limit_state ^= LIMIT_MASK; }
-      for (idx=0; idx<N_AXIS; idx++) {
-        if (axislock & step_pin[idx]) {
-          if (limit_state & limit_pin[idx]) { axislock &= ~(step_pin[idx]); }
-        }
-      }
-      sys.homing_axis_lock = axislock;
-      st_prep_buffer(); // Check and prep segment buffer. NOTE: Should take no longer than 200us.
+	do {
+	  if (approach) {
+		// Check limit state. Lock out cycle axes when they change.
+		limit_state = LIMIT_PIN;
+		if (bit_isfalse(settings.flags,BITFLAG_INVERT_LIMIT_PINS)) { limit_state ^= LIMIT_MASK; }
+		for (idx=0; idx<N_AXIS; idx++) {
+		  if (axislock & step_pin[idx]) {
+			if (limit_state & limit_pin[idx]) { axislock &= ~(step_pin[idx]); }
+		  }
+		}
+		sys.homing_axis_lock = axislock;
+	  }
+
+	  st_prep_buffer(); // Check and prep segment buffer. NOTE: Should take no longer than 200us.
+
+	  // Exit routines: User abort homing and alarm upon safety door or no limit switch found.
+	  // No time to run protocol_execute_realtime() in this loop.
+	  if (sys.rt_exec_state & (EXEC_SAFETY_DOOR | EXEC_RESET | EXEC_CYCLE_STOP)) {
+		if ((sys.rt_exec_state & (EXEC_SAFETY_DOOR | EXEC_RESET)) || 
+		   ((approach) && (sys.rt_exec_state & EXEC_CYCLE_STOP))) { 
+		  mc_reset(); 
+		  protocol_execute_realtime();
+		  return;
+		} else {
+		  bit_false_atomic(sys.rt_exec_state,EXEC_CYCLE_STOP);
+		  break;
+		} 
+	  }
+
+	} while (STEP_MASK & axislock);
 
-      // Exit routines: User abort homing and alarm upon safety door or no limit switch found.
-      // No time to run protocol_execute_realtime() in this loop.
-      if (sys.rt_exec_state & (EXEC_SAFETY_DOOR | EXEC_RESET | EXEC_CYCLE_STOP)) { 
-        if (sys.rt_exec_state & (EXEC_SAFETY_DOOR | EXEC_CYCLE_STOP)) { mc_reset(); }  
-        protocol_execute_realtime();
-        return;
-      }
-    } while (STEP_MASK & axislock);
-    
     st_reset(); // Immediately force kill steppers and reset step segment buffer.
-    plan_reset(); // Reset planner buffer. Zero planner positions. Ensure homing motion is cleared.
-    plan_sync_position(); // Sync planner position to current machine position
+    plan_reset(); // Reset planner buffer to zero planner current position and to clear previous motions.
 
     delay_ms(settings.homing_debounce_delay); // Delay to allow transient dynamics to dissipate.
 
     // Reverse direction and reset homing rate for locate cycle(s).
-    homing_rate = settings.homing_feed_rate;
     approach = !approach;
+
+    // After first cycle, homing enters locating phase. Shorten search to pull-off distance.
+    if (approach) { 
+      max_travel = settings.homing_pulloff*HOMING_AXIS_LOCATE_SCALAR; 
+      homing_rate = settings.homing_feed_rate;
+    } else {
+      max_travel = settings.homing_pulloff;    
+      homing_rate = settings.homing_seek_rate;
+    }
     
   } while (n_cycle-- > 0);
     
@@ -242,13 +260,16 @@ void limits_go_home(uint8_t cycle_mask)
   for (idx=0; idx<N_AXIS; idx++) {
     // NOTE: settings.max_travel[] is stored as a negative value.
     if (cycle_mask & bit(idx)) {
-      set_axis_position = 0;     
-      #ifndef HOMING_FORCE_SET_ORIGIN
+      #ifdef HOMING_FORCE_SET_ORIGIN
+        set_axis_position = 0;
+      #else 
         if ( bit_istrue(settings.homing_dir_mask,bit(idx)) ) {
-          set_axis_position = lround(settings.max_travel[idx]*settings.steps_per_mm[idx]);
+          set_axis_position = lround((settings.max_travel[idx]+settings.homing_pulloff)*settings.steps_per_mm[idx]);
+        } else {
+          set_axis_position = lround(-settings.homing_pulloff*settings.steps_per_mm[idx]);
         }
       #endif
-
+      
       #ifdef COREXY
         if (idx==X_AXIS) { 
           off_axis_position = (sys.position[B_MOTOR] - sys.position[A_MOTOR])/2;
@@ -268,39 +289,6 @@ void limits_go_home(uint8_t cycle_mask)
     }
   }
   plan_sync_position(); // Sync planner position to homed machine position.
-
-  // Set pull-off motion target. Seperated from above loop if target is dependent on sys.position.
-  if (settings.homing_pulloff > 0.0) {
-    for (idx=0; idx<N_AXIS; idx++) {
-      if (cycle_mask & bit(idx)) {
-        #ifdef HOMING_FORCE_SET_ORIGIN
-          target[idx] = settings.homing_pulloff;  
-          if ( bit_isfalse(settings.homing_dir_mask,bit(idx)) ) { target[idx] = -target[idx]; }     
-        #else
-          if ( bit_istrue(settings.homing_dir_mask,bit(idx)) ) {
-            target[idx] = settings.homing_pulloff+settings.max_travel[idx];
-          } else {
-            target[idx] = -settings.homing_pulloff;
-          }
-        #endif      
-      } else {
-        // Non-active cycle axis. Set target to not move during pull-off. 
-        target[idx] = system_convert_axis_steps_to_mpos(sys.position, idx);
-      }
-    }      
-    #ifdef USE_LINE_NUMBERS
-      plan_buffer_line(target, settings.homing_seek_rate, false, HOMING_CYCLE_LINE_NUMBER); // Bypass mc_line(). Directly plan motion.
-    #else
-      plan_buffer_line(target, settings.homing_seek_rate, false); // Bypass mc_line(). Directly plan motion.
-    #endif
-  
-    // Initiate pull-off using main motion control routines. 
-    // TODO : Clean up state routines so that this motion still shows homing state.
-    sys.state = STATE_IDLE;
-    bit_true_atomic(sys.rt_exec_state, EXEC_CYCLE_START);
-    protocol_execute_realtime();
-    protocol_buffer_synchronize(); // Complete pull-off motion.
-  }
   
   // Set system state to homing before returning. 
   sys.state = STATE_HOMING; 
diff --git a/grbl/report.c b/grbl/report.c
index 001c02d..f32203a 100644
--- a/grbl/report.c
+++ b/grbl/report.c
@@ -136,6 +136,8 @@ void report_feedback_message(uint8_t message_code)
     printPgmString(PSTR("Disabled")); break; 
     case MESSAGE_SAFETY_DOOR_AJAR:
     printPgmString(PSTR("Check Door")); break;
+    case MESSAGE_PROGRAM_END:
+    printPgmString(PSTR("Pgm End")); break;
   }
   printPgmString(PSTR("]\r\n"));
 }
@@ -420,7 +422,7 @@ void report_realtime_status()
   // the system power on location (0,0,0) and work coordinate position (G54 and G92 applied). Eventually
   // to be added are distance to go on block, processed block id, and feed rate. Also a settings bitmask
   // for a user to select the desired real-time data.
-  uint8_t i;
+  uint8_t idx;
   int32_t current_position[N_AXIS]; // Copy current state of the system position variable
   memcpy(current_position,sys.position,sizeof(sys.position));
   float print_position[N_AXIS];
@@ -445,21 +447,21 @@ void report_realtime_status()
   // Report machine position
   if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_MACHINE_POSITION)) {
     printPgmString(PSTR(",MPos:")); 
-    for (i=0; i< N_AXIS; i++) {
-      printFloat_CoordValue(print_position[i]);
-      if (i < (N_AXIS-1)) { printPgmString(PSTR(",")); }
+    for (idx=0; idx< N_AXIS; idx++) {
+      printFloat_CoordValue(print_position[idx]);
+      if (idx < (N_AXIS-1)) { printPgmString(PSTR(",")); }
     }
   }
   
   // Report work position
   if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_WORK_POSITION)) {
     printPgmString(PSTR(",WPos:")); 
-    for (i=0; i< N_AXIS; i++) {
+    for (idx=0; idx< N_AXIS; idx++) {
       // Apply work coordinate offsets and tool length offset to current position.
-      print_position[i] -= gc_state.coord_system[i]+gc_state.coord_offset[i];
-      if (i == TOOL_LENGTH_OFFSET_AXIS) { print_position[i] -= gc_state.tool_length_offset; }    
-      printFloat_CoordValue(print_position[i]);
-      if (i < (N_AXIS-1)) { printPgmString(PSTR(",")); }
+      print_position[idx] -= gc_state.coord_system[idx]+gc_state.coord_offset[idx];
+      if (idx == TOOL_LENGTH_OFFSET_AXIS) { print_position[idx] -= gc_state.tool_length_offset; }    
+      printFloat_CoordValue(print_position[idx]);
+      if (idx < (N_AXIS-1)) { printPgmString(PSTR(",")); }
     }
   }
         
@@ -492,14 +494,13 @@ void report_realtime_status()
     printFloat_RateValue(st_get_realtime_rate());
   #endif    
   
-  #ifdef REPORT_LIMIT_PIN_STATE
+  if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_LIMIT_PINS)) {
     printPgmString(PSTR(",Lim:"));
-    uint8_t idx;
     for (idx=0; idx<N_AXIS; idx++) {
-      if (LIMIT_PIN & get_limit_pin_mask(idx)) { printString(PSTR("1")); }
-      else { printString(PSTR("0")); }
+      if (LIMIT_PIN & get_limit_pin_mask(idx)) { printPgmString(PSTR("1")); }
+      else { printPgmString(PSTR("0")); }
     }
-  #endif
+  }
   
   #ifdef REPORT_CONTROL_PIN_STATE 
     printPgmString(PSTR(",Ctl:"));
diff --git a/grbl/report.h b/grbl/report.h
index 82593cf..7126085 100644
--- a/grbl/report.h
+++ b/grbl/report.h
@@ -68,6 +68,7 @@
 #define MESSAGE_ENABLED 4
 #define MESSAGE_DISABLED 5
 #define MESSAGE_SAFETY_DOOR_AJAR 6
+#define MESSAGE_PROGRAM_END 7
 
 // Prints system status messages.
 void report_status_message(uint8_t status_code);
diff --git a/grbl/settings.h b/grbl/settings.h
index 5090824..6f215e0 100644
--- a/grbl/settings.h
+++ b/grbl/settings.h
@@ -44,6 +44,7 @@
 #define BITFLAG_RT_STATUS_WORK_POSITION     bit(1)
 #define BITFLAG_RT_STATUS_PLANNER_BUFFER    bit(2)
 #define BITFLAG_RT_STATUS_SERIAL_RX         bit(3)
+#define BITFLAG_RT_STATUS_LIMIT_PINS        bit(4)
 
 // Define EEPROM memory address location values for Grbl settings and parameters
 // NOTE: The Atmega328p has 1KB EEPROM. The upper half is reserved for parameters and
diff --git a/grbl/stepper.c b/grbl/stepper.c
index 155b805..614a4c8 100644
--- a/grbl/stepper.c
+++ b/grbl/stepper.c
@@ -324,11 +324,8 @@ ISR(TIMER1_COMPA_vect)
         st.exec_block = &st_block_buffer[st.exec_block_index];
         
         // Initialize Bresenham line and distance counters
-        st.counter_x = (st.exec_block->step_event_count >> 1);
-        st.counter_y = st.counter_x;
-        st.counter_z = st.counter_x;        
+        st.counter_x = st.counter_y = st.counter_z = (st.exec_block->step_event_count >> 1);
       }
-
       st.dir_outbits = st.exec_block->direction_bits ^ dir_port_invert_mask; 
 
       #ifdef ADAPTIVE_MULTI_AXIS_STEP_SMOOTHING
diff --git a/grbl/system.h b/grbl/system.h
index a74f029..94f2143 100644
--- a/grbl/system.h
+++ b/grbl/system.h
@@ -71,7 +71,7 @@
 typedef struct {
   uint8_t abort;                 // System abort flag. Forces exit back to main loop for reset.
   uint8_t state;                 // Tracks the current state of Grbl.
-  uint8_t suspend;               // System suspend flag. Allows only realtime commands. Used primarily for holds.
+  uint8_t suspend;               // System suspend bitflag variable that manages holds, cancels, and safety door.
 
   volatile uint8_t rt_exec_state;  // Global realtime executor bitflag variable for state management. See EXEC bitmasks.
   volatile uint8_t rt_exec_alarm;  // Global realtime executor bitflag variable for setting various alarms.