if err := os.Mkdir(outdir, 0777); err != nil {
		t.Fatalf("can't create outdir %s: %v", outdir, err)
	}

	// Merge the two dirs into a final result.
	ins := fmt.Sprintf("-i=%s,%s", indir1, indir2)
	out := fmt.Sprintf("-o=%s", outdir)
	margs := []string{ins, out}
	lines := runToolOp(t, s, "merge", margs)
	if len(lines) != 0 {
		t.Errorf("merge run produced %d lines of unexpected output", len(lines))
		dumplines(lines)

}
.configuration h3 {
    cursor: pointer;
}
.configuration h3 ins {
    background-image: url(../images/d.png); background-repeat:no-repeat; background-color:white;
    background-position: -18px 0;
    display: inline-block;
    width: 18px;
    height: 18px;
    position: relative;
    top: 4px;
}
.configuration h3.closed  ins {
    background-position: 0 0;
}
#dependencies {
    margin-right: 30px;
}

  let printer = "$_printer << '[' << $_self << ']'";
}

def DimensionMetadataAttr : AttrDef<TFL_Dialect, "DimensionMetadata"> {
  let mnemonic = "dimension_metadata";
  let parameters = (ins
      TFL_DimensionTypeAttr:$format,
      "int32_t":$dense_size,
      I32ArrayParameter:$segments,
      I32ArrayParameter:$indices
  );
  let summary = "Dimension metadata.";

            res.setEntry(resEntry);

            res.setScope(requestedScope);

            for (MetadataGraphVertex v : vertices) {
                final List<MetadataGraphEdge> ins = graph.getIncidentEdges(v);
                final MetadataGraphEdge edge = cleanEdges(v, ins, requestedScope);

                if (edge == null) { // no edges - don't need this vertex anymore
                    if (entry.equals(v)) { // unless it's an entry point.

	case *md.List:
		dumpBlocks(b.Items, depth+1)
	case *md.Item:
		dumpBlocks(b.Blocks, depth+1)
	default:
		// TODO(jba): additional cases as needed.
	}
}

func dumpInlines(ins []md.Inline, depth int) {
	for _, in := range ins {
		switch in := in.(type) {
		case *md.Plain:
			dprintf(depth, "Plain(%q)\n", in.Text)
		case *md.Code:
			dprintf(depth, "Code(%q)\n", in.Text)
		case *md.Link:
			dprintf(depth, "Link:\n")

    x_sum = math_ops.Add(x_sum, x[i])
  return x_sum


@composite.Composite('TestInputNOp')
def _tfr_control_flow_tensor_list_size(ins):
  n = len(ins)
  if n == 0:
    return array_ops.Const(value=[[0, 1], [2, 3]], dtype=dtypes.int64)
  else:
    return math_ops.AddN(ins)


#--- test fn for tf ops ---


@composite.Composite('TestComplexTFOp')
def _tfr_tf_ops_complex(lhs, rhs):

        }

        return new StreamResponse(osddFile.getName()).contentType(contentType + "; charset=" + encoding).stream(out -> {
            try (InputStream ins = new FileInputStream(osddFile)) {
                out.write(ins);
            }
        });
    }

    public void setOsddPath(final String osddPath) {
        this.osddPath = osddPath;
    }

o replaceSchemaMap.dfprop

Properties for documents:
o documentMap.dfprop

Properties for non-functional adjustments:
o sourceCopyright.dfprop
o infraMap.dfprop (manual making)

Properties for plug-ins:
o freeGenMap.dfprop (manual making)
o lastafluteMap.dfprop (manual making)

        assertEquals("text/xml; charset=UTF-8", streamResponse.getContentType());
        streamResponse.getStreamCall().callback(new WrittenStreamOut() {

            @Override
            public void write(final InputStream ins) throws IOException {
                assertEquals("""
                        <?xml version="1.0" encoding="UTF-8"?>
                        <OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">

		}
		f := types.NewField(src.NoXPos, nil, t)
		fields[k] = f
	}
	s := types.NewStruct(fields)
	return s
}

func mkFuncType(rcvr *types.Type, ins []*types.Type, outs []*types.Type) *types.Type {
	q := typecheck.Lookup("?")
	inf := []*types.Field{}
	for _, it := range ins {
		inf = append(inf, mkParamResultField(it, q, ir.PPARAM))
	}
	outf := []*types.Field{}
	for _, ot := range outs {