//
//     ```
//     e^(x+iy) = e^x * e^iy = e^x * (cos y + i sin y)
//     ```
//
//     Let's consider complex number 1+1j as an example.
//     e^1 * (cos 1 + i sin 1) = 2.7182818284590 * (0.54030230586+0.8414709848j)
//
//     ```python
//     x = tf.constant(1 + 1j)
//     tf.math.exp(x) ==> 1.4686939399158851+2.2873552871788423j
//     ```

  add_attrs(g.node());

  auto out0 = ops::_Retval(scope.WithOpName("b_identity_0_retval_RetVal"),
                           b_identity, 0);
  auto out1 = ops::_Retval(scope.WithOpName("e_0_retval_RetVal"), e, 1);
  auto out2 = ops::_Retval(scope.WithOpName("g_0_retval_RetVal"), g, 2);
  auto out3 =
      ops::_Retval(scope.WithOpName("readu_0_retval_RetVal"), read_u, 3);

00000300  60 d6 83 e6 ab 08 77 a4  f9 73 e5 d8 cb 66 9f 41  |`.....w..s...f.A|
00000310  00 15 2c 09 0e ad 16 02  6c 06 5f bc bf 47 f1 5a  |..,.....l._..G.Z|
00000320  85 97 ab 88 e8 45 b0 31  96 ad 56 00 97 59 17 03  |.....E.1..V..Y..|
00000330  03 00 99 5e 77 80 46 1d  2f 47 9f b3 43 4d a6 2b  |...^w.F./G..CM.+|
00000340  e9 f7 72 a2 d0 c6 69 7c  df 5d ce a0 3b 89 e2 69  |..r...i|.]..;..i|

//                          = log(6.3*5.3*4.3*3.3*2.3) + lgamma(2.3)
//   2. Polynomial approximation of lgamma around its
//      minimum (ymin=1.461632144968362245) to maintain monotonicity.
//      On [ymin-0.23, ymin+0.27] (i.e., [1.23164,1.73163]), use
//              Let z = x-ymin;
//              lgamma(x) = -1.214862905358496078218 + z**2*poly(z)
//              poly(z) is a 14 degree polynomial.

                    bool1 = "${1 > 2}"
                    bool2 = "${2 > 1}"
                    theBoolean = "${3 > 2}"
                    theDouble = "${Math.PI - 1}"
                    thedouble = "${Math.E - 1}"
                    thefloat = "${Math.PI - 2}"
                    theFloat = "${Math.E - 2}"
                    theint = "${1 + 2}"
                    theInteger = "${3 + 5}"

ner.removeChild(this.fakeElem),this.fakeElem=null)}},{key:"selectTarget",value:function(){this.selectedText=(0,c.default)(this.target),this.copyText()}},{key:"copyText",value:function(){var e=void 0;try{e=document.execCommand(this.action)}catch(t){e=!1}this.handleResult(e)}},{key:"handleResult",value:function(t){this.emitter.emit(t?"success":"error",{action:this.action,text:this.selectedText,trigger:this.trigger,clearSelection:this.clearSelection.bind(this)})}},{key:"clearSelection",value:functi...

000002b0  3e 9b 3b 4f 90 0f d2 9b  50 11 fe df 1f 12 f2 d9  |>.;O....P.......|
000002c0  0d 89 bc 6c 01 93 45 ca  b8 3c 09 cf b2 01 e9 99  |...l..E..<......|
000002d0  87 fb 1d ac 91 7f 77 a2  21 5e 07 5e 65 3b ec 31  |......w.!^.^e;.1|
000002e0  d7 b5 b9 1d 88 c8 82 f5  03 a9 37 e8 b9 02 42 01  |..........7...B.|
000002f0  78 c4 90 fb e3 7f 5a 7a  66 0a 44 f5 66 0e 1e ac  |x.....Zzf.D.f...|

                && ms1.comparator().equals(ms2.comparator());
    CollectorTester.of(
            ImmutableSortedMultiset.<String, String>toImmutableSortedMultiset(
                String.CASE_INSENSITIVE_ORDER, e -> e, e -> 1),
            equivalence)
        .expectCollects(ImmutableSortedMultiset.emptyMultiset(String.CASE_INSENSITIVE_ORDER))
        .expectCollects(
            ImmutableSortedMultiset.orderedBy(String.CASE_INSENSITIVE_ORDER)

   * encounter order.
   *
   * @since 21.0
   */
  public static <E> Collector<E, ?, ImmutableMultiset<E>> toImmutableMultiset() {
    return CollectCollectors.toImmutableMultiset(Function.identity(), e -> 1);
  }

  /**
   * Returns a {@code Collector} that accumulates elements into an {@code ImmutableMultiset} whose
   * elements are the result of applying {@code elementFunction} to the inputs, with counts equal to

            a,
            b1,
            c,
            b2);
    collector = ImmutableMultiset.toImmutableMultiset(e -> e, e -> 1);
    CollectorTester.of(collector, equivalence)
        .expectCollects(
            ImmutableMultiset.<TypeWithDuplicates>builder().add(a).addCopies(b1, 2).add(c).build(),
            a,
            b1,