const int32_t* values) {
  int64_t num_values = 1;
  for (int i = 0; i < num_dims; ++i) {
    num_values *= dims[i];
  }
  TF_Tensor* t =
      TF_AllocateTensor(TF_INT32, dims, num_dims, sizeof(int32_t) * num_values);
  memcpy(TF_TensorData(t), values, sizeof(int32_t) * num_values);
  return t;
}

TF_Tensor* Int32Tensor(const std::vector<int32_t>& values) {
  int64_t dims = values.size();

	if len(ps.subs) != 2 {
		t.Fatalf("expected 2 subscribers")
	}
	if want, got := int32(2), ps.NumSubscribers(Mask(1)); got != want {
		t.Fatalf("want %d subscribers, got %d", want, got)
	}
	if want, got := int32(2), ps.NumSubscribers(Mask(2)); got != want {
		t.Fatalf("want %d subscribers, got %d", want, got)
	}
	if want, got := int32(2), ps.NumSubscribers(Mask(1|2)); got != want {
		t.Fatalf("want %d subscribers, got %d", want, got)

  // +optional
  optional int32 minReadySeconds = 5;

  // The number of old ReplicaSets to retain to allow rollback.
  // This is a pointer to distinguish between explicit zero and not specified.
  // This is set to the max value of int32 (i.e. 2147483647) by default, which
  // means "retaining all old ReplicaSets".
  // +optional
  optional int32 revisionHistoryLimit = 6;

// RegEx matches only numeric values
var numericPlaceholderRe = regexp.MustCompile(`\$\d+\$`)

func isNumeric(k reflect.Kind) bool {
	switch k {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return true
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return true
	case reflect.Float32, reflect.Float64:
		return true
	default:
		return false
	}
}

	types  Mask
	filter func(entry T) bool
}

// PubSub holds publishers and subscribers
type PubSub[T Maskable, M Maskable] struct {
	// atomics, keep at top:
	types          uint64
	numSubscribers int32
	maxSubscribers int32

	// not atomics:
	subs []*Sub[T]
	sync.RWMutex
}

// Publish message to the subscribers.
// Note that publish is always non-blocking send so that we don't block on slow receivers.

  // metric is configured.  Scaling is active as long as at least one metric value is
  // available.
  // +optional
  optional int32 minReplicas = 2;

  // maxReplicas is the upper limit for the number of pods that can be set by the autoscaler; cannot be smaller than MinReplicas.
  optional int32 maxReplicas = 3;

syntax = "proto2";

package k8s.io.apimachinery.pkg.util.intstr;

// Package-wide variables from generator "generated".
option go_package = "k8s.io/apimachinery/pkg/util/intstr";

// IntOrString is a type that can hold an int32 or a string.  When used in
// JSON or YAML marshalling and unmarshalling, it produces or consumes the
// inner type.  This allows you to have, for example, a JSON field that can
// accept a name or number.

  // The number of pending and running pods.
  // +optional
  optional int32 active = 4;

  // The number of pods which reached phase Succeeded.
  // +optional
  optional int32 succeeded = 5;

  // The number of pods which reached phase Failed.
  // +optional
  optional int32 failed = 6;

  // completedIndexes holds the completed indexes when .spec.completionMode =

namespace gradients {

using namespace std;

// ================== Helper functions =================

// Fills data with values [start,end) with given step size.
void Range(vector<int32_t>* data, int32_t start, int32_t end,
           int32_t step = 1) {
  for (int32_t i = start; i < end; i += step) {
    (*data)[i] = i;
  }
}

// Fills out_dims with the dimensions of the given tensor.
void GetDims(const TF_Tensor* t, int64_t* out_dims) {

// Range: -128 through 127.
type int8 int8

// int16 is the set of all signed 16-bit integers.
// Range: -32768 through 32767.
type int16 int16

// int32 is the set of all signed 32-bit integers.
// Range: -2147483648 through 2147483647.
type int32 int32

// int64 is the set of all signed 64-bit integers.
// Range: -9223372036854775808 through 9223372036854775807.
type int64 int64