}

    /**
     * Parses a sequence of XML elements and converts them to the appropriate array type.
     *
     * @param parser The XML parser
     * @return Converted array instance
     */
    private Object parseArray(final MXParser parser, final TypeLiteral<?> toType) throws Exception {
        // convert to a collection first then convert that into an array

                                  quantizedElementType, converter);
    outConvertedType = converted.getType();
    return converted;
  }
  // Nothing else matched: try to convert a primitive.
  return convertPrimitiveValueAttr(realValue, quantizedElementType, converter,
                                   outConvertedType);
}

/// Convert an attribute from a type based on

def QuantConvertConst : Pass<"quant-convert-const", "func::FuncOp"> {
  let summary = "Converts constants followed by qbarrier to actual quantized "
                "values";
  let constructor = "mlir::quantfork::createConvertConstPass()";
}

def QuantConvertSimulatedQuant
    : Pass<"quant-convert-simulated-quantization", "func::FuncOp"> {
  let summary = "Converts training-time simulated quantization ops to "

	if milliCPU == 0 {
		return
	}

	// we then convert your milliCPU to a value normalized over a period
	quota = (milliCPU * period) / milliCPUToCPU

	// quota needs to be a minimum of 1ms.
	if quota < minQuotaPeriod {
		quota = minQuotaPeriod
	}

	return
}

// sharesToMilliCPU converts CpuShares (cpu.shares) to milli-CPU value

func Run(x int) int {
  return 1
}
`

// toSymbolV1 converts a package path using the original mangling scheme.
func toSymbolV1(ppath string) string {
	clean := func(r rune) rune {
		switch {
		case 'A' <= r && r <= 'Z', 'a' <= r && r <= 'z',
			'0' <= r && r <= '9':
			return r
		}
		return '_'
	}
	return strings.Map(clean, ppath)
}

// toSymbolV2 converts a package path using the second mangling scheme.

    }

    def "converts to OutgoingVariant when nothing defined"() {
        expect:
        def variants = getOutgoingVariants(publications)
        variants.size() == 1

        def child = variants.first()
        child.displayName == displayName
        child.attributes == ImmutableAttributes.EMPTY
        child.artifacts == allArtifacts
    }

    def "converts to OutgoingVariant when artifacts declared"() {

  "CreateXlaDotV2OpFromTfEinsumOp($_builder, $_loc, $0...)">;

def IsEinsumOpSupported : Constraint<
  CPred<"IsEinsumOpSupported($0, $1, $2)">,
  "Check if the given einsum op could be converted into a XlaDotV2 op.">;

// Converts inlined Conv2D pattern to TF XlaConvV2 op. This pattern doesn't
// support non-constant weights.
def ConvertTFConv2DToXLAConvOp : Pat<
  (TF_Conv2DOp:$conv

  module will be written (default: stdout).


### Examples

* To convert [microsoft/resnet-50](https://huggingface.co/microsoft/resnet-50)
model to StableHLO with static input shape `4x3x224x224` for input argument with
type `tensor<?x3x224x224xf32>`.

```bash
tf-to-stablehlo-translate <saved-model-path> --input-arg-shapes=4,3,224,224
```

* To convert

func (ls Set) Get(label string) string {
	return ls[label]
}

// AsSelector converts labels into a selectors. It does not
// perform any validation, which means the server will reject
// the request if the Set contains invalid values.
func (ls Set) AsSelector() Selector {
	return SelectorFromSet(ls)
}

// AsValidatedSelector converts labels into a selectors.
// The Set is validated client-side, which allows to catch errors early.

func AsStringArray(files ...string) ([]string, error) {
	out := make([]string, 0, len(files))
	for _, f := range files {
		b, err := AsBytes(f)
		if err != nil {
			return nil, err
		}
		out = append(out, string(b))
	}
	return out, nil
}

// AsStringArrayOrFail calls AsStringOrFail and then converts to string.