context(), &result);
  EXPECT_EQ(status.code(), error::FAILED_PRECONDITION) << status.message();
}

// A SavedConcreteFunction whose outputs are fewer than its corresponding
// functiondef should cause an error.
TEST_F(SavedConcreteFunctionLoadingTest, TooFewOutputsInSavedConcreteFunction) {
  // `saved` has 0 inputs, 1 output
  SavedConcreteFunction saved;

//
// func castagnoliSSE42(crc uint32, p []byte) uint32
TEXT ·castagnoliSSE42(SB),NOSPLIT,$0
	MOVL crc+0(FP), AX  // CRC value
	MOVQ p+8(FP), SI  // data pointer
	MOVQ p_len+16(FP), CX  // len(p)

	// If there are fewer than 8 bytes to process, skip alignment.
	CMPQ CX, $8
	JL less_than_8

	MOVQ SI, BX
	ANDQ $7, BX
	JZ aligned

	// Process the first few bytes to 8-byte align the input.

// respect to t is
//
//	1 / NEQ(t) .
//
// To generalize from transmitting one packet at a time to executing C
// requests at a time, that derivative becomes
//
//	C / NEQ(t) .
//
// However, sometimes there are fewer than C requests available to
// execute.  For a given queue "q", let us also write "reqs(q, t)" for
// the number of requests of that queue that are executing at that
// time.  The total number of requests executing is sum[over q]

	// magnitude up to 2^{w-1} so that the nonzero digits are as
	// sparse as possible.  Intuitively, this "condenses" the
	// "mass" of the scalar onto sparse coefficients (meaning
	// fewer additions).

	basepointNafTable := basepointNafTable()
	var aTable nafLookupTable5
	aTable.FromP3(A)
	// Because the basepoint is fixed, we can use a wider NAF
	// corresponding to a bigger table.

        broadcast.add("event1", action)

        when:
        broadcast.source.event2(9, "param")

        then:
        0 * _._
    }

    def 'the Action can have fewer parameters than the event method'() {
        given:
        Action<Integer> action = Mock()
        broadcast.add("event2", action)

        when:
        broadcast.source.event2(1, "param")

        then:

      op->emitRemark("Quantization is skipped for ")
          << quantized_op->getName().getStringRef().str() << " because it has "
          << mlir::dyn_cast<DenseFPElementsAttr>(attr).size()
          << " elements which is fewer than the threshold("
          << quant_specs_.minimum_elements_for_weights << " elements).";
      return false;
    }

    if (is_per_channel_quantization) {
      quant_type = mlir::dyn_cast<quant::QuantizedType>(

	}
	// not halfway - digit tells all (x.mant has no trailing zeros)
	return x.mant[n] >= '5'
}

// round sets x to (at most) n mantissa digits by rounding it
// to the nearest even value with n (or fever) mantissa digits.
// If n < 0, x remains unchanged.
func (x *decimal) round(n int) {
	if n < 0 || n >= len(x.mant) {
		return // nothing to do
	}

	if shouldRoundUp(x, n) {
		x.roundUp(n)
	} else {

	if err != nil {
		panic(err)
	}
}

type SRVWriter struct{ ResponseWriter }

// AddSRV adds a SRV record. The target name must end in a period and
// be 63 bytes or fewer.
func (w SRVWriter) AddSRV(priority, weight, port uint16, target string) error {
	targetName, err := dnsmessage.NewName(target)
	if err != nil {
		return err
	}
	w.a.wrote = true

      if (!argument_to_index.count(r.get())) continue;

      int arg = argument_to_index.lookup(r.get());

      // If we see an arg as a result, and we're going
      // to remove that result, we can assume one fewer use.
      use_count[arg]--;

      return_to_operand.insert({i, arg});
      unused_results.set(i);
    }

    // Now mark all args for deletion that don't have uses anymore.

This translates into faster feedback for developers, and less money spent on the CI resources.
Faster builds also mean fewer commits being part of each build, which makes debugging issues more efficient.

Beginning with the build cache on CI is a good first step as the environment on CI agents is usually more stable and predictable than developer machines.