// Create Fetch.
  ValueRange to_fetch = island.getResults();
  if (to_fetch.size() != 1) {
    // Drop control result for fetch.
    to_fetch = to_fetch.drop_back();
  }
  builder.create<tf_executor::FetchOp>(loc, to_fetch);
  // Build Island.
  island.getBody().push_back(new Block);
  island.getBody().front().getOperations().splice(
      island.getBody().front().begin(), body.getOperations(),

      tf_executor::FetchOp fetch = graph_op.GetFetch();
      auto fetches = llvm::to_vector<8>(fetch.getOperands());
      fetches.append(unused_execute_controls.begin(),
                     unused_execute_controls.end());
      builder.setInsertionPoint(fetch);
      builder.create<tf_executor::FetchOp>(fetch.getLoc(), fetches);
      fetch.erase();
    }
  } else {

    if (!unused_replica_controls.empty()) {
      tf_executor::FetchOp fetch = graph_op.GetFetch();
      auto fetches = llvm::to_vector<8>(fetch.getOperands());
      fetches.append(unused_replica_controls.begin(),
                     unused_replica_controls.end());
      builder.setInsertionPoint(fetch);
      builder.create<tf_executor::FetchOp>(fetch.getLoc(), fetches);
      fetch.erase();
    }
  } else {

                                executor_graph.getBody().end());

    // Add terminator of tf_executor::graph
    rewriter.setInsertionPointToEnd(&executor_graph.getBody().front());
    rewriter.create<tf_executor::FetchOp>(loc);

    // Add terminator of func
    rewriter.setInsertionPointToEnd(&func.getBody().front());
    rewriter.create<func::ReturnOp>(loc);

    if (!MayHaveSideEffect(op)) return;
    // Skip following ops to avoid that every island, graph and function is
    // classified as unknown side-effecting.
    if (isa<tf_executor::YieldOp, tf_executor::FetchOp,
            mlir::func::ReturnOp>(op))
      return;

    // Propagate side effects from regions or functions attached to `op` for
    // some special cases.
    if (auto func = llvm::dyn_cast<func::FuncOp>(op)) {

	}
	manifest.MediaType = types.DockerManifestSchema2

	// Push image to the registry.
	err = crane.Push(img, ref, fetchOpt)
	if err != nil {
		t.Fatal(err)
	}

	// Push image to the registry with latest tag as well
	ref = fmt.Sprintf("%s/test/valid/docker:latest", host)
	err = crane.Push(img, ref, fetchOpt)
	if err != nil {
		t.Fatal(err)
	}

	// Calculate sum
	d, _ := img.Digest()

        updated_next_iteration = true;
      }
    }
  } while (updated_next_iteration);
}

// Propagates devices to function results.
void PropagateDevicesToResults(
    func::FuncOp func, tf_executor::FetchOp fetch,
    const llvm::DenseMap<Value, llvm::StringRef>& value_to_device) {
  // We apply all result attributes at once to avoid excessive allocations when
  // we have many result values.

    Op<TfExecutor_Dialect, mnemonic, traits> {

  let hasVerifier = 1;
  let hasCustomAssemblyFormat = 1;
}

def TfExecutor_GraphOp : TfExecutor_Op<"graph",
    [SingleBlockImplicitTerminator<"FetchOp">]> {
  let summary = [{The `tf_executor.graph` operation contains a region with a
    single block that lists the operations in a TensorFlow graph.}];


  let description = [{

  return control_island.getOutputs().empty() &&
         isa<TF::NoOp>(control_island.GetBody().front());
}

// Remove all control outputs of the function. Traverses NoOp control barrier
// chains from FetchOp to all NoOp control barriers. Returns true
// iff at least one control output is deleted. The ops_connected_to_fetch
// set is populated with all operations that had a direct (or indirect, through

  // vector `tangent` of matching shape and dtype. Tangents are the "vector" in
  // "Jacobian-vector product"; `Watch`ing a new Tensor and immediately calling
  // FetchJVP for it would return `tangent`.
  void Watch(int64_t tensor_id, Gradient* tangent);

  // Removes the gradient associated with tensor_id. Should be called when the
  // Tensor associated with `tensor_id` is deleted.