}
}

func osArchInit() {}

func checkS390xCPU() {
	// Check if the present z-system has the hardware capability to carryout
	// floating point operations. Check if hwcap reflects CPU capability for the
	// necessary floating point hardware (HasVX) availability.
	// Starting with Go1.19, z13 is the minimum machine level for running Go on LoZ
	if cpu.HWCap&_HWCAP_VX == 0 {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.execution.steps;

/**
 * Context necessary for steps that change the outputs.
 *
 * This context doesn't add any new information, it encodes a requirement
 * in the type system that a step can change the outputs.
 */

/**
 * Coordinates the building of tooling models.
 */
public interface BuildToolingModelController {
    /**
     * Returns the mutable model, configuring if necessary.
     */
    GradleInternal getConfiguredModel();

    ToolingModelScope locateBuilderForTarget(String modelName, boolean param);

                // create it if necessary
                openFunction = OPEN_FN_TRUNC | OPEN_FN_CREATE;
            } else {
                openFunction = OPEN_FN_TRUNC;
            }
        } else {
            // don't truncate the file
            if(( flags & SmbFile.O_CREAT ) == SmbFile.O_CREAT ) {
                // create it if necessary
                if(( flags & SmbFile.O_EXCL ) == SmbFile.O_EXCL ) {

import org.gradle.internal.typeconversion.NotationParser;

/**
 * A concrete type for a generic {@link NotationParser} that parses {@link Capability}s.
 * <p>
 * This concrete type is necessary so that it can be injected into version catalog generated sources.
 */
public interface CapabilityNotationParser extends NotationParser<Object, Capability> {

namespace cc {

// SignatureDefFunctionMetadata stores additional information on each input
// and output's names, dtypes, and shape.
class SignatureDefFunctionMetadata final {
  // TODO(bmzhao): Add getters here as necessary.
 private:
  friend class SignatureDefFunction;
  static SignatureDefFunctionMetadata* wrap(
      TF_SignatureDefFunctionMetadata* p) {
    return reinterpret_cast<SignatureDefFunctionMetadata*>(p);
  }

#include "tensorflow/c/experimental/saved_model/public/function_metadata.h"

#include "tensorflow/c/experimental/saved_model/internal/function_metadata_type.h"

// Package syslog provides a simple interface to the system log
// service. It can send messages to the syslog daemon using UNIX
// domain sockets, UDP or TCP.
//
// Only one call to Dial is necessary. On write failures,
// the syslog client will attempt to reconnect to the server
// and write again.
//
// The syslog package is frozen and is not accepting new features.

		}
	}()
}

var One float64 = 1.0

func f(d uintptr) {
	var a, m []int
	var s struct {
		a, b, c, d, e int
	}

	g(d, a, m, s, uint(One)) // Uint of not-a-constant inserts a conditional, necessary to bug

	defer func() uint {
		return 0
	}()
}

var d uintptr

func h() {
	f(d)

#define TENSORFLOW_C_EXPERIMENTAL_SAVED_MODEL_CORE_FUNCTION_METADATA_H_

namespace tensorflow {

class FunctionMetadata {
  // TODO(bmzhao): Fill in with fields as necessary
};

}  // namespace tensorflow