void TF_ImportGraphDefResultsReturnOutputs(TF_ImportGraphDefResults* results,
                                           int* num_outputs,
                                           TF_Output** outputs) {
  *num_outputs = results->return_tensors.size();
  *outputs = results->return_tensors.data();
}

void TF_ImportGraphDefResultsReturnOperations(TF_ImportGraphDefResults* results,
                                              int* num_opers,

				if jerr == nil {
					srvResult.Results = append(srvResult.Results, servicePeerResult{
						Host:          nerr.Host.String(),
						WaitingDrives: waitingDrives,
					})
					continue
				}
			}
			errStr := ""
			if nerr.Err != nil {
				errStr = nerr.Err.Error()
			}
			srvResult.Results = append(srvResult.Results, servicePeerResult{
				Host: nerr.Host.String(),
				Err:  errStr,

			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			if cap(z.Results) >= int(zb0002) {
				z.Results = (z.Results)[:zb0002]
			} else {
				z.Results = make([]int, zb0002)
			}
			for za0001 := range z.Results {
				z.Results[za0001], err = dc.ReadInt()
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
		default:

	c.Assert(response.StatusCode, http.StatusOK)

	var results ListBucketsResponse
	// parse the list bucket response.
	decoder := xml.NewDecoder(response.Body)
	err = decoder.Decode(&results)
	// validating that the xml-decoding/parsing was successful.
	c.Assert(err, nil)

	// Fetch the bucket created above
	var createdBucket Bucket
	for _, b := range results.Buckets.Buckets {
		if b.Name == bucketName {

			// testing whether the copy was successful.
			var results ListPartsInfo
			results, err = obj.ListObjectParts(context.Background(), testCase.bucketName, testObject, testCase.uploadID, 0, 1, ObjectOptions{})
			if err != nil {
				t.Fatalf("Test %d: %s: Failed to look for copied object part: <ERROR> %s", i+1, instanceType, err)
			}
			if len(results.Parts) != 1 {

			go func() {
				defer wg.Done()
				result := madmin.SiteNetPerfNodeResult{}
				cli, err := globalSiteReplicationSys.getAdminClient(ctx, info.DeploymentID)
				if err != nil {
					result.Error = err.Error()
				} else {
					result = siteNetperf(ctx, duration)
					result.Endpoint = cli.GetEndpointURL().String()
				}
				resultsMu.Lock()
				results.NodeResults = append(results.NodeResults, result)
				resultsMu.Unlock()

	resyncStatus := ResyncFailed
	defer func() {
		s.markStatus(resyncStatus, opts, objectAPI)
		globalSiteResyncMetrics.incBucket(opts, resyncStatus)
		s.workerCh <- struct{}{}
	}()
	// Allocate new results channel to receive ObjectInfo.
	objInfoCh := make(chan itemOrErr[ObjectInfo])
	cfg, err := getReplicationConfig(ctx, opts.bucket)
	if err != nil {

		objLayer := newObjectLayerFn()

		opts := HealthOptions{}
		result := objLayer.Health(ctx, opts)

		metrics = make([]MetricV2, 0, 2+4*len(result.ESHealth))

		metrics = append(metrics, MetricV2{
			Description: getClusterWriteQuorumMD(),
			Value:       float64(result.WriteQuorum),
		})

		health := 1
		if !result.Healthy {
			health = 0
		}

		metrics = append(metrics, MetricV2{