MOVW	$1000000000, R5	// 10**9
	MULLU	R6,R5,(R9,R8)   // R9:R8 = R7:R6 * R5
	MULA	R7,R5,R9,R9
	SUB.S	R8,R1		// R2:R1 -= R9:R8
	SBC	R9,R2

	// because reciprocal was a truncated repeating fraction, quotient
	// may be slightly too small -- adjust to make remainder < 10**9
	CMP	R5,R1	// if remainder > 10**9
	SUB.HS	R5,R1   //    remainder -= 10**9
	ADD.HS	$1,R6	//    sec += 1

	MOVW	R6,sec_lo+0(FP)

	}
	return nil
}

// SetString sets z to the value of s and returns z and a boolean indicating
// success. s can be given as a (possibly signed) fraction "a/b", or as a
// floating-point number optionally followed by an exponent.
// If a fraction is provided, both the dividend and the divisor may be a
// decimal integer or independently use a prefix of “0b”, “0” or “0o”,

        @Override
        public void run(BuildOperationContext context) {
            ProjectEvaluationListener nextBatch = project.getProjectEvaluationBroadcaster();
            Action<ProjectEvaluationListener> fireAction = new Action<ProjectEvaluationListener>() {
                @Override
                public void execute(ProjectEvaluationListener listener) {
                    listener.afterEvaluate(project, state);
                }

import org.gradle.internal.reflect.DefaultTypeValidationContext;
import org.gradle.util.internal.TextUtil;
import org.gradle.work.DisableCachingByDefault;
import org.gradle.workers.WorkAction;
import org.gradle.workers.WorkParameters;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.Opcodes;

import java.io.File;
import java.io.IOException;

            import org.gradle.api.file.ProjectLayout
            import org.gradle.workers.WorkParameters
            import org.gradle.workers.internal.WorkerDaemonFactory

            abstract class TestWorkAction implements WorkAction<WorkParameters.None> {
                void execute() {
                    println "Runnable executed..."
                }
            }

            abstract class DaemonTask extends DefaultTask {

                    workerExecutor.processIsolation().submit(TestWorkAction) { }
                    ${server.callFromBuild("waiting")}
                }
            }
            abstract class TestWorkAction implements WorkAction<WorkParameters.None> { void execute() { } }
        """

        when:
        // start a build with a IsolationMode.PROCESS worker that will initialize the worker classpath cache and wait until the cache was initialized

            import org.gradle.internal.service.scopes.GradleUserHomeScopeServices
            import org.gradle.workers.WorkParameters
            import org.gradle.workers.WorkAction
            import org.gradle.internal.instrumentation.agent.AgentStatus
            import org.gradle.cache.scopes.GlobalScopedCacheBuilderFactory

            abstract class WorkerTask extends DefaultTask {

// RUN: tf-opt %s -split-input-file -tf-device-cluster-formation | FileCheck %s

// Simple case, single device cluster.

module {
  // CHECK-LABEL: func @singlecluster
  // CHECK-SAME: (%[[ARG_0:[a-z0-9]*]]: tensor<?xi32>)
  func.func @singlecluster(%arg0: tensor<?xi32>) -> tensor<?xi32> {
    // CHECK: %[[A_OUTPUT:[0-9]*]] = "tf.A"(%[[ARG_0]])
    %2 = "tf.A"(%arg0) : (tensor<?xi32>) -> tensor<?xi32>

        WorkActionClass(String name, String packageName, WorkParameterClass parameters) {
            super(name, packageName)
            this.parameters = parameters
            this.imports += ["org.gradle.workers.WorkAction"]
        }

        @Override
        WorkActionClass writeToBuildSrc() {
            parameters.writeToBuildSrc()
            addImportToBuildScript("${packageName}.${name.capitalize()}")

  // After construction:
  //  For basic block argument source this will be a first operation in the
  //  basic block, and for operations it will be an operation iself.
  //
  // During the union-find cluster formation:
  //  The root member will have the location in the basic block, where the
  //  cluster operation will be inserted. We use the location of the last
  //  operation in the cluster, so that during cluster construction we can