TF_Tensor* t = TFE_TensorHandleResolve(handle, status.get());
  ASSERT_EQ(TF_OK, TF_GetCode(status.get())) << TF_Message(status.get());
  std::unique_ptr<float[]> actual_values(new float[expected_values.size()]);
  EXPECT_EQ(sizeof(float) * expected_values.size(), TF_TensorByteSize(t));
  memcpy(actual_values.get(), TF_TensorData(t), TF_TensorByteSize(t));
  TF_DeleteTensor(t);

  for (int i = 0; i < expected_values.size(); i++) {

pkg go/types, type SelectionKind int
pkg go/types, type Signature struct
pkg go/types, type Sizes interface { Alignof, Offsetsof, Sizeof }
pkg go/types, type Sizes interface, Alignof(Type) int64
pkg go/types, type Sizes interface, Offsetsof([]*Var) []int64
pkg go/types, type Sizes interface, Sizeof(Type) int64
pkg go/types, type Slice struct
pkg go/types, type StdSizes struct
pkg go/types, type StdSizes struct, MaxAlign int64

      TF_Tensor* out = csession.output_tensor(i);
      ASSERT_TRUE(out != nullptr);
      EXPECT_EQ(TF_INT32, TF_TensorType(out));
      EXPECT_EQ(0, TF_NumDims(out));  // scalar
      ASSERT_EQ(sizeof(int32_t), TF_TensorByteSize(out));
      int32_t* output_contents = static_cast<int32_t*>(TF_TensorData(out));
      EXPECT_EQ(expected_results[i], *output_contents);
    }
  }

		0, // u6
		f7,
		f8,
		0, // s9
		0, // s10
		1
	};

	const char __cgodebug_str__9[] = s9;
	const unsigned long long __cgodebug_strlen__9 = sizeof(s9)-1;
	const char __cgodebug_str__10[] = s10;
	const unsigned long long __cgodebug_strlen__10 = sizeof(s10)-1;

and again invokes the system C compiler, to produce an object file
containing debug information. Cgo parses the DWARF debug information

a <a href="#Constant_expressions">constant expression</a>,
a <a href="#Conversions">conversion</a> with a result that is a constant, or
the result value of some built-in functions such as
<code>unsafe.Sizeof</code> applied to any value,
<code>cap</code> or <code>len</code> applied to
<a href="#Length_and_capacity">some expressions</a>,
<code>real</code> and <code>imag</code> applied to a complex constant

	}
	if t, ok := strings.CutPrefix(s, "union_"); ok {
		return "union " + t
	}
	if t, ok := strings.CutPrefix(s, "enum_"); ok {
		return "enum " + t
	}
	if t, ok := strings.CutPrefix(s, "sizeof_"); ok {
		return "sizeof(" + cname(t) + ")"
	}
	return s
}

// ProcessCgoDirectives processes the import C preamble:
//  1. discards all #cgo CFLAGS, LDFLAGS, nocallback and noescape directives,

a <a href="#Conversions">conversion</a> with a result that is a constant, or
the result value of some built-in functions such as
<code>min</code> or <code>max</code> applied to constant arguments,
<code>unsafe.Sizeof</code> applied to <a href="#Package_unsafe">certain values</a>,
<code>cap</code> or <code>len</code> applied to
<a href="#Length_and_capacity">some expressions</a>,

  GraphImportGraphDefLocked(graph, def, options, &results, status);
  DCHECK_EQ(results.return_tensors.size(), num_return_outputs);
  memcpy(return_outputs, results.return_tensors.data(),
         num_return_outputs * sizeof(TF_Output));
}

void TF_GraphImportGraphDef(TF_Graph* graph, const TF_Buffer* graph_def,
                            const TF_ImportGraphDefOptions* options,
                            TF_Status* status) {