int index) {
  DCHECK(index >= 0 && index < shape_list->num_items);
  TF_ShapeAndType& shape = shape_list->items[index];
  DCHECK(shape.dims == nullptr) << "Shape at " << index << " is already set!";
  shape.num_dims = -1;
  shape.dims = nullptr;
}

void TF_ShapeAndTypeListSetDtype(TF_ShapeAndTypeList* shape_list, int index,
                                 TF_DataType dtype) {

        // Add first document - should trigger indexing because cache size is 1
        Map<String, Object> dataMap1 = new HashMap<>();
        dataMap1.put("url", "http://example.com/test1");
        indexUpdateCallback.store(paramMap, dataMap1);
        assertEquals(1, indexingHelper.sendDocumentsCalled);

        // Add second document - should trigger indexing again
        Map<String, Object> dataMap2 = new HashMap<>();

  }

  @Override
  public UnmodifiableListIterator<E> listIterator(int index) {
    return new AbstractIndexedListIterator<E>(size(), index) {
      @Override
      protected E get(int index) {
        return ImmutableList.this.get(index);
      }
    };
  }

  @Override
  public ImmutableList<E> asList() {
    return this;
  }

  @Override

            try (DcerpcHandle handle = DcerpcHandle.getHandle("ncacn_np:" + authorityServerName + "[\\PIPE\\lsarpc]", tc)) {
                String server = authorityServerName;
                final int dot = server.indexOf('.');
                if (dot > 0 && !Character.isDigit(server.charAt(0))) {
                    server = server.substring(0, dot);
                }

     * @return sequence element cast to type
     * @throws PACDecodingException if types are incompatible
     */
    public static <T extends ASN1Primitive> T as(final Class<T> type, final ASN1Sequence sequence, final int index)
            throws PACDecodingException {
        return as(type, sequence.getObjectAt(index));
    }

    /**
     * Read a tagged object without parsing it's contents
     *

    val uriStripped = uriStrippedCodePoints.indexOf(codePointString) != -1
    if (uriStripped) {
      if (uri.toString() != component.urlString("")) {
        fail("Encoding $component $codePoint using $encoding")
      }
      return
    }

    // If the URI has more escaping than the HttpURL, check that the decoded values still match.
    val uriEscaped = uriEscapedCodePoints.indexOf(codePointString) != -1
    if (uriEscaped) {

index 3f9112e..8e60197 100644
--- a/iconv/gconv.h
+++ b/iconv/gconv.h
@@ -174,7 +174,7 @@ typedef struct __gconv_info
 {
   size_t __nsteps;
   struct __gconv_step *__steps;
-  __extension__ struct __gconv_step_data __data __flexarr;
+  __extension__ struct __gconv_step_data __data[0];
 } *__gconv_t;
 
 #endif /* gconv.h */
diff --git a/include/libc-symbols.h b/include/libc-symbols.h
index c555bf2..143b26d 100644

	g := errgroup.WithNErrs(len(disks))
	for index := range disks {
		g.Go(func() error {
			di := madmin.Disk{
				Endpoint:  endpoints[index].String(),
				PoolIndex: endpoints[index].PoolIdx,
				SetIndex:  endpoints[index].SetIdx,
				DiskIndex: endpoints[index].DiskIdx,
				Local:     endpoints[index].IsLocal,
			}
			if disks[index] == OfflineDisk {
				di.State = diskErrToDriveState(errDiskNotFound)

   */
  @Override
  protected int nextEscapeIndex(CharSequence csq, int index, int end) {
    checkNotNull(csq);
    for (; index < end; index++) {
      char c = csq.charAt(index);
      if (c >= safeOctets.length || !safeOctets[c]) {
        break;
      }
    }
    return index;
  }

  /*

package okhttp3.internal

import okhttp3.Headers

internal fun Headers.commonName(index: Int): String = namesAndValues.getOrNull(index * 2) ?: throw IndexOutOfBoundsException("name[$index]")

internal fun Headers.commonValue(index: Int): String =
  namesAndValues.getOrNull(index * 2 + 1) ?: throw IndexOutOfBoundsException("value[$index]")

internal fun Headers.commonValues(name: String): List<String> {