docs: private BootOperations organizeBootOperations(List<ModelNode> bootList, final int lockPermit, MutableRootResourceRegistrationProvider parallelBootRootResourceRegistrationProvider) {
  
          final List<ParsedBootOp> initialOps = new ArrayList<ParsedBootOp>();
          List<ParsedBootOp> postExtensionOps = null;
          boolean invalid = false;
          boolean sawExtensionAdd = false;
          final ManagementResourceRegistration rootRegistration = managementModel.get().getRootResourceRegistration();
          final MutableRootResourceRegistrationProvider parallellBRRRProvider = parallelBootRootResourceRegistrationProvider != null ?
                  parallelBootRootResourceRegistrationProvider : getMutableRootResourceRegistrationProvider();
          ParallelExtensionAddHandler parallelExtensionAddHandler = executorService == null ? null : new ParallelExtensionAddHandler(executorService, parallellBRRRProvider);
          ParallelBootOperationStepHandler parallelSubsystemHandler = (executorService != null && processType.isServer() && runningModeControl.getRunningMode() == RunningMode.NORMAL)
                  ? new ParallelBootOperationStepHandler(executorService, rootRegistration, processState, this, lockPermit, extraValidationStepHandler) : null;
          boolean registeredParallelSubsystemHandler = false;
          int subsystemIndex = 0;
          for (ModelNode bootOp : bootList) {
              final ParsedBootOp parsedOp = new ParsedBootOp(bootOp);
              if (postExtensionOps != null) {
                  // Handle cases like AppClient where extension adds are interleaved with subsystem ops
                  if (parsedOp.isExtensionAdd()) {
                      final ExtensionAddHandler stepHandler = (ExtensionAddHandler) rootRegistration.getOperationHandler(parsedOp.address, parsedOp.operationName);
                      if (parallelExtensionAddHandler != null) {
                          parallelExtensionAddHandler.addParsedOp(parsedOp, stepHandler);
                      } else {
                          initialOps.add(new ParsedBootOp(parsedOp, stepHandler));
                      }
                  } else {
                      if (parallelSubsystemHandler == null || !parallelSubsystemHandler.addSubsystemOperation(parsedOp)) {
                          // Put any interface/socket op before the subsystem op
                          if (registeredParallelSubsystemHandler && (parsedOp.isInterfaceOperation() || parsedOp.isSocketOperation())) {
                              postExtensionOps.add(subsystemIndex++, parsedOp);
                          } else {
                              postExtensionOps.add(parsedOp);
                          }
                      } else if (!registeredParallelSubsystemHandler) {
                          postExtensionOps.add(parallelSubsystemHandler.getParsedBootOp());
                          subsystemIndex = postExtensionOps.size() - 1;
                          registeredParallelSubsystemHandler = true;
                      }
                  }
              } else {
                  final OperationStepHandler stepHandler = rootRegistration.getOperationHandler(parsedOp.address, parsedOp.operationName);
                  if (!sawExtensionAdd && stepHandler == null) {
                      // Odd case. An op prior to the first extension add where there is no handler. This would really
                      // only happen during AS development
                      logNoHandler(parsedOp);
                      invalid = true;
                      // stop
                      break;
                  } else if (stepHandler instanceof ExtensionAddHandler) {
                      if (parallelExtensionAddHandler != null) {
                          parallelExtensionAddHandler.addParsedOp(parsedOp, (ExtensionAddHandler) stepHandler);
                          if (!sawExtensionAdd) {
                              initialOps.add(parallelExtensionAddHandler.getParsedBootOp());
                          }
                      } else {
                          initialOps.add(new ParsedBootOp(parsedOp, stepHandler));
                      }
                      sawExtensionAdd = true;
                  } else if (!sawExtensionAdd) {
                      // An operation prior to the first Extension Add
                      initialOps.add(new ParsedBootOp(parsedOp, stepHandler));
                  } else {
                      // Start the postExtension list
                      postExtensionOps = new ArrayList<ParsedBootOp>(32);
                      if (parallelSubsystemHandler == null || !parallelSubsystemHandler.addSubsystemOperation(parsedOp)) {
                          postExtensionOps.add(parsedOp);
                      } else {
                          // First subsystem op; register the parallel handler and add the op to it
                          postExtensionOps.add(parallelSubsystemHandler.getParsedBootOp());
                          registeredParallelSubsystemHandler = true;
                      }
                  }
              }
          }
  
  
          return new BootOperations(initialOps, postExtensionOps, invalid);
      }