SideEffects:    &noSideEffect,
			TimeoutSeconds: int32Ptr(1),
		}, {
			Name:           "webhook2.k8s.io",
			ClientConfig:   validClientConfig,
			SideEffects:    &noSideEffect,
			TimeoutSeconds: int32Ptr(15),
		}, {
			Name:           "webhook3.k8s.io",
			ClientConfig:   validClientConfig,
			SideEffects:    &noSideEffect,
			TimeoutSeconds: int32Ptr(30),
		},
		}, true),
	}, {

					Port:     pointer.Int32Ptr(int32(3456)),
				},
				{
					Name:     pointer.StringPtr("udp-example"),
					Protocol: protoPtr(v1.ProtocolUDP),
					Port:     pointer.Int32Ptr(int32(161)),
				},
				{
					Name:     pointer.StringPtr("tcp-example"),
					Protocol: protoPtr(v1.ProtocolTCP),
					Port:     pointer.Int32Ptr(int32(80)),
				},
			},

(Load <t> ptr mem) && is64BitInt(t) && !config.BigEndian && t.IsSigned() =>
	(Int64Make
		(Load <typ.Int32> (OffPtr <typ.Int32Ptr> [4] ptr) mem)
		(Load <typ.UInt32> ptr mem))

(Load <t> ptr mem) && is64BitInt(t) && !config.BigEndian && !t.IsSigned() =>
	(Int64Make
		(Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem)
		(Load <typ.UInt32> ptr mem))

(Load <t> ptr mem) && is64BitInt(t) && config.BigEndian && t.IsSigned() =>

		burst:          0,
	}

	useSerializedEnv := false
	maxParallelImagePulls := 5
	var wg sync.WaitGroup

	puller, fakeClock, fakeRuntime, container, _ := pullerTestEnv(t, *testCase, useSerializedEnv, utilpointer.Int32Ptr(int32(maxParallelImagePulls)))
	fakeRuntime.BlockImagePulls = true
	fakeRuntime.CalledFunctions = nil
	fakeRuntime.T = t
	fakeClock.Step(time.Second)

	// First 5 EnsureImageExists should result in runtime calls

					Name:     utilpointer.StringPtr("http"),
					Port:     utilpointer.Int32Ptr(80),
					Protocol: &tcpProtocol,
				}, {
					Name:     utilpointer.StringPtr("https"),
					Port:     utilpointer.Int32Ptr(443),
					Protocol: &tcpProtocol,
				}, {
					Name:     utilpointer.StringPtr("extra1"),
					Port:     utilpointer.Int32Ptr(3000),
					Protocol: &tcpProtocol,
				}, {

	// result: (Int64Make (Load <typ.Int32> (OffPtr <typ.Int32Ptr> [4] ptr) mem) (Load <typ.UInt32> ptr mem))
	for {
		t := v.Type
		ptr := v_0
		mem := v_1
		if !(is64BitInt(t) && !config.BigEndian && t.IsSigned()) {
			break
		}
		v.reset(OpInt64Make)
		v0 := b.NewValue0(v.Pos, OpLoad, typ.Int32)
		v1 := b.NewValue0(v.Pos, OpOffPtr, typ.Int32Ptr)
		v1.AuxInt = int64ToAuxInt(4)
		v1.AddArg(ptr)

// license that can be found in the LICENSE file.

package main

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

void f(int32_t *p, int n) {
  int32_t * volatile q = (int32_t *)malloc(sizeof(int32_t) * n);
  memcpy(p, q, n * sizeof(*p));
  free(q);
}

void g(int32_t *p, int n) {
  if (p[4] != 1) {
    // We shouldn't get here; msan should stop us first.
    exit(0);
  }
}
*/
import "C"

    $transpose_a, $transpose_b, $grad_a, $grad_b),
  (CreateXlaDotV2OpFromTfMatMulOp
    $input, $weight, /*input_zp=*/(CreateScalarIntegerConst<"int32_t", "0">),
    /*weight_zp=*/(CreateScalarIntegerConst<"int32_t", "0">),
    $matmul, $transpose_a, $transpose_b),
  [(IsInt32ElementType $input),
   (IsInt8ElementType $weight),
   (IsConstTensor $weight),
   (IsInt32ElementType $matmul),

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

void f(int32_t *p, int n) {
  int32_t * volatile q = (int32_t *)malloc(sizeof(int32_t) * n);
  memcpy(p, q, n * sizeof(*p));
  free(q);
}

void g(int32_t *p, int n) {
  if (p[4] != 1) {
    abort();
  }
}
*/
import "C"

import (
	"unsafe"
)

func main() {
	a := make([]int32, 10)
	C.f((*C.int32_t)(unsafe.Pointer(&a[0])), C.int(len(a)))
	a[4] = 1

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

void f(int32_t *p, int n) {
  int32_t * volatile q = (int32_t *)malloc(sizeof(int32_t) * n);
  memcpy(p, q, n * sizeof(*p));
  free(q);
}

void g(int32_t *p, int n) {
  if (p[4] != 1) {
    abort();
  }
}
*/
import "C"

import (
	"unsafe"
)

func main() {
	a := make([]int32, 10)
	C.f((*C.int32_t)(unsafe.Pointer(&a[0])), C.int(len(a)))
	a[4] = 1