// Add the function return;
  std::vector<Value> results;
  Append(results, new_forward->getResults());
  Append(results, new_core_tpu->getResults());
  func_builder.create<func::ReturnOp>(loc, results);

  // Inline any StatefulPartitionCall Ops.
  auto result = Inliner(builder, symbol_table).InlineCallsInFunc(then_func);
  if (failed(result)) return result;

  builder.restoreInsertionPoint(insertion_point);

						poolIdx, setIdx, poolReadQuorums[poolIdx]))
			}
			result.HealthyRead = result.HealthyRead && healthyRead
		}
	}

	if opts.Maintenance {
		result.Healthy = result.Healthy && drivesHealing == 0
		result.HealthyRead = result.HealthyRead && drivesHealing == 0
		result.HealingDrives = drivesHealing
	}

	return result
}

// PutObjectMetadata - replace or add tags to an existing object

  for (Value result : return_value_from_host)
    parallel_execute_result_types.push_back(result.getType());
  for (Value result : return_value_from_device)
    parallel_execute_result_types.push_back(result.getType());
  return parallel_execute_result_types;
}

// Remap the device cluster results with parallel execute op results
llvm::SmallVector<Value, 4> GetRemappedTpuClusterResults(

    results = qc.QuantizationResults()
    text_format.Parse(quantization_results_textpb, results)

    self.assertProtoEquals(
        expected_message_maybe_ascii=r"""
        results {
          quantizable_unit { name: "composite_dot_general_fn_1" }
          method { static_range_ptq {} }
        }
        """,
        message=results,
    )

                }

                captureBuildOperationResult(context, results);
                return results;
            }

            private void captureBuildOperationResult(BuildOperationContext context, ResolverResults results) {
                results.getVisitedGraph().getResolutionFailure().ifPresent(context::failed);

   * a POJO.
   *
   * @param input The future to transform
   * @param function A Function to transform the results of the provided future to the results of
   *     the returned future.
   * @param executor Executor to run the function in.
   * @return A future that holds result of the transformation.
   * @since 9.0 (in 2.0 as {@code compose})
   */

   * a POJO.
   *
   * @param input The future to transform
   * @param function A Function to transform the results of the provided future to the results of
   *     the returned future.
   * @param executor Executor to run the function in.
   * @return A future that holds result of the transformation.
   * @since 9.0 (in 2.0 as {@code compose})
   */

// CHECK-SAME: topology = "topology"
// CHECK:      %[[OP_B:[0-9]*]] = "tf.opB"(%[[CLUSTER]])
// CHECK:      "tf.opD"(%[[OP_B]])


// Test one replica cluster results in removing of TPUReplicatedInput and
// TPUReplicatedOutput nodes and operands are forwarded to results.
// CHECK-LABEL: func @one_replica
// CHECK-SAME: (%[[ARG_0:[a-z0-9]*]]: tensor<i1>)
func.func @one_replica(%arg0: tensor<i1>) -> tensor<i1> {

	tparams, params := p.parseParameters(true)
	if tparams != nil {
		p.error(tparams.Pos(), "function type must have no type parameters")
	}
	results := p.parseResult()

	return &ast.FuncType{Func: pos, Params: params, Results: results}
}

func (p *parser) parseMethodSpec() *ast.Field {
	if p.trace {
		defer un(trace(p, "MethodSpec"))
	}

	doc := p.leadComment

        } else if (result instanceof InternalTaskSkippedResult) {
            return new DefaultTaskSkippedResult(result.getStartTime(), result.getEndTime(), ((InternalTaskSkippedResult) result).getSkipMessage());
        } else if (result instanceof InternalTaskFailureResult) {
            return new DefaultTaskFailureResult(result.getStartTime(), result.getEndTime(), toFailures(result.getFailures()), toTaskExecutionDetails(result));