func (s *scratch) add(c byte) {
	if s.fill+1 >= cap(s.data) {
		s.grow()
	}

	s.data[s.fill] = c
	s.fill++
}

// append encoded rune to scratch buffer
func (s *scratch) addRune(r rune) int {
	if s.fill+utf8.UTFMax >= cap(s.data) {
		s.grow()
	}

	n := utf8.EncodeRune(s.data[s.fill:], r)
	s.fill += n
	return n

	c = d.next()
	if !utf16.IsSurrogate(r) || c != '\\' {
		d.scratch.addRune(r)
		goto scan
	}
	if c = d.next(); c != 'u' {
		d.scratch.addRune(r)
		goto scan_esc
	}

	r2 := d.u4()
	if r2 < 0 {
		return "", d.mkError(ErrSyntax, "in unicode escape sequence")
	}

	// write surrogate pair
	d.scratch.addRune(utf16.DecodeRune(r, r2))
	c = d.next()
	goto scan
}

                    addRule(IncubatingInternalInterfaceAddedRule, publicApiRuleParams)
                    addRule(MethodsRemovedInInternalSuperClassRule, publicApiRuleParams)
                    addRule(BinaryBreakingSuperclassChangeRule, publicApiRuleParams)

                    addRule(BinaryBreakingChangesRule, ruleParams)
                    addRule(NullabilityBreakingChangesRule, ruleParams)

      ImmutableLongArray iia = builder.build();
      for (int j = 0; j < iia.length(); j++) {
        assertThat(iia.get(j)).isEqualTo((long) j);
      }
    }
  }

  private enum BuilderOp {
    ADD_ONE {
      @Override
      void doIt(ImmutableLongArray.Builder builder, AtomicLong counter) {
        builder.add(counter.getAndIncrement());
      }
    },
    ADD_ARRAY {
      @Override

      ImmutableDoubleArray iia = builder.build();
      for (int j = 0; j < iia.length(); j++) {
        assertThat(iia.get(j)).isEqualTo((double) j);
      }
    }
  }

  private enum BuilderOp {
    ADD_ONE {
      @Override
      void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
        builder.add(counter.getAndIncrement());
      }
    },
    ADD_ARRAY {
      @Override

      ImmutableLongArray iia = builder.build();
      for (int j = 0; j < iia.length(); j++) {
        assertThat(iia.get(j)).isEqualTo((long) j);
      }
    }
  }

  private enum BuilderOp {
    ADD_ONE {
      @Override
      void doIt(ImmutableLongArray.Builder builder, AtomicLong counter) {
        builder.add(counter.getAndIncrement());
      }
    },
    ADD_ARRAY {
      @Override

		loi.NextMarker = opts.encodeMarker(last.Name)
		loi.NextVersionIDMarker = last.VersionID
	}
	return loi, nil
}

func maxKeysPlusOne(maxKeys int, addOne bool) int {
	if maxKeys < 0 || maxKeys > maxObjectList {
		maxKeys = maxObjectList
	}
	if addOne {
		maxKeys++
	}
	return maxKeys
}

				} else {
					replicationConfig = replication.Config{}
				}
				if err == nil {
					err = replicationConfig.AddRule(opts)
				}
			} else {
				err = replicationConfig.EditRule(opts)
			}
		default:
			err = replicationConfig.AddRule(opts)
		}
		if err != nil {
			return c.annotatePeerErr(peer.Name, "Error adding bucket replication rule", err)
		}

t.Run(fmt.Sprintf("line %d", lineNum), func(t *testing.T) { if A == "0" || B == "0" { t.Skip("skipping test with zero input") } if LCM == "1" { t.Skip("skipping test with LCM=1") } p, _ := bigmod.NewModulus(addOne(decodeHex(t, A))) a, _ := bigmod.NewNat().SetBytes(decodeHex(t, A), p) q, _ := bigmod.NewModulus(addOne(decodeHex(t, B))) b, _ := bigmod.NewNat().SetBytes(decodeHex(t, B), q) gcd, err := bigmod.NewNat().GCDVarTime(a, b) // GCD doesn't work if a and b are both even, but LCM handles it. if err == nil...

t.Run(fmt.Sprintf("line %d", lineNum), func(t *testing.T) { if A == "0" || B == "0" { t.Skip("skipping test with zero input") } if LCM == "1" { t.Skip("skipping test with LCM=1") } p, _ := bigmod.NewModulus(addOne(decodeHex(t, A))) a, _ := bigmod.NewNat().SetBytes(decodeHex(t, A), p) q, _ := bigmod.NewModulus(addOne(decodeHex(t, B))) b, _ := bigmod.NewNat().SetBytes(decodeHex(t, B), q) gcd, err := bigmod.NewNat().GCDVarTime(a, b) // GCD doesn't work if a and b are both even, but LCM handles it. if err == nil...