// ThreadLocal is not available to GWT, so we always reuse the same
    // instance.  It is always safe to return the same instance because
    // javascript is single-threaded, and only used by blocks that doesn't
    // involve async callbacks.
    return CHAR_BUFFER;
  }

  private Platform() {}

}

func writeDot(ns ...int) {
	for _, root := range []string{"t", "p"} {
		fmt.Printf("const _ = unsafe.Offsetof(%s", root)
		for _, n := range ns {
			fmt.Printf(".T%d", n)
		}
		// Does it involve an indirection?
		nlast := ns[len(ns)-1]
		nprev := 1
		if len(ns) > 1 {
			nprev = ns[len(ns)-2]
		}
		isIndirect := false
		for n := nlast / 2; n > nprev; n /= 2 {
			if n%2 == 1 {
				isIndirect = true

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.versions.KotlinGradlePluginVersions
import spock.lang.Issue

/**
 * Integration tests for the `java-test-fixtures` plugin that involve `kotlin` projects.
 */
class KotlinTestFixturesIntegrationTest extends AbstractTestFixturesIntegrationTest {
    /**
     * Ensure we make an exception for test fixtures when checking for redundant

  // the `RemoveVariablesInSessionInitializerPass` pass, which runs otherwise,
  // may unexpectedly also remove the initialization patterns for non-variable
  // resources (like hash tables) if they involve variables. Such a case is
  // illustrated in the test file
  // "../tests/tf_saved_model_remove_vars_in_session_initializer.mlir".
  // This defaults to `false` to avoid breaking existing uses.

As the SavedModel work progresses, it's likely to be of interest to find a
shortcut between the Python `tf.Module` and the SavedModel MLIR representation
that doesn't involve serializing a SavedModel to disk and reading it back.

## Potential improvements

The test iteration cycle for these tests is very long (usually over a minute).

	"istio.io/istio/pkg/security"
)

// TokenProvider is a grpc PerRPCCredentials that can be used to attach a JWT token to each gRPC call.
// TokenProvider can be used for XDS, which may involve token exchange through STS.
type DefaultTokenProvider struct {
	opts *security.Options
}

var _ credentials.PerRPCCredentials = &DefaultTokenProvider{}

		if runtime.GOOS != "aix" {
			cgoLDFlags += " -Wl,-rpath," + libDir
		}
		t.Logf("CGO_LDFLAGS=%s", cgoLDFlags)
		os.Setenv("CGO_LDFLAGS", cgoLDFlags)

	}

	// Do a test build that doesn't involve Go FORTRAN support.
	fcArgs := append([]string{"testdata/helloworld/helloworld.f90", "-o", "/dev/null"}, fcExtra...)
	t.Logf("%s %s", fc, fcArgs)
	if err := exec.Command(fc, fcArgs...).Run(); err != nil {

// This transformation pass reduces the precision of some tensor types by first
// checking if all values within that tensor are within the range.
// This pass is added to aid conversion of models that involve types not
// available in TF such as INT4, and ideally should be removed in favor of
// stronger type propagation.

#include <cstdint>
#include <memory>
#include <utility>

// A task is a higher-level component that aids tracing of logical
// operations such as an RPC request, an HTTP request, or an
// interesting local operation which may require multiple goroutines
// working together. Since tasks can involve multiple goroutines,
// they are tracked via a [context.Context] object. [NewTask] creates
// a new task and embeds it in the returned [context.Context] object.
// Log messages and regions are attached to the task, if any, in the

    /**
     * Whether this function call is an implicit invoke call on a value that has an `invoke` member function. See
     * https://kotlinlang.org/docs/operator-overloading.html#invoke-operator for more details.
     */
    public val isImplicitInvoke: Boolean by validityAsserted(isImplicitInvoke)
}

/**