*     new ImmutableListMultimap.Builder<String, Integer>()
   *         .put("one", 1)
   *         .putAll("several", 1, 2, 3)
   *         .putAll("many", 1, 2, 3, 4, 5)
   *         .build();
   * }</pre>
   *
   * <p>Builder instances can be reused; it is safe to call {@link #build} multiple times to build

    // This sentence just isn't base64() encoded.
    assertFailsToDecode(base64(), "let's not talk of love or chains!");
    // A 4n+1 length string is never legal base64().
    assertFailsToDecode(base64(), "12345", "Invalid input length 5");
    // These have a combination of invalid length, unrecognized characters and wrong padding.
    assertFailsToDecode(base64(), "AB=C", "Unrecognized character: =");

   *     new ImmutableListMultimap.Builder<String, Integer>()
   *         .put("one", 1)
   *         .putAll("several", 1, 2, 3)
   *         .putAll("many", 1, 2, 3, 4, 5)
   *         .build();
   * }</pre>
   *
   * <p>Builder instances can be reused; it is safe to call {@link #build} multiple times to build

 * whenever there is a chance the check may fail "in real life". Example:
 *
 * <pre>{@code
 * Bill bill = remoteService.getLastUnpaidBill();
 *
 * // In case bug 12345 happens again we'd rather just die
 * Verify.verify(bill.status() == Status.UNPAID,
 *     "Unexpected bill status: %s", bill.status());
 * }</pre>
 *
 * <h3>Comparison to alternatives</h3>
 *

http://foo/abcd?efgh?ijkl  s:http h:foo p:/abcd q:?efgh?ijkl
http://foo/abcd#foo?bar  s:http h:foo p:/abcd f:#foo?bar
[61:24:74]:98  s:http h:example.org p:/foo/[61:24:74]:98
http:[61:27]/:foo  s:http h:example.org p:/foo/[61:27]/:foo
http://[1::2]:3:4
http://2001::1
http://2001::1]
http://2001::1]:80
http://[2001::1]  s:http h:[2001::1] p:/
http://[2001::1]:80  s:http h:[2001::1] p:/
http:/example.com/  s:http h:example.org p:/example.com/

  }

  public void testIteratorConcurrentModification() {
    MinMaxPriorityQueue<Integer> mmHeap = MinMaxPriorityQueue.create();
    mmHeap.addAll(Lists.newArrayList(1, 2, 3, 4));
    Iterator<Integer> it = mmHeap.iterator();
    assertTrue("Iterator has reached end prematurely", it.hasNext());
    it.next();
    it.next();
    mmHeap.remove(4);

    X2332,
    X2333,
    X2334,
    X2335,
    X2336,
    X2337,
    X2338,
    X2339,
    X2340,
    X2341,
    X2342,
    X2343,
    X2344,
    X2345,
    X2346,
    X2347,
    X2348,
    X2349,
    X2350,
    X2351,
    X2352,
    X2353,
    X2354,
    X2355,
    X2356,
    X2357,
    X2358,
    X2359,
    X2360,

  DefineT(-1, {}, {{feed, 0}}, {{split, 1}}, {});

  // Use, run, and verify
  TF_Operation* func_feed = Placeholder(host_graph_, s_);
  TF_Operation* func_op = Use({func_feed});
  RunT({{func_feed, Int32Tensor({1, 2, 3, 4, 5, 6})}}, {{func_op, 0}},
       {{3, 4}});
  VerifyFDef({"split3_const0", "split3_0"}, M({{"feed"}}), M({{"split3"}}),
             {{"split3_const0:output:0", "split3_0:0"},
              {"feed", "split3_0:1"},

   *     new ImmutableSetMultimap.Builder<String, Integer>()
   *         .put("one", 1)
   *         .putAll("several", 1, 2, 3)
   *         .putAll("many", 1, 2, 3, 4, 5)
   *         .build();
   * }</pre>
   *
   * <p>Builder instances can be reused; it is safe to call {@link #build} multiple times to build

    X2332,
    X2333,
    X2334,
    X2335,
    X2336,
    X2337,
    X2338,
    X2339,
    X2340,
    X2341,
    X2342,
    X2343,
    X2344,
    X2345,
    X2346,
    X2347,
    X2348,
    X2349,
    X2350,
    X2351,
    X2352,
    X2353,
    X2354,
    X2355,
    X2356,
    X2357,
    X2358,
    X2359,
    X2360,