// whose value is broacast to all replicas.
std::unique_ptr<mlir::OperationPass<mlir::func::FuncOp>>
CreateHoistBroadcastReadPass();

// Creates a pass that moves broadcasts from TF host ops to XLA code, encoded as
// XlaAllReduces. This enables use of the device network for broadcasts, which
// is faster.
std::unique_ptr<mlir::OperationPass<mlir::func::FuncOp>>
CreateXlaBroadcastPass();

		if n > 0 {
			written += int64(n)
			remain -= int64(n)
			p.data -= n
		}
	}
	if err != nil {
		return written, handled, err
	}
	return written, true, nil
}

// spliceDrain moves data from a socket to a pipe.
//
// Invariant: when entering spliceDrain, the pipe is empty. It is either in its
// initial state, or splicePump has emptied it previously.
//

}

def XlaBroadcastPass : Pass<"tf-xla-broadcast", "mlir::func::FuncOp"> {
  let summary = "Moves a broadcast from host into XLA, encoded as XlaAllReduce";

  let description = [{
    This pass moves brodcasts from host TF ops into XLA. This enables use of
    the inter-device network, which is faster than the inter-host network.

// replace mixed-type convolution and matmul cast hacks by XLA Conv2DOp and
// MatmulOp.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateReplaceCastHacksWithTFXLAOpsPass();

// Creates a pass that moves & merges initializer function's ops into the @main
// function. This pass should be run on a valid tf_executor dialect. The control
// output of the initializer function for non-variable resource initialization

			offset += size
		}

	case ssa.OpPPC64LoweredMove, ssa.OpPPC64LoweredMoveShort:

		bytesPerLoop := int64(32)
		// This will be used when moving more
		// than 8 bytes.  Moves start with
		// as many 8 byte moves as possible, then
		// 4, 2, or 1 byte(s) as remaining.  This will
		// work and be efficient for power8 or later.
		// If there are 64 or more bytes, then a

//   ordering constraint.
constexpr std::array<StringRef, 2> kInitializerTypesByMergeOrder = {
    kTfSavedModelInitializerRestoreType, kTfSavedModelInitializerInitType};

// This pass moves all ops from initializer functions to the main function. A
// new `tf.NoOp` that has control dependency to the initializer function for
// non-variable resources will be created. The control output of the new

    """
    # Tuple of (mse_error, quant_min, quant_max).
    mse_min = (float('inf'), float('inf'), float('inf'))
    left, right = start_idx, start_idx

    # If this value is true, it moves left, otherwise it moves right.
    move_left = True
    while not (left == 0 and right == self._num_bins - 1):
      # Decrease left if right can't be moved or move_left is true.

  // user if these moves are not known to be atomic.
  bool has_atomic_move = false;
  env->HasAtomicMove(persistent_cache_directory_, &has_atomic_move)
      .IgnoreError();
  if (!has_atomic_move) {
    LOG_EVERY_POW_2(WARNING)
        << "Filesystem for XLA persistent cache at "
        << persistent_cache_directory_
        << " does not support atomic moves.  Therefore the persistent cache is "

// ops within device cluster.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateDropWhileShapeInvariantInDeviceClusterPass();

// Creates a pass that moves writes to replicate invariant resource variables
// outside tf_device.replicate op.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateHoistReplicateInvariantResourceWritesPass();

      return WalkResult::advance();
    });

    if (!walk_result.wasInterrupted())
      head_outside_compiled_ops.insert(&cluster_op);
  }

  return head_outside_compiled_ops.takeVector();
}

// Moves head outside compiled ops into its own `tf_device.LaunchOp`
// computation before the cluster.
void CreateHeadComputation(OpBuilder* builder,
                           mlir::tf_device::ClusterOp cluster,