var gFormat = createFormat({decimals:0});

var xyzFormat = createFormat({decimals:(unit == MM ? 3 : 4)});

var feedFormat = createFormat({decimals:(unit == MM ? 3 : 4), scale:1.0 / 60.0}); // feed is mm/s or in/s

var rpmFormat = createFormat({decimals:0});

var abcFormat = createFormat({decimals:3, scale:DEG});

var secFormat = createFormat({decimals:2}); // seconds

 

var xOutput = createOutputVariable({control:CONTROL_FORCE}, xyzFormat);

var yOutput = createOutputVariable({control:CONTROL_FORCE}, xyzFormat);

var zOutput = createOutputVariable({control:CONTROL_FORCE}, xyzFormat);

var aOutput = createOutputVariable({control:CONTROL_FORCE}, abcFormat);

var bOutput = createOutputVariable({control:CONTROL_FORCE}, abcFormat);

var cOutput = createOutputVariable({control:CONTROL_FORCE}, abcFormat);

var feedZOutput = createOutputVariable({control:CONTROL_FORCE}, feedFormat);

var feedOutput = createOutputVariable({}, feedFormat);

var gMotionModal = createOutputVariable({}, gFormat); // modal group 1 // G0-G3, ...

 

var settings = {

    compensateToolLength  : true // specifies if tool length should be added to the pivot distance for nonTCP rotary heads

  supportsInverseTimeFeed: false // this postprocessor does not support inverse time feedrates

 

var maxZFeed = toPreciseUnit(180, IN); // max Z feed used for VS command

function defineMachine() {

  var headOffset = 0;

  var useTCP = false;

  if (!receivedMachineConfiguration) { // note: setup your machine here

    var aAxis = createAxis({coordinate:1, table:false, axis:[0, -1, 0], range:[-120, 120], offset:[0, 0, headOffset], resolution:15, preference:0, tcp:useTCP}); // 15 deg steps

    var cAxis = createAxis({coordinate:2, table:false, axis:[0, 0, -1], range:[-360, 360], resolution:15, preference:1, tcp:useTCP}); // 15 deg steps

    machineConfiguration = new MachineConfiguration(aAxis, cAxis);

 

    if (receivedMachineConfiguration) {

 

  if (!receivedMachineConfiguration) {

    if (machineConfiguration.isHeadConfiguration()) {

 

    var performRewinds = false; // set to true to enable the rewind/reconfigure logic

    if (performRewinds) {

      var stockExpansion = new Vector(toPreciseUnit(0.1, IN), toPreciseUnit(0.1, IN), toPreciseUnit(0.1, IN)); // expand stock XYZ values

 

    if (machineConfiguration.isMultiAxisConfiguration()) {

 

 

function onOpen() {

  if (typeof defineMachine == "function" && getProperty("fifthAxis")) {

 

  writeBlock(unit == MM ? "IF %(25)=0 THEN GOTO UNIT_ERROR" : "IF %(25)=1 THEN GOTO UNIT_ERROR");

 

  var tools = getToolTable();

  if (tools.getNumberOfTools() > 1) {

 

  var workpiece = getWorkpiece();

  writeBlock("&PWMaterial = " + xyzFormat.format(workpiece.upper.z - workpiece.lower.z));

  var partDatum = workpiece.lower.z;

  if (partDatum >= 0) {

  } else {

 

function positionABC(abc, force) {

  if (!machineConfiguration.isMultiAxisConfiguration()) {

  var a = aOutput.format(abc.x);

  var b = bOutput.format(abc.y);

  var c = cOutput.format(abc.z);

  if (a || b || c) {

      + conditional(machineConfiguration.isMachineCoordinate(0), " A" + abcFormat.format(abc.x))

      + conditional(machineConfiguration.isMachineCoordinate(1), " B" + abcFormat.format(abc.y))

      + conditional(machineConfiguration.isMachineCoordinate(2), " C" + abcFormat.format(abc.z))

 

function onSection() {

  var forceSectionRestart = optionalSection && !currentSection.isOptional();

  var insertToolCall = isToolChangeNeeded("number") || forceSectionRestart;

 

 

  if (getProperty("showNotes")) {

 

  var abc = defineWorkPlane(currentSection, true);

 

 

 

  var initialPosition = getFramePosition(currentSection.getInitialPosition());

  var motionCode = highFeedMapping == HIGH_FEED_MAP_ANY ? "M3" : "J3";

  if (xyzFormat.getResultingValue(getCurrentPosition().z) < xyzFormat.getResultingValue(initialPosition.z)) {

 

function onCommand(command) {

  switch (command) {

  case COMMAND_COOLANT_OFF:

  case COMMAND_COOLANT_ON:

  case COMMAND_STOP:

  case COMMAND_START_SPINDLE:

    var minSpeed = 5000;

    if (spindleSpeed < minSpeed) {

  case COMMAND_LOAD_TOOL:

    machineSimulation({/*x:toPreciseUnit(200, MM), y:toPreciseUnit(200, MM), coordinates:MACHINE,*/ mode:TOOLCHANGE}); // move machineSimulation to a tool change position

    writeBlock("&Tool = " + tool.number);

    if (tool.comment) {

      writeBlock("&ToolName = " + tool.comment);

  case COMMAND_UNLOCK_MULTI_AXIS:

  case COMMAND_LOCK_MULTI_AXIS:

  case COMMAND_STOP_SPINDLE:

  case COMMAND_SPINDLE_CLOCKWISE:

  case COMMAND_SPINDLE_COUNTERCLOCKWISE:

  case COMMAND_BREAK_CONTROL:

 

 

function onDwell(seconds) {

  var maxValue = 99999;

  if (seconds > maxValue) {

 

function onSpindleSpeed(spindleSpeed) {

 

function writeRetract() {

 

function writeFeed(feed, moveInZ) {

  if (moveInZ) { // limit feed if moving in Z

  var f = feedOutput.format(feed);

  if (f) {

 

function onRapid(_x, _y, _z) {

  var x = xOutput.format(_x);

  var y = yOutput.format(_y);

  var z = zOutput.format(_z);

  if (x || y || z) {

 

function onLinear(_x, _y, _z, feed) {

  var x = xOutput.format(_x);

  var y = yOutput.format(_y);

  var z = zOutput.format(_z);

  if (x || y || z) {

 

function onRapid5D(_x, _y, _z, _a, _b, _c) {

 

function onLinear5D(_x, _y, _z, _a, _b, _c, feed) {

 

function onCircular(clockwise, cx, cy, cz, x, y, z, feed) {

  var start = getCurrentPosition();

 

  if (isHelical()) {

 

  switch (getCircularPlane()) {

  case PLANE_XY:

 

function onSectionEnd() {

 

function onClose() {

 

var receivedMachineConfiguration;

var tcp = {isSupportedByControl:getSetting("supportsTCP", true), isSupportedByMachine:false, isSupportedByOperation:false};

var state = {

  mainState               : true // specifies the current context of the state (true = main, false = optional)

var validateLengthCompensation = getSetting("outputToolLengthCompensation", true); // disable validation when outputToolLengthCompensation is disabled

var multiAxisFeedrate;

var sequenceNumber;

var optionalSection = false;

var currentWorkOffset;

var forceSpindleSpeed = false;

var operationNeedsSafeStart = false; // used to convert blocks to optional for safeStartAllOperations

 

function activateMachine() {

  if (!machineConfiguration.isMachineCoordinate(0) && (typeof aOutput != "undefined")) {

  if (!machineConfiguration.isMachineCoordinate(1) && (typeof bOutput != "undefined")) {

  if (!machineConfiguration.isMachineCoordinate(2) && (typeof cOutput != "undefined")) {

 

 

  if (!machineConfiguration.isMultiAxisConfiguration()) {

 

  var axes = [machineConfiguration.getAxisU(), machineConfiguration.getAxisV(), machineConfiguration.getAxisW()];

  tcp.isSupportedByMachine = axes.some(function(axis) {return axis.isEnabled() && axis.isTCPEnabled();}); // true if TCP is enabled on any rotary axis

 

  var mode = machineConfiguration.getMultiAxisFeedrateMode();

  var type = mode == FEED_INVERSE_TIME ? machineConfiguration.getMultiAxisFeedrateInverseTimeUnits() :

 

  if (receivedMachineConfiguration && machineConfiguration.performRewinds()) {

  if (typeof safeRetractDistance == "number" && getProperty("safeRetractDistance") != undefined && getProperty("safeRetractDistance") != 0) {

 

  if (revision >= 50294)  {

 

  if (machineConfiguration.isHeadConfiguration() && getSetting("workPlaneMethod.compensateToolLength", false)) {

    for (var i = 0; i < getNumberOfSections(); ++i) {

      var section = getSection(i);

      if (section.isMultiAxis()) {

  } else {

 

function getBodyLength(tool) {

  for (var i = 0; i < getNumberOfSections(); ++i) {

    var section = getSection(i);

    if (tool.number == section.getTool().number) {

      if (section.hasParameter("operation:tool_assemblyGaugeLength")) { // For Fusion

        return section.getParameter("operation:tool_assemblyGaugeLength", tool.bodyLength + tool.holderLength);

      } else  { // Legacy products

        return section.getParameter("operation:tool_overallLength", tool.bodyLength + tool.holderLength);

  return tool.bodyLength + tool.holderLength;

 

function getFeed(f) {

  if (getProperty("useG95")) {

    return feedOutput.format(f / spindleSpeed); // use feed value

  if (typeof activeMovements != "undefined" && activeMovements) {

    var feedContext = activeMovements[movement];

    if (feedContext != undefined) {

      if (!feedFormat.areDifferent(feedContext.feed, f)) {

        if (feedContext.id == currentFeedId) {

          return ""; // nothing has changed

        return settings.parametricFeeds.feedOutputVariable + (settings.parametricFeeds.firstFeedParameter + feedContext.id);

  return feedOutput.format(f); // use feed value

 

function validateCommonParameters() {

  for (var i = 0; i < getNumberOfSections(); ++i) {

    var section = getSection(i);

    if (getSection(0).workOffset == 0 && section.workOffset > 0) {

      if (!(typeof wcsDefinitions != "undefined" && wcsDefinitions.useZeroOffset)) {

    if (section.isMultiAxis()) {

      if (!section.isOptimizedForMachine() &&

      if (machineConfiguration.getMultiAxisFeedrateMode() == FEED_INVERSE_TIME && !getSetting("supportsInverseTimeFeed", true)) {

      if (getSetting("supportsToolVectorOutput", false) && !tcp.isSupportedByControl) {

        error(localize("Incompatible postprocessor settings detected." + EOL +

  if (!tcp.isSupportedByControl && tcp.isSupportedByMachine) {

  if (getProperty("safePositionMethod") == "clearanceHeight") {

    var msg = "-Attention- Property 'Safe Retracts' is set to 'Clearance Height'." + EOL +

      "Ensure the clearance height will clear the part and or fixtures." + EOL +

 

function validateToolData() {

  var _default = 99999;

  var _maximumSpindleRPM = machineConfiguration.getMaximumSpindleSpeed() > 0 ? machineConfiguration.getMaximumSpindleSpeed() :

  var _maximumToolNumber = machineConfiguration.isReceived() && machineConfiguration.getNumberOfTools() > 0 ? machineConfiguration.getNumberOfTools() :

  var _maximumToolLengthOffset = settings.maximumToolLengthOffset == undefined ? _default : settings.maximumToolLengthOffset;

  var _maximumToolDiameterOffset = settings.maximumToolDiameterOffset == undefined ? _default : settings.maximumToolDiameterOffset;

 

  var header = ["Detected maximum values are out of range.", "Maximum values:"];

  var warnings = {

    toolNumber    : {msg:"Tool number value exceeds the maximum value for tool: " + EOL, max:" Tool number: " + _maximumToolNumber, values:[]},

    lengthOffset  : {msg:"Tool length offset value exceeds the maximum value for tool: " + EOL, max:" Tool length offset: " + _maximumToolLengthOffset, values:[]},

    diameterOffset: {msg:"Tool diameter offset value exceeds the maximum value for tool: " + EOL, max:" Tool diameter offset: " + _maximumToolDiameterOffset, values:[]},

    spindleSpeed  : {msg:"Spindle speed exceeds the maximum value for operation: " + EOL, max:" Spindle speed: " + _maximumSpindleRPM, values:[]}

 

  var toolIds = [];

  for (var i = 0; i < getNumberOfSections(); ++i) {

    var section = getSection(i);

    if (toolIds.indexOf(section.getTool().getToolId()) === -1) { // loops only through sections which have a different tool ID

      var toolNumber = section.getTool().number;

      var lengthOffset = section.getTool().lengthOffset;

      var diameterOffset = section.getTool().diameterOffset;

      var comment = section.getParameter("operation-comment", "");

 

      if (toolNumber > _maximumToolNumber && !getProperty("toolAsName")) {

      if (lengthOffset > _maximumToolLengthOffset) {

        warnings.lengthOffset.values.push(SP + "Tool " + toolNumber + " (" + comment + "," + " Length offset: " + lengthOffset + ")" + EOL);

      if (diameterOffset > _maximumToolDiameterOffset) {

        warnings.diameterOffset.values.push(SP + "Tool " + toolNumber + " (" + comment + "," + " Diameter offset: " + diameterOffset + ")" + EOL);

 

    var ramp = section.getMovements() & ((1 << MOVEMENT_RAMP) | (1 << MOVEMENT_RAMP_ZIG_ZAG) | (1 << MOVEMENT_RAMP_PROFILE) | (1 << MOVEMENT_RAMP_HELIX));

    var _sectionSpindleSpeed = Math.max(section.getTool().spindleRPM, ramp ? section.getTool().rampingSpindleRPM : 0, 0);

    if (_sectionSpindleSpeed > _maximumSpindleRPM) {

      warnings.spindleSpeed.values.push(SP + section.getParameter("operation-comment", "") + " (" + _sectionSpindleSpeed + " RPM" + ")" + EOL);

 

  warnings.toolNumber.values.sort(function(a, b) {return a - b;});

  warnings.lengthOffset.values.sort(function(a, b) {return a.localeCompare(b);});

  warnings.diameterOffset.values.sort(function(a, b) {return a.localeCompare(b);});

 

  var warningMessages = [];

  for (var key in warnings) {

    if (warnings[key].values != "") {

  if (warningMessages.length != 0) {

 

function forceFeed() {

 

function forceXYZ() {

 

function forceABC() {

 

function forceAny() {

 

function writeBlock() {

  var text = formatWords(arguments);

  if (!text) {

  var prefix = getSetting("sequenceNumberPrefix", "N");

  var suffix = getSetting("writeBlockSuffix", "");

  if ((optionalSection || skipBlocks) && !getSetting("supportsOptionalBlocks", true)) {

  if (getProperty("showSequenceNumbers") == "true") {

    if (sequenceNumber == undefined || sequenceNumber >= settings.maximumSequenceNumber) {

    if (optionalSection || skipBlocks) {

    } else {

  } else {

    if (optionalSection || skipBlocks) {

    } else {

 

function formatComment(text) {

  var prefix = settings.comments.prefix;

  var suffix = settings.comments.suffix;

  var _permittedCommentChars = settings.comments.permittedCommentChars == undefined ? "" : settings.comments.permittedCommentChars;

  switch (settings.comments.outputFormat) {

  case "upperCase":

  case "lowerCase":

  case "ignoreCase":

  if (_permittedCommentChars != "") {

  return text != "" ?  prefix + text + suffix : "";

 

function writeComment(text) {

  if (!text) {

  var comments = String(text).split(EOL);

  for (comment in comments) {

    var _comment = formatComment(comments[comment]);

    if (_comment) {

      if (getSetting("comments.showSequenceNumbers", false)) {

      } else {

 

function onComment(text) {

 

function writeToolBlock() {

  var show = getProperty("showSequenceNumbers");

  setProperty("showSequenceNumbers", (show == "true" || show == "toolChange") ? "true" : "false");

  machineSimulation({/*x:toPreciseUnit(200, MM), y:toPreciseUnit(200, MM), coordinates:MACHINE,*/ mode:TOOLCHANGE}); // move machineSimulation to a tool change position

 

var skipBlocks = false;

var initialState = JSON.parse(JSON.stringify(state)); // save initial state

var optionalState = JSON.parse(JSON.stringify(state));

var saveCurrentSectionId = undefined;

function writeStartBlocks(isRequired, code) {

  var saveSkipBlocks = skipBlocks;

  var saveMainState = state; // save main state

 

  if (!isRequired) {

    if (!getProperty("safeStartAllOperations", false)) {

    if (saveCurrentSectionId != getCurrentSectionId()) {

 

 

var pendingRadiusCompensation = -1;

function onRadiusCompensation() {

  if (pendingRadiusCompensation >= 0 && !getSetting("supportsRadiusCompensation", true)) {

 

function onPassThrough(text) {

  var commands = String(text).split(",");

  for (text in commands) {

 

function forceModals() {

  if (arguments.length == 0) { // reset all modal variables listed below

    if (typeof gMotionModal != "undefined") {

    if (typeof gPlaneModal != "undefined") {

    if (typeof gAbsIncModal != "undefined") {

    if (typeof gFeedModeModal != "undefined") {

  } else {

    for (var i in arguments) {

 

function getSetting(setting, defaultValue) {

  var result = defaultValue;

  var keys = setting.split(".");

  var obj = settings;

  for (var i in keys) {

    if (obj[keys[i]] != undefined) { // setting does exist

      if (typeof [keys[i]] === "object") {

    } else { // setting does not exist, use default value

      if (defaultValue != undefined) {

      } else {

        error("Setting '" + keys[i] + "' has no default value and/or does not exist.");

        return undefined;

  return result;

 

function getForwardDirection(_section) {

  var forward = undefined;

  var _optimizeType = settings.workPlaneMethod && settings.workPlaneMethod.optimizeType;

  if (_section.isMultiAxis()) {

  } else if (!getSetting("workPlaneMethod.useTiltedWorkplane", false) && machineConfiguration.isMultiAxisConfiguration()) {

    if (_optimizeType == undefined) {

      var saveRotation = getRotation();

    } else {

      var abc = getWorkPlaneMachineABC(_section, false);

      var forceAdjustment = settings.workPlaneMethod.optimizeType == OPTIMIZE_TABLES || settings.workPlaneMethod.optimizeType == OPTIMIZE_BOTH;

  } else {

  return forward;

 

function getRetractParameters() {

  var _arguments = typeof arguments[0] === "object" ? arguments[0].axes : arguments;

  var singleLine = arguments[0].singleLine == undefined ? true : arguments[0].singleLine;

  var words = []; // store all retracted axes in an array

  var retractAxes = new Array(false, false, false);

  var method = getProperty("safePositionMethod", "undefined");

  if (method == "clearanceHeight") {

    if (!is3D()) {

    return undefined;

  for (i in _arguments) {

  if ((retractAxes[0] || retractAxes[1]) && !state.retractedZ) { // retract Z first before moving to X/Y home

    return undefined;

  if (retractAxes[0] || retractAxes[1]) {

  if (retractAxes[2]) {

  var useZeroValues = (settings.retract.useZeroValues && settings.retract.useZeroValues.indexOf(method) != -1);

  var _xHome = machineConfiguration.hasHomePositionX() && !useZeroValues ? machineConfiguration.getHomePositionX() : toPreciseUnit(0, MM);

  var _yHome = machineConfiguration.hasHomePositionY() && !useZeroValues ? machineConfiguration.getHomePositionY() : toPreciseUnit(0, MM);

  var _zHome = machineConfiguration.getRetractPlane() != 0 && !useZeroValues ? machineConfiguration.getRetractPlane() : toPreciseUnit(0, MM);

  for (var i = 0; i < _arguments.length; ++i) {

    switch (_arguments[i]) {

    case X:

      if (!state.retractedX) {

        words.push("X" + xyzFormat.format(_xHome));

    case Y:

      if (!state.retractedY) {

        words.push("Y" + xyzFormat.format(_yHome));

    case Z:

      if (!state.retractedZ) {

        words.push("Z" + xyzFormat.format(_zHome));

      return undefined;

  return {

 

function subprogramsAreSupported() {

  return typeof subprogramState != "undefined";

 

var debugSimulation = false; // enable to output debug information for connection move support in the NC program

var TCPON = "TCP ON";

var TCPOFF = "TCP OFF";

var TWPON = "TWP ON";

var TWPOFF = "TWP OFF";

var TOOLCHANGE = "TOOL CHANGE";

var RETRACTTOOLAXIS = "RETRACT TOOLAXIS";

var WORK = "WORK CS";

var MACHINE = "MACHINE CS";

var MIN = "MIN";

var MAX = "MAX";

var WARNING_NON_RANGE = [0, 1, 2];

var isTwpOn;

var isTcpOn;

function machineSimulation(parameters) {

  if (revision < 50198 || skipBlocks) {

    var range = axis.getRange();

    if (range.isNonRange()) {

      var axisLetters = ["X", "Y", "Z"];

      var warningMessage = subst(localize("An attempt was made to move the \"%1\" axis to its MIN/MAX limits during machine simulation, but its range is set to \"unlimited\"." + EOL +

      return undefined;

    return limit == MIN ? range.minimum : range.maximum;

  var x = (isNaN(parameters.x) && parameters.x) ? getAxisLimit(machineConfiguration.getAxisX(), parameters.x) : parameters.x;

  var y = (isNaN(parameters.y) && parameters.y) ? getAxisLimit(machineConfiguration.getAxisY(), parameters.y) : parameters.y;

  var z = (isNaN(parameters.z) && parameters.z) ? getAxisLimit(machineConfiguration.getAxisZ(), parameters.z) : parameters.z;

  var rotaryAxesErrorMessage = localize("Invalid argument for rotary axes passed to the machineSimulation function. Only numerical values are supported.");

  var a = (isNaN(parameters.a) && parameters.a) ? error(rotaryAxesErrorMessage) : parameters.a;

  var b = (isNaN(parameters.b) && parameters.b) ? error(rotaryAxesErrorMessage) : parameters.b;

  var c = (isNaN(parameters.c) && parameters.c) ? error(rotaryAxesErrorMessage) : parameters.c;

  var coordinates = parameters.coordinates;

  var eulerAngles = parameters.eulerAngles;

  var feed = parameters.feed;

  if (feed === undefined && typeof gMotionModal !== "undefined") {

  var mode  = parameters.mode;

  var performToolChange = mode == TOOLCHANGE;

  if (mode !== undefined && ![TCPON, TCPOFF, TWPON, TWPOFF, TOOLCHANGE, RETRACTTOOLAXIS].includes(mode)) {

 

  var enableTCP = isTcpOn;

  var enableTWP = isTwpOn;

  if (mode === TCPON || mode === TCPOFF) {

  } else if (mode === TWPON || mode === TWPOFF) {

  } else {

    enableTCP = typeof state !== "undefined" && state.tcpIsActive;

    enableTWP = typeof state !== "undefined" && state.twpIsActive;

  var disableTCP = !enableTCP;

  var disableTWP = !enableTWP;

  if (disableTWP) {

  if (disableTCP) {

  if (enableTCP) {

  if (enableTWP) {

    if (settings.workPlaneMethod.eulerConvention == undefined) {

    } else if (eulerAngles) {

  if (mode == RETRACTTOOLAXIS) {

 

  if (debugSimulation) {

    writeln("  DEBUG" + JSON.stringify(parameters));

    writeln("  DEBUG" + JSON.stringify({isTwpOn:isTwpOn, isTcpOn:isTcpOn, feed:feed}));

 

  if (x !== undefined || y !== undefined || z !== undefined || a !== undefined || b !== undefined || c !== undefined) {

    if (x !== undefined) {simulation.setTargetX(x);}

    if (y !== undefined) {simulation.setTargetY(y);}

    if (z !== undefined) {simulation.setTargetZ(z);}

    if (a !== undefined) {simulation.setTargetA(a);}

    if (b !== undefined) {simulation.setTargetB(b);}

    if (c !== undefined) {simulation.setTargetC(c);}

 

    if (feed != undefined && feed) {

      simulation.setFeedrate(typeof feed == "number" ? feed : feedOutput.getCurrent() == 0 ? highFeedrate : feedOutput.getCurrent());

    } else {

 

    if (coordinates != undefined && coordinates == MACHINE) {

    } else {

  if (performToolChange) {

function defineWorkPlane(_section, _setWorkPlane) {

  var abc = new Vector(0, 0, 0);

  if (settings.workPlaneMethod.forceMultiAxisIndexing || !is3D() || machineConfiguration.isMultiAxisConfiguration()) {

    if (isPolarModeActive()) {

    } else if (_section.isMultiAxis()) {

    } else if (settings.workPlaneMethod.useTiltedWorkplane && settings.workPlaneMethod.eulerConvention != undefined) {

      if (settings.workPlaneMethod.eulerCalculationMethod == "machine" && machineConfiguration.isMultiAxisConfiguration()) {

      } else {

    } else {

 

    if (_setWorkPlane) {

      if (_section.isMultiAxis() || isPolarModeActive()) { // 4-5x simultaneous operations

        if (_section.isOptimizedForMachine()) {

        } else {

      } else { // 3x and/or 3+2x operations

  } else {

    var remaining = _section.workPlane;

    if (!isSameDirection(remaining.forward, new Vector(0, 0, 1))) {

      return abc;

  return abc;

 

function isTCPSupportedByOperation(_section) {

  var _tcp = _section.getOptimizedTCPMode() == OPTIMIZE_NONE;

  if (!_section.isMultiAxis() && (settings.workPlaneMethod.useTiltedWorkplane ||

  return _tcp;

function getWorkPlaneMachineABC(_section, rotate) {

  var currentABC = isFirstSection() ? new Vector(0, 0, 0) : getCurrentABC();

  var abc = _section.getABCByPreference(machineConfiguration, _section.workPlane, currentABC, settings.machineAngles.controllingAxis, settings.machineAngles.type, settings.machineAngles.options);

  if (!isSameDirection(machineConfiguration.getDirection(abc), _section.workPlane.forward)) {

  if (rotate) {

    if (settings.workPlaneMethod.optimizeType == undefined || settings.workPlaneMethod.useTiltedWorkplane) { // legacy

      var useTCP = false;

      var R = machineConfiguration.getRemainingOrientation(abc, _section.workPlane);

    } else {

      if (!_section.isOptimizedForMachine()) {

  return abc;

function writeToolCall(tool, insertToolCall) {

  if (!isFirstSection()) {

    writeStartBlocks(!getProperty("safeStartAllOperations") && insertToolCall, function () {

  writeStartBlocks(insertToolCall, function () {

    if (getSetting("retract.homeXY.onToolChange", false)) {

    if (!isFirstSection() && insertToolCall) {

      if (typeof forceWorkPlane == "function") {

      if (typeof disableLengthCompensation == "function") {

 

    if (tool.manualToolChange) {

      writeComment("MANUAL TOOL CHANGE TO T" + toolFormat.format(tool.number));

    } else {

      if (!isFirstSection() && getProperty("optionalStop") && insertToolCall) {

  if (typeof forceModals == "function" && (insertToolCall || getProperty("safeStartAllOperations"))) {

 

function startSpindle(tool, insertToolCall) {

  if (tool.type != TOOL_PROBE) {

    var spindleSpeedIsRequired = insertToolCall || forceSpindleSpeed || isFirstSection() ||

 

    writeStartBlocks(spindleSpeedIsRequired, function () {

      if (spindleSpeedIsRequired || operationNeedsSafeStart) {

var gRotationModal = createOutputVariable({current : 69,

  onchange: function () {

    if (typeof probeVariables != "undefined") {

 

var currentWorkPlaneABC = undefined;

function forceWorkPlane() {

 

function cancelWCSRotation() {

  if (typeof gRotationModal != "undefined" && gRotationModal.getCurrent() == 68) {

 

function cancelWorkPlane(force) {

  if (typeof gRotationModal != "undefined") {

    if (force) {

    var command = gRotationModal.format(69);

    if (command) {

 

function setWorkPlane(abc) {

  if (!settings.workPlaneMethod.forceMultiAxisIndexing && is3D() && !machineConfiguration.isMultiAxisConfiguration()) {

  var workplaneIsRequired = (currentWorkPlaneABC == undefined) ||

 

  writeStartBlocks(workplaneIsRequired, function () {

    if (getSetting("retract.homeXY.onIndexing", false)) {

    if (currentSection.getId() > 0 && (isTCPSupportedByOperation(getSection(currentSection.getId() - 1) || tcp.isSupportedByOperation)) && typeof disableLengthCompensation == "function") {

 

    if (settings.workPlaneMethod.useTiltedWorkplane) {

      if (machineConfiguration.isMultiAxisConfiguration()) {

        var machineABC = abc.isNonZero() ? (currentSection.isMultiAxis() ? getCurrentDirection() : getWorkPlaneMachineABC(currentSection, false)) : abc;

        if (settings.workPlaneMethod.useABCPrepositioning || machineABC.isZero()) {

        } else {

      if (abc.isNonZero() || !machineConfiguration.isMultiAxisConfiguration()) {

          gRotationModal.format(68.2), "X" + xyzFormat.format(currentSection.workOrigin.x), "Y" + xyzFormat.format(currentSection.workOrigin.y), "Z" + xyzFormat.format(currentSection.workOrigin.z),

          "I" + abcFormat.format(abc.x), "J" + abcFormat.format(abc.y), "K" + abcFormat.format(abc.z)

    } else {

    if (!currentSection.isMultiAxis()) {