@Test
                    public void testMultiply() {
                        Multiplier multiplier = new Multiplier();
                        Assert.assertEquals(1, multiplier.multiply(1, 1));
                        Assert.assertEquals(4, multiplier.multiply(2, 2));
                        Assert.assertEquals(2, multiplier.multiply(1, 2));
                    }

                    @Test

            abstract class Multiplier implements TransformAction<TransformParameters.None> {
                private final boolean showOutput = System.getProperty("showOutput") != null
                private final String target

                Multiplier(String target) {
                    if (showOutput) {
                        println("Creating multiplier")
                    }

namespace quant {

// Converts a double-precision floating-point multiplier to a quantized
// multiplier.
//
// Args:
//   double_multiplier: The double-precision floating-point multiplier.
//
// Returns:
//   A quantized multiplier, represented as a pair of integers: the quantized
//   multiplier and the shift amount. The shift amount is the number of bits
//   that the quantized multiplier should be shifted to the right before being
//   used.

                                                         multiplier.getType());
    if (!result_type) {
      return rewriter.notifyMatchFailure(mul_op, [&](::mlir::Diagnostic &diag) {
        diag << "entities 'filter, multiplier' failed to satisfy constraint: "
                "non-broadcastable operands";
      });
    }
    filter_value = filter.getValue();
    mul_value = multiplier.getValue();

//
//   (x - mean) * scale / sqrt(variance + epsilon) + offset
//
// Let multiplier = scale / sqrt(variance + epsilon),
// to compute
//   (x - mean) * scale / sqrt(variance + epsilon) + offset,
// is then to compute
//   (x * multiplier) + (offset - mean * multiplier).
//
// TODO(b/228916181): There is a known issue with this DDR rule that it doesn't

		}
	}
}

func TestEncoderDecoder(t *testing.T) {
	for _, multiplier := range []int{1, 128, 192} {
		for _, test := range encDecTests {
			input := bytes.Repeat(test.dec, multiplier)
			output := strings.Repeat(test.enc, multiplier)

			var buf bytes.Buffer
			enc := NewEncoder(&buf)

                        parameters.multiplier.set(2)
                    }
                    registerTransform(MakeColor) {
                        from.attribute(color, 'red')
                        to.attribute(color, 'green')
                        parameters.targetColor.set('green')
                        parameters.multiplier.set(1)
                    }
                }
            }

#include "absl/types/optional.h"

namespace mlir {
namespace quant {

using QuantizedMultiplier = std::pair<int32_t, int32_t>;
using QuantizedRange = std::pair<int32_t, int32_t>;

// Decompose double precision multiplier to integer multiplier and exponent.
//    double_multiplier = int_multiplier * 2 ^ (-31 + exponent)
// int_multiplier will be range of (2^31, 2^30].
QuantizedMultiplier QuantizeMultiplier(double double_multiplier);

                     (Arith_ConstantOp:$multiplier F32ElementsAttr:$mul_value)),
// TODO(karimnosseir): Add check for $conv is of rank 4.
      (TF_Conv2DOp $input,
          (TF_MulOp (Arith_ConstantOp $filter_value, (location $filter)),
                    (Arith_ConstantOp $mul_value, (location $multiplier)),
                    (location $mul)),

	qs := &queueSet{estimatedServiceDuration: time.Second}
	list := newRequestFIFO()

	update := func(we *queueSum, req *request, multiplier int) {
		we.InitialSeatsSum += multiplier * req.InitialSeats()
		we.MaxSeatsSum += multiplier * req.MaxSeats()
		we.TotalWorkSum += fcrequest.SeatSeconds(multiplier) * req.totalWork()
	}

	assert := func(t *testing.T, want, got *queueSum) {
		if !reflect.DeepEqual(want, got) {