x = 0 // Last resort, just write zero
		f.err = ErrFieldTooLong
	}

	s := strconv.FormatInt(x, 8)
	// Add leading zeros, but leave room for a NUL.
	if n := len(b) - len(s) - 1; n > 0 {
		s = strings.Repeat("0", n) + s
	}
	f.formatString(b, s)
}

// fitsInOctal reports whether the integer x fits in a field n-bytes long
// using octal encoding with the appropriate NUL terminator.

            steps {
                preBuildSteps()
                killProcessStep(buildTypeThis, KILL_ALL_GRADLE_PROCESSES, os)
                substDirOnWindows(os)

                repeat(if (performanceTestBuildSpec.type == PerformanceTestType.flakinessDetection) 2 else 1) { repeatIndex: Int ->
                    gradleWrapper {
                        name = "GRADLE_RUNNER${if (repeatIndex == 0) "" else "_2"}"

    if (!commaPrefixed && (commaSuffixed || exhausted())) {
      result.add(
        Challenge(
          schemeName,
          Collections.singletonMap<String, String>(null, peek + "=".repeat(eqCount)),
        ),
      )
      peek = null
      continue
    }

    // It's a series of parameter names and values.
    val parameters = mutableMapOf<String?, String>()

  int count;

  @Param({"0", "1", "16", "32", "100"})
  int componentLength;

  private Iterable<String> components;

  @BeforeExperiment
  void setUp() {
    String component = Strings.repeat("a", componentLength);
    String[] raw = new String[count];
    Arrays.fill(raw, component);
    components = Arrays.asList(raw);
  }

  /** {@link Joiner} with a string delimiter. */
  @Benchmark

                for ( int i = 0; i < 5; i++ ) {
                    // each entry 94 byte + 2 * name length
                    // = 128 byte per entry
                    try ( SmbResource r = f.resolve(String.format("%04x%s", i, repeat('X', 13))) ) {
                        r.createNewFile();
                    }
                }
                // == 5*128 = 640

                // . and .. entries = 200 byte (includes alignment)

	return b
}

// Despite being an exported symbol,
// Repeat is linknamed by widely used packages.
// Notable members of the hall of shame include:
//   - gitee.com/quant1x/num
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
// Note that this comment is not part of the doc comment.
//
//go:linkname Repeat

// Repeat returns a new byte slice consisting of count copies of b.
//

  - If there are any errors, read the error and fix your code.
  - IMPORTANT NOTE: if the first import fails, you have to select and apply `Synchronization disabled`, then repeat the step above.
    Otherwise, TeamCity complains "Can't find the previous revision, please commit current settings first".

		panic("Negative length passed to DummyDataGen!")
	}
	if skipOffset < 0 {
		panic("Negative rotations are not allowed")
	}

	skipOffset %= int64(len(alphabets))
	const multiply = 100
	as := bytes.Repeat(alphabets, multiply)
	b := as[skipOffset : skipOffset+int64(len(alphabets)*(multiply-1))]
	return &DummyDataGen{
		length: totalLength,
		b:      b,
	}
}

func (d *DummyDataGen) Read(b []byte) (n int, err error) {

  @JvmStatic
  fun headerEntries(vararg elements: String?): List<Header> {
    return List(elements.size / 2) { Header(elements[it * 2]!!, elements[it * 2 + 1]!!) }
  }

  @JvmStatic
  fun repeat(
    c: Char,
    count: Int,
  ): String {
    val array = CharArray(count)
    Arrays.fill(array, c)
    return String(array)
  }

  /**

# specifically. Use your best judgment to keep the scripts in this directory
# lean and easy to follow. When in doubt, remember that for CI scripts, "keep it
# simple" is MUCH more important than "don't repeat yourself."

# -e: abort script if one command fails
# -u: error if undefined variable used
# -x: log all commands
# -o pipefail: entire command fails if pipe fails. watch out for yes | ...