x,
            min=ops.convert_to_tensor(self._min[0]),
            max=ops.convert_to_tensor(self._max[0]),
            num_bits=8,
            narrow_range=False,
        )
        y = array_ops.fake_quant_with_min_max_vars(
            y,
            min=ops.convert_to_tensor(self._min[1]),
            max=ops.convert_to_tensor(self._max[1]),
            num_bits=8,

import assertk.assertions.containsExactly
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isGreaterThanOrEqualTo
import assertk.assertions.isIn
import assertk.assertions.isInstanceOf
import assertk.assertions.isLessThan
import assertk.assertions.isNotEmpty
import assertk.assertions.isNull
import assertk.assertions.isTrue
import assertk.fail
import java.io.File

	"ι":                            "\u03b9",
	"⨼":                           "\u2a3c",
	"¿":                          "\u00bf",
	"𝒾":                            "\U0001d4be",
	"∈":                            "\u2208",
	"⋹":                           "\u22f9",
	"⋵":                         "\u22f5",
	"⋴":                           "\u22f4",

<code>package math</code>, which exports function <code>Sin</code>, and
installed the compiled package in the file identified by
<code>"lib/math"</code>.
This table illustrates how <code>Sin</code> is accessed in files
that import the package after the
various types of import declaration.
</p>

<pre class="grammar">
Import declaration          Local name of Sin

import   "lib/math"         math.Sin

  // particularly seems to be the case for the control edges between _SOURCE
  // and _SINK that the Graph constructor inserts. Copy the input edges and
  // sort the edges, but only the control edges, not data edges!
  // TODO(jmolloy): We should probably just ignore _SOURCE and _SINK nodes.
  // They'll break roundtripping anyway unless we strip them when converting
  // back to graphdef.

^bb0(%arg0: tensor<? x f32>):
  // CHECK: "tfl.sin"(%arg0)
  %0 = "tfl.sin"(%arg0): (tensor<? x f32>) -> tensor<? x f32>
  func.return %0 : tensor<? x f32>
}

// -----

// test invalid Sin input
func.func @testSinWithWrongInputType(tensor<?xi32>) -> tensor<?xi32> {
^bb0(%arg0: tensor<?xi32>):
  // expected-error @+1 {{tfl.sin' op operand #0 must be tensor of 32-bit float values}}

  ...

    OpBuilder<(ins "Value":$cond, "Value":$x, "Value":$y),
    [{
    BuildSelectV2Op(&$_builder, $_state, cond, x, y);
  }]>];

  let hasOptions = 1;
}

def TFL_SinOp: TFL_Op<"sin", [
    Pure,
    TF_SameOperandsAndResultTypeResolveRef]> {
  let summary = "Sine operator";

  let description = [{
    Computes element-wise Sine of input
  }];

	_mo  = 784
	_mr  = 795
	_ms  = 799
	_mul = 806
	_my  = 817
	_nb  = 839
	_ne  = 849
	_nl  = 871
	_no  = 879
	_pa  = 925
	_pl  = 947
	_pt  = 960
	_ro  = 988
	_ru  = 994
	_sh  = 1031
	_si  = 1036
	_sk  = 1042
	_sl  = 1046
	_sq  = 1073
	_sr  = 1074
	_sv  = 1092
	_sw  = 1093
	_ta  = 1104
	_te  = 1121
	_th  = 1131
	_tl  = 1146
	_tn  = 1152
	_tr  = 1162
	_uk  = 1198
	_ur  = 1204

    }, {
     %e0 = "tf.Neg"(%arg1) : (tensor<2xf32>) -> tensor<2xf32>
     %e1 = "tf.Relu"(%arg1) : (tensor<2xf32>) -> tensor<2xf32>
     %e2 = "tf.Sin"(%arg1) : (tensor<2xf32>) -> tensor<2xf32>
     "tf.Yield"(%e0, %e1, %e2) : (tensor<2xf32>, tensor<2xf32>, tensor<2xf32>) -> ()
    }) { is_stateless = false} : (tensor<i1>) -> (tensor<2xf32>, tensor<2xf32>, tensor<2xf32>)