# Consider if there is a way to check if activation fusion is properly
    # done in MLIR level.
    # Tests that the quantized graph outputs similar values. The rtol and atol
    # values are arbitrary.
    self.assertAllClose(new_outputs, expected_outputs, rtol=0.3, atol=0.2)

    # Due to other meta data, the compression is not exactly 1/4.
    self.assertLess(
        testing.get_size_ratio(

    # expected to be small.
    # The atol value is arbitrary.
    if not enable_per_channel_quantization:
      expected_outputs = model.conv(input_data)
      target_outputs = converted_model.signatures['serving_default'](
          input_tensor=ops.convert_to_tensor(input_data)
      )
      self.assertAllClose(target_outputs, expected_outputs, atol=0.06)

    if target_opset == quant_opts_pb2.XLA:

}

func Strtol(s string, base int) (int, error) {
	p := C.CString(s)
	n, err := C.strtol(p, nil, C.int(base))
	C.free(unsafe.Pointer(p))
	return int(n), err
}

func Atol(s string) int {
	p := C.CString(s)
	n := C.atol(p)
	C.free(unsafe.Pointer(p))
	return int(n)
}

func testConst(t *testing.T) {
	C.myConstFunc(nil, 0, nil)
}

func testEnum(t *testing.T) {

		return -int64(cutoff), rangeError(fnParseInt, s0)
	}
	n := int64(un)
	if neg {
		n = -n
	}
	return n, nil
}

// Atoi is equivalent to ParseInt(s, 10, 0), converted to type int.
func Atoi(s string) (int, error) {
	const fnAtoi = "Atoi"

	sLen := len(s)
	if intSize == 32 && (0 < sLen && sLen < 10) ||
		intSize == 64 && (0 < sLen && sLen < 19) {

qiulaidongfeng <******@****.***> 1714788079 +0000

******@****.*** <******@****.***> 1654492238 +0000

	processClump := func(idx int, emit bool) int {
		// Process func itself, plus anything else defined
		// on the same line
		atl := ues.atline[dentries[idx].line]
		for k := uint(0); k < atl; k++ {
			if emit {
				emitFunc(&dentries[idx], dcsites[idx], k, atl)
			}
			idx++
		}
		// now process any closures it contains
		ncl := 0
		for idx < nd {
			nfn := dentries[idx].fname

var atomsToAttrs = map[atom.Atom]sets.String{
	atom.A:          sets.NewString("href"),
	atom.Applet:     sets.NewString("codebase"),
	atom.Area:       sets.NewString("href"),
	atom.Audio:      sets.NewString("src"),
	atom.Base:       sets.NewString("href"),
	atom.Blockquote: sets.NewString("cite"),
	atom.Body:       sets.NewString("background"),
	atom.Button:     sets.NewString("formaction"),

        options {
            buildAST = true;
        }

        expr:   mexpr (PLUS^ mexpr)* SEMI!
            ;

        mexpr
            :   atom (STAR^ atom)*
            ;

        atom:   INT
            ;"""
        expect:
        "org.acme" == new MetadataExtracter().getPackageName(new StringReader(grammar))
    }

            options {
                buildAST = true;
            }

            expr:   mexpr (PLUS^ mexpr)* SEMI!
                ;

            mexpr
                :   atom (STAR^ atom)*
                ;

            atom:   INT
                ;"""

        file("grammar-builder/src/main/antlr/AnotherGrammar.g") << """
            header {
                package org.acme;
            }