"bb",
		}
		for i, s := range d {
			id, inserted := m.PutString(s)
			if !inserted {
				t.Errorf("expected to have inserted string %q, but did not", s)
			}
			if id != uint64(i+1) {
				t.Errorf("expected string %q to have ID %d, but got %d instead", s, i+1, id)
			}
		}
		for i, s := range d {
			id, inserted := m.PutString(s)
			if inserted {
				t.Errorf("inserted string %q, but expected to have not done so", s)
			}

// be inserted to convert to well-formed matrix multiply; i.e., mhlo.dot_general
// -> tfl.batch_matmul(mhlo.transpose(mhlo.reshape(operand)), ...).
// Note:
// 1) Reshape/transpose are inserted because tfl.BatchMatMul requires
// size(contracting_dimensions) = 1 and size(output_dim) = 1, whereas
// mhlo.dot_general has no such restriction.

                return new ImmutableUniqueList<T>(set, array);
            }

            private Object[] shrinkArray() {
                if (array.length == inserted) {
                    return array;
                }
                Object[] newArray = new Object[inserted];
                System.arraycopy(array, 0, newArray, 0, inserted);
                return newArray;
            }

    List<Element<T>> getInserted() {
        return inserted;
    }

    @Override
    public boolean isEmpty() {
        for (Element<T> element : inserted) {
            if (element.size() != 0) {
                return false;
            }
        }
        return true;
    }

    @Override
    public boolean constantTimeIsEmpty() {
        return inserted.isEmpty();
    }

    @Override

	fmt.Printf("found %g at index %d in %v\n", x, i, a)

	x = 0.5
	i = sort.SearchFloat64s(a, x)
	fmt.Printf("%g not found, can be inserted at index %d in %v\n", x, i, a)
	// Output:
	// found 2 at index 1 in [1 2 3.3 4.6 6.1 7.2 8]
	// 0.5 not found, can be inserted at index 0 in [1 2 3.3 4.6 6.1 7.2 8]
}

// This example demonstrates searching for int in a list sorted in ascending order.
func ExampleSearchInts() {

	std	0,16(1)
	stdu	1,-32(1)

	// Save R2 in TOC save slot.
	std	2,24(1)

	// clobber R2
	li	2,0

	// Call type2_func. A call stub from notoc to toc should be inserted.
	bl	toc_func@notoc

	// Call libc random. A notoc plt stub should be inserted.
	bl	random@notoc

	// Return 0 to indicate the test ran.
	li	3,0

	// Restore R2
	ld	2,24(1)

	// Restore LR and pop stack
	addi	1,1,32

// RUN: stablehlo-quant-opt %s -split-input-file -stablehlo-insert-weight-param | FileCheck %s

// Test that q/dq pair with per-tensor quantization parameter is inserted
// between constant and XlaCallModule op with empty `weight_only_ptq` method
// and function name containing conv.

func.func @qdq_for_conv_weight_empty(%arg0: tensor<1x3x2x3xf32>) -> tensor<1x2x2x2xf32> attributes {tf._original_func_name = "main_0"} {

     */
    public abstract DirectoryProperty getRoot();

    /**
     * Source of snippets that can be inserted into the user manual
     */
    public abstract DirectoryProperty getSnippets();

    /**
     * Source of samples that can be inserted into the user manual
     *
     */
    public abstract DirectoryProperty getSamples();

    /**

    auto attr = func.getArgAttrOfType<FlatSymbolRefAttr>(
        i, "tf_saved_model.bound_input");
    if (!attr) continue;
    auto inserted = unique_bound_inputs.insert(std::make_pair(attr, i));
    if (inserted.second) continue;
    auto duplicate_arg = func.getArgument(i);
    auto original_arg = func.getArgument(unique_bound_inputs[attr]);
    duplicate_arg.replaceAllUsesWith(original_arg);

}

var fextras = [...]extra{
	// compiler frontend inserted calls (sysfunc)
	{"deferproc", 1},
	{"deferprocStack", 1},
	{"deferreturn", 1},
	{"newproc", 1},
	{"panicoverflow", 1},
	{"sigpanic", 1},

	// compiler backend inserted calls
	{"gcWriteBarrier", 1},
	{"duffzero", 1},
	{"duffcopy", 1},

	// assembler backend inserted calls
	{"morestack", 0},        // asm function, ABI0