#include <stdint.h>

#include "tensorflow/c/tf_datatype.h"

namespace tensorflow {

// Each of the following struct types have two members: a kDType that
// corresponds to a TF_Datatype enum value, and a typedef "type"
// of its corresponding C++ type. These types allow us to write Dtype-agnostic
// tests via GoogleTest's TypedTests:

#include "libcgo.h"

// go_sigaction_t is a C version of the sigactiont struct from
// defs_linux_amd64.go.  This definition — and its conversion to and from struct
// sigaction — are specific to linux/amd64.
typedef struct {
	uintptr_t handler;
	uint64_t flags;
	uintptr_t restorer;
	uint64_t mask;
} go_sigaction_t;

// SA_RESTORER is part of the kernel interface.
// This is Linux i386/amd64 specific.
#ifndef SA_RESTORER

#include "tensorflow/c/c_api_macros.h"
#include "tensorflow/c/tf_datatype.h"
#include "tensorflow/c/tf_status.h"

#ifdef __cplusplus
extern "C" {
#endif

// Allocator Attributes used for tensor allocation.
typedef struct TF_AllocatorAttributes {
  size_t struct_size;
  // Set boolean to 1 for CPU allocation, else 0.
  TF_Bool on_host;
} TF_AllocatorAttributes;

#define TF_ALLOCATOR_ATTRIBUTES_STRUCT_SIZE \

// when the stack is used for something else. Issue 26209.

/*
#cgo LDFLAGS: -fsanitize=memory
#cgo CPPFLAGS: -fsanitize=memory

#include <stdint.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
	uintptr_t a[20];
} S;

S f() {
	S *p;

	p = (S *)(malloc(sizeof(S)));
	p->a[0] = 0;
	return *p;
}
*/
import "C"

// allocateStack extends the stack so that stack copying doesn't

// invalidate old TF_Operation* pointers.
typedef struct TF_Operation TF_Operation;

// Represents a specific input of an operation.
typedef struct TF_Input {
  TF_Operation* oper;
  int index;  // The index of the input within oper.
} TF_Input;

// Represents a specific output of an operation.
typedef struct TF_Output {
  TF_Operation* oper;

  /// ). The `status` should be `TF_OK` as long as the read from the remote
  /// filesystem succeeded (similar to the semantics of the read(2) system
  /// call).
  typedef std::function<int64_t(const std::string& filename, size_t offset,
                                size_t buffer_size, char* buffer,
                                TF_Status* status)>
      BlockFetcher;

//
// auto* reader = TFE_MonitoringNewCounterReader("name");
// test();
// int64_t value = TFE_MonitoringReadCounter1(reader, "label-value");

// Opaque handle to a reader.
typedef struct TFE_MonitoringCounterReader TFE_MonitoringCounterReader;

// Returns a handle to be used for reading values from streamz counter. The
// counter can have been created with any number of labels.

 */
public interface IsolatedAntBuilder {

    /**
     * Creates a copy of this builder which uses the given libraries. These classes are visible for use in
     * taskdef/typedef tasks.
     *
     * @param classpath The library classpath
     * @return a copy of this builder
     */
    IsolatedAntBuilder withClasspath(Iterable<File> classpath);

    /**

// but any crypto code that depends on the speed of
// division is equally dumb.

//go:build ignore

#include <stdio.h>
#include <stdint.h>

#define nelem(x) (sizeof(x)/sizeof((x)[0]))

typedef uint32_t u32;

static u32 div(u32 x, u32 y, u32 *rp) {
	int n = 0;
	while((y>>(32-1)) != 1 && y < x) {
		y<<=1;
		n++;
	}
	u32 q = 0;
	for(;; n--, y>>=1, q<<=1) {
		if(x>=y) {
			x -= y;
			q |= 1;

// `TF_RegisterKernelBuilder`, which will allow TF to construct user-provided
// kernels when necessary.

typedef struct TF_KernelBuilder TF_KernelBuilder;
typedef struct TF_OpKernelConstruction TF_OpKernelConstruction;
typedef struct TF_OpKernelContext TF_OpKernelContext;
typedef struct TF_AsyncOpKernelDoneCallback TF_AsyncOpKernelDoneCallback;

// Run callback function for async kernel.