%1:2 = tf_executor.island {
      %0 = "tf.Const"() {value = dense<2.000000e+00> : tensor<f32>} : () -> tensor<f32>
      tf_executor.yield %0 : tensor<f32>
    }
// Uses two islands for no other reason than preventing canonicalization from
// eliminating the graph entirely.
    %2:2 = tf_executor.island(%1#1) {
      %4 = "tf.opB"(%1#0) : (tensor<f32>) -> tensor<f32>
      tf_executor.yield %4 : tensor<f32>
    }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package abi

import "unsafe"

// NoEscape hides the pointer p from escape analysis, preventing it
// from escaping to the heap. It compiles down to nothing.
//
// WARNING: This is very subtle to use correctly. The caller must
// ensure that it's truly safe for p to not escape to the heap by

// the comment with any comment markers ("//", "/*", or "*/") stripped.
// The position for each comment is the position of the token immediately
// preceding the comment, with all comments that are on the same line
// collected in a slice, in source order. If there is no preceding token
// (the matching comment appears at the beginning of the file), then the
// recorded position is unknown (line, col = 0, 0).

        """

					if ok {
						return fmt.Sprintf("Pod has %s=%s label, preventing injection", me.Key, v), false
					}
				case metav1.LabelSelectorOpNotIn:
					v, ok := podLabels[me.Key]
					if !ok {
						continue
					}
					for _, nv := range me.Values {
						if nv == v {
							return fmt.Sprintf("Pod has %s=%s label, preventing injection", me.Key, v), false
						}
					}
				}
			}

package os

// Executable returns the path name for the executable that started
// the current process. There is no guarantee that the path is still
// pointing to the correct executable. If a symlink was used to start
// the process, depending on the operating system, the result might
// be the symlink or the path it pointed to. If a stable result is
// needed, [path/filepath.EvalSymlinks] might help.
//
// Executable returns an absolute path unless an error occurred.

      if (!preceding_op) continue;

      // Check whether the preceding op is a quantized composite function.
      if (llvm::isa<TF::PartitionedCallOp>(preceding_op)) {
        auto call_op = llvm::cast<TF::PartitionedCallOp>(preceding_op);
        if (!IsCompositeFunction(call_op)) continue;
        return true;
      }

      // Check if the preceding op is a quantized same-scale op.

image::structuring-builds-2.png[]

This is a common use case for multi-project builds.
Gradle offers <<declaring_dependencies.adoc#sub:project_dependencies,project dependencies>> for this.

[[sec:project_jar_dependencies]]
== Depending on another project

Let's explore a theoretical multi-project build with the following layout:

[.multi-language-sample]
=====
[source, kotlin]
----
.
├── api
│   ├── src
│   │   └──...

stderr 'go: example.com@v0.0.0 requires\n\tgolang.org/x/text@v1.999.999-0.20170915032832-14c0d48ead0c: invalid pseudo-version: preceding tag \(v1.999.998\) not found'
cd ..
! go list -m golang.org/x/text
stderr 'golang.org/x/text@v1.999.999-0.20170915032832-14c0d48ead0c: invalid pseudo-version: preceding tag \(v1.999.998\) not found'

# A v1.0.0- pseudo-version that is not derived from a tag is invalid:

//go:build js

package osinfo

import (
	"fmt"
	"syscall/js"
)

// Version returns the OS version name/number.
func Version() (string, error) {
	// Version detection on Wasm varies depending on the underlying runtime
	// (browser, node, etc), nor is there a standard via something like
	// WASI (see https://go.dev/issue/31105). For now, attempt a few simple