// last byte of that block decrypted to the block size.
	//
	// See also macAndPaddingGood logic below.
	paddingLen &= good

	toRemove = int(paddingLen) + 1
	return
}

func roundUp(a, b int) int {
	return a + (b-a%b)%b
}

// cbcMode is an interface for block ciphers using cipher block chaining.
type cbcMode interface {
	cipher.BlockMode
	SetIV([]byte)
}

	if iter.next >= len(iter.closureVars) {
		return nil, nil, 0
	}
	n = iter.closureVars[iter.next]
	typ = n.Type()
	if !n.Byval() {
		typ = types.NewPtr(typ)
	}
	iter.next++
	offset = types.RoundUp(iter.offset, typ.Alignment())
	iter.offset = offset + typ.Size()
	return n, typ, offset

    assertFailsWith<EOFException> {
      source.buffer().readByteString(101)
    }
  }

  @Test fun blockedStreamDoesntStarveNewStream() {
    val framesThatFillWindow =
      roundUp(Settings.DEFAULT_INITIAL_WINDOW_SIZE, peer.maxOutboundDataLength())

    // Write the mocking script. This accepts more data frames than necessary!
    peer.sendFrame().settings(Settings())

	var callArgs []*ssa.Value
	var callArgTypes []*types.Type

	for _, arg := range args {
		t := arg.Type
		off = types.RoundUp(off, t.Alignment())
		size := t.Size()
		callArgs = append(callArgs, arg)
		callArgTypes = append(callArgTypes, t)
		off += size
	}
	off = types.RoundUp(off, int64(types.RegSize))

	// Issue call
	var call *ssa.Value

		// just to avoid performance penalties when loading from
		// the constant pool across a cache line.
		c.pool.size = roundUp(c.pool.size, 8)
	}
	c.pool.size += uint32(sz)
	p.Pool = t
}

// roundUp rounds up x to "to".
func roundUp(x, to uint32) uint32 {
	if to == 0 || to&(to-1) != 0 {
		log.Fatalf("rounded up to a value that is not a power of 2: %d\n", to)
	}

            lines.times { l ->
                def foundOp = children.find {
                    it.progress.find {
                        it.hasDetailsOfType(LogEventBuildOperationProgressDetails) &&
                            it.details.message == "o: $i $l"
                    }
                }

                assert foundOp: "o: $i $l"
            }
        }
    }

        TypeID::get<TF::ReverseSequenceOp>(),
        TypeID::get<TF::RightShiftOp>(),
        TypeID::get<TF::RintOp>(),
        TypeID::get<TF::RollOp>(),
        TypeID::get<TF::RoundOp>(),
        TypeID::get<TF::SegmentSumV2Op>(),
        TypeID::get<TF::SegmentProdV2Op>(),
        TypeID::get<TF::SegmentMinV2Op>(),
        TypeID::get<TF::SegmentMaxV2Op>(),
        TypeID::get<TF::SelectV2Op>(),

        /*operands=*/fcast_op.getResult(),
        /*attributes=*/avg_pool_op->getAttrs());

    // Cast back to the storage type after AvgPool op.
    auto round_val = rewriter.create<TF::RoundOp>(
        sc_op.getLoc(), float_avg_pool_op.getOutput());
    auto icast_op = rewriter.create<TF::CastOp>(
        sc_op.getLoc(), q_result_type.clone(qtype.getStorageType()), round_val);

             ConstOp::getOperationName(), MulOp::getOperationName(),
             FloorOp::getOperationName(), ClipByValueOp::getOperationName(),
             DivOp::getOperationName(), RoundOp::getOperationName()}) {}

  LogicalResult matchAndRewrite(Operation *src_op,
                                PatternRewriter &rewriter) const override {
    auto op = cast<FakeQuantWithMinMaxVarsOp>(src_op);

INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(Relu6GradOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(ReluGradOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(RintOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(RoundOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(RsqrtOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(RsqrtGradOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(SeluOp);
INFER_RETURN_TYPE_COMPONENTS_FROM_OPERANDS(SeluGradOp);