&& m == int32(1<<8+umagic8(c).m) && s == 8+umagic8(c).s
  && x.Op != OpConst8 && udivisibleOK8(c)
 => (Leq8U
			(RotateLeft8 <typ.UInt8>
				(Mul8 <typ.UInt8>
					(Const8 <typ.UInt8> [int8(udivisible8(c).m)])
					x)
				(Const8 <typ.UInt8> [int8(8-udivisible8(c).k)])
				)
			(Const8 <typ.UInt8> [int8(udivisible8(c).max)])
		)

(Eq16 x (Mul16 (Const16 [c])
  (Trunc64to16
    (Rsh64Ux64

    if (input_batch != ShapedType::kDynamic &&
        input_batch % (block_size * block_size) != 0) {
      return op.emitOpError()
             << "requires input batch (dimension 0) to be evenly divisible "
                "by (block_size * block_size), but got input batch "
             << input_batch << " and block_size " << block_size;
    }

    input_shape.assign(input_type.getShape().begin(),

    return
  }

  // Test that map_outside_compilation's inputs shapes are divisible by num_cores_per_replica.
  func.func @map_outside_compilation_div_num_cores_per_replica() -> () {
    "tf_device.cluster"() ({
      %0 = "tf.OpA"() : () -> tensor<3xi64>
      // expected-error @+1 {{divisible by num_cores_per_replica}}

                            << kernel_output_features << ") to be divisible by "
                            << "feature_group_count (value "
                            << feature_group_count_val << ").\n";
  }
  if (input_batch % batch_group_count != 0) {
    return op.emitOpError()
           << "Expected input batch dimension (value " << input_batch
           << " ) to be divisible by batch_group_count (value "

}

// -----

func.func @testConv2D(%arg0: tensor<256x32x32x3xf32>, %arg1: tensor<3x3x2x16xf32>) -> tensor<256x32x32x16xf32> {
  // expected-error @+1 {{requires the number of input channels to be divisible by the number of filter input channels; found 3 and 2, respectively}}
  %0 = "tf.Conv2D"(%arg0, %arg1) {padding = "SAME", strides = [1, 1, 1, 1]} : (tensor<256x32x32x3xf32>, tensor<3x3x2x16xf32>) -> tensor<256x32x32x16xf32>

  if (op.getNumResults() == 0) return failure();

  if (input_dim_size % op.getNumResults() != 0)
    return op.emitOpError("dimension #")
           << *dim_index << " not divisible by the number of result tensors";

  return success();
}

//===----------------------------------------------------------------------===//
// SplitVOp

    // expected-error@+1 {{incorrect input sharding configuration received. 1-th dimension of the input must be evenly divisible by 4}}

    %strides = "tf.Const"() {value = dense<[3, 1, 1]> : tensor<3xi32>} : () -> tensor<3xi32>
    // expected-error @below {{'tf.XlaConvV2' op Expected output feature dimension (value 9) to be divisible by feature_group_count (value 2).}}

func generate(ch chan<- int) {
	for i := 2; ; i++ {
		ch <- i  // Send 'i' to channel 'ch'.
	}
}

// Copy the values from channel 'src' to channel 'dst',
// removing those divisible by 'prime'.
func filter(src <-chan int, dst chan<- int, prime int) {
	for i := range src {  // Loop over values received from 'src'.
		if i%prime != 0 {
			dst <- i  // Send 'i' to channel 'dst'.
		}

Organs of Sense are not for enabling the Soul to perceive the Species of Things in its Sensorium, but only for conveying them thither; and God has no need of such Organs, he being every where present to the Things themselves. And since Space is divisible _in infinitum_, and Matter is not necessarily in all places, it may be also allow'd that God is able to create Particles of Matter of several Sizes and Figures, and in several Proportions to Space, and perhaps of different Densities and Forces, and...