#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include "libcgo.h"

void
fatalf(const char* format, ...)
{
	va_list ap;

	fprintf(stderr, "runtime/cgo: ");
	va_start(ap, format);
	vfprintf(stderr, format, ap);
	va_end(ap);
	fprintf(stderr, "\n");
	abort();

  public void testPadStart_noPadding() {
    assertSame("", Strings.padStart("", 0, '-'));
    assertSame("x", Strings.padStart("x", 0, '-'));
    assertSame("x", Strings.padStart("x", 1, '-'));
    assertSame("xx", Strings.padStart("xx", 0, '-'));
    assertSame("xx", Strings.padStart("xx", 2, '-'));
  }

  public void testPadStart_somePadding() {
    assertEquals("-", Strings.padStart("", 1, '-'));
    assertEquals("--", Strings.padStart("", 2, '-'));

	opts.tasks = task.Descendents()
	slices.SortStableFunc(opts.tasks, func(a, b *trace.UserTaskSummary) int {
		aStart, bStart := parsed.startTime(), parsed.startTime()
		if a.Start != nil {
			aStart = a.Start.Time()
		}
		if b.Start != nil {
			bStart = b.Start.Time()
		}
		if a.Start != b.Start {
			return cmp.Compare(aStart, bStart)
		}
		// Break ties with the end time.
		aEnd, bEnd := parsed.endTime(), parsed.endTime()

      auto fbb = std::make_unique<flexbuffers::Builder>();
      size_t map_start = fbb->StartMap();
      for (const NamedAttribute& pair : composite.getCompositeAttributes()) {
        // Allows skipping unsupported attributes, will warn.
        (void)BuildOption(fbb.get(), op, pair);
      }
      fbb->EndMap(map_start);
      fbb->Finish();
      custom_option_buffer.assign(fbb->GetBuffer().begin(),

  const size_t temp_bytes_total = TotalBufferBytes(buffer_infos_for_temps);

  // Create rewrite strings for namespace start and end.
  string ns_start;
  for (const string& n : opts.namespaces) {
    ns_start += absl::StrCat("namespace ", n, " {\n");
  }
  ns_start += "\n";
  string ns_end("\n");
  for (int i = opts.namespaces.size() - 1; i >= 0; --i) {
    const string& n = opts.namespaces[i];

    rescale(currentScale * (e.deltaY < 0 ? 1.1 : (1/1.1)),
            toSvg(e.offsetX, e.offsetY));
  }

  function setMode(m) {
    mode = m;
    touchid = null;
    touchid2 = null;
  }

  function panStart(x, y) {
    moved = false;
    panLastX = x;
    panLastY = y;
  }

  function panMove(x, y) {
    let dx = x - panLastX;
    let dy = y - panLastY;

                s.append(String.format("%n    %s- %s", padding, modelType.getName()));
            }
        }
    }

    private static String pad(int padding) {
        return Strings.padStart("", padding * 4, ' ');
    }

    private static boolean isScalarCollection(ModelType<?> propertyType, boolean declaredAsHavingUnmanagedType) {
        Class<?> concreteClass = propertyType.getConcreteClass();

		return ctx, update, canStart, canEverStart, true
	case !canStart:
		// this is the only path we don't start the pod, so we need to put the change back in pendingUpdate
		status.pendingUpdate = &update.Options
		status.working = false
		klog.V(4).InfoS("Pod cannot start yet", "pod", klog.KObj(update.Options.Pod), "podUID", podUID)
		return ctx, update, canStart, canEverStart, true
	}

                separator = "\n$columnIndent  $indent"
            )
    }

    private
    fun lineNumber(location: CompilerMessageSourceLocation) =
        location.line.toString().padStart(maxLineNumberStringLength, '0')

    private
    fun prependIndent(it: String) = it.prependIndent(indent)

    private
    val errorPlural
        get() = if (errors.size > 1) "errors" else "error"

         */
        return new Iterator<T>() {
          boolean atStart = true;

          @Override
          public boolean hasNext() {
            return iterator.hasNext();
          }

          @Override
          @ParametricNullness
          public T next() {
            T result = iterator.next();
            atStart = false; // not called if next() fails
            return result;
          }