FUCOMI  F0, F1       // compare F0 to F1
	JCC     2(PC)        // jump if F0 >= F1
	FXCHD   F0, F1       // F0=|p| (larger), F1=|q| (smaller)
	FTST                 // compare F0 to 0
	FSTSW	AX
	ANDW    $0x4000, AX
	JNE     10(PC)       // jump if F0 = 0
	FXCHD   F0, F1       // F0=q (smaller), F1=p (larger)
	FDIVD   F1, F0       // F0=q(=q/p), F1=p
	FMULD   F0, F0       // F0=q*q, F1=p
	FLD1                 // F0=1, F1=q*q, F2=p

	if o == nil {
		return
	}

	fs.Int32Var(&o.ConcurrentEndpointSyncs, "concurrent-endpoint-syncs", o.ConcurrentEndpointSyncs, "The number of endpoint syncing operations that will be done concurrently. Larger number = faster endpoint updating, but more CPU (and network) load")

    byte[] key = fillByteArray(80, 0xaa);
    String data = "Test Using Larger Than Block-Size Key - Hash Key First";

    checkSha1("aa4ae5e15272d00e95705637ce8a3b55ed402112", key, data);
  }

  public void testRfc2202_hmacSha1_case7() {
    byte[] key = fillByteArray(80, 0xaa);
    String data = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data";

//        def larger = checkBaselineVersion({ it.usesLessMemoryThan(current) }, { it.getMemoryStatsAgainst(displayName, current) })
//        if (slower && larger) {
//            throw new AssertionError("$slower\n$larger")
//        }
        if (slower) {
            throw new AssertionError(slower)
        }
//        if (larger) {
//            throw new AssertionError(larger)
//        }

    void put(R row, C column, V value, BinaryOperator<V> merger) {
      MutableCell<R, C, V> oldCell = table.get(row, column);
      if (oldCell == null) {
        MutableCell<R, C, V> cell = new MutableCell<>(row, column, value);
        insertionOrder.add(cell);
        table.put(row, column, cell);
      } else {
        oldCell.merge(value, merger);
      }
    }

	// Filter to only include don't cares and hints with a single NUMA node.
	singleNumaHints := filterSingleNumaHints(filteredHints)

	merger := NewHintMerger(p.numaInfo, singleNumaHints, p.Name(), p.opts)
	bestHint := merger.Merge()

	if bestHint.NUMANodeAffinity.IsEqual(p.numaInfo.DefaultAffinityMask()) {
		bestHint = TopologyHint{nil, bestHint.Preferred}
	}

    }

    @Test
    fun `doesn't choke on left being larger than right`() {

        val a = listOf("a", "b", "c", "0", "1", "d")
        val b = listOf("a", "b", "c", "3", "d")

        assertThat(
            commonPrefixOf(listOf(a, b)),
            equalTo(listOf("a", "b", "c"))
        )
    }

    @Test
    fun `doesn't choke on right being larger than left`() {

        val a = listOf("a", "b", "c", "0", "d")

// available.
//
//go:noescape
func updateVX(state *macState, msg []byte)

// mac is a replacement for macGeneric that uses a larger buffer and redirects
// calls that would have gone to updateGeneric to updateVX if the vector
// facility is installed.
//
// A larger buffer is required for good performance because the vector
// implementation has a higher fixed cost per call than the generic
// implementation.

                    .build(Build.newBuilder().plugins(plugins).build())
                    .build();
            model.update(merger.merge(model.getDelegate(), lifecycleModel));
        }
    }

    /**
     *  The domain-specific model merger for lifecycle bindings
     */
    protected static class LifecycleBindingsMerger extends MavenModelMerger {

          saved_model::GetWriteVersion(*saved_model_proto))
          .IncrementBy(1);
    }
    return result;
  }

  if (!IS_OSS) {
    // Only use Merger outside of OSS.
    // Placeholder for protosplitter merger call.
  }

  return Status(
      absl::StatusCode::kNotFound,
      strings::StrCat("Could not find SavedModel .pb or .pbtxt at supplied "