oh32 OptionalHeader32
			// There can be 0 or more data directories. So the minimum size of optional
			// header is calculated by subtracting oh32.DataDirectory size from oh32 size.
			oh32MinSz = binary.Size(oh32) - binary.Size(oh32.DataDirectory)
		)

		if sz < uint16(oh32MinSz) {
			return nil, fmt.Errorf("optional header size(%d) is less minimum size (%d) of PE32 optional header", sz, oh32MinSz)
		}

		// Init oh32 fields

    if (buffer == nullptr && size > 0) {
      return absl::InternalError(
          absl::StrFormat("Failed to allocate HostMemory of size %d", size));
    }
    return std::make_unique<HostMemoryAllocation>(buffer, size, this);
  }

  void HostMemoryDeallocate(void* mem) override {
    stream_executor_->host_memory_deallocate(&device_, mem);
  }

  void* UnifiedMemoryAllocate(uint64 size) override {

page.user.max.fetch.size=1000
page.role.max.fetch.size=1000
page.group.max.fetch.size=1000
page.crawling.info.param.max.fetch.size=100
page.crawling.info.max.fetch.size=1000
page.data.config.max.fetch.size=100
page.web.config.max.fetch.size=100
page.file.config.max.fetch.size=100
page.duplicate.host.max.fetch.size=1000
page.failure.url.max.fetch.size=1000
page.favorite.log.max.fetch.size=100
page.file.auth.max.fetch.size=100

func (m *CSIStorageCapacity) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CSIStorageCapacity) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

		if uint64(size) >= quotaSize { // check if file size already exceeds the quota
			return BucketQuotaExceeded{Bucket: bucket}
		}

		bui, err := sys.GetBucketUsageInfo(ctx, bucket)
		if err != nil {
			return err
		}

		if bui.Size > 0 && ((bui.Size + uint64(size)) >= quotaSize) {
			return BucketQuotaExceeded{Bucket: bucket}
		}
	}

	return nil
}

          if (headerCount + 1 > dynamicTable.size) { // Need to grow the dynamic table.
            val doubled = arrayOfNulls<Header>(dynamicTable.size * 2)
            System.arraycopy(dynamicTable, 0, doubled, dynamicTable.size, dynamicTable.size)
            nextHeaderIndex = dynamicTable.size - 1
            dynamicTable = doubled
          }
          index = nextHeaderIndex--

    public Integer crudMode;

    @Required
    @Size(max = 100)
    public String name;

    @Required
    @Size(max = 100)
    @Pattern(regexp = "^[a-zA-Z0-9_]+$")
    public String value;

    @CustomSize(maxKey = "form.admin.max.input.size")
    public String includedPaths;

    @CustomSize(maxKey = "form.admin.max.input.size")
    public String excludedPaths;

    this.values = array;
    this.rowKeyToIndex = Maps.indexMap(rowSpace);
    this.columnKeyToIndex = Maps.indexMap(columnSpace);
    rowCounts = new int[rowKeyToIndex.size()];
    columnCounts = new int[columnKeyToIndex.size()];
    int[] cellRowIndices = new int[cellList.size()];
    int[] cellColumnIndices = new int[cellList.size()];

    throw IOException("Cannot buffer entire body for content length: $contentLength")
  }

  val bytes = source().use(consumer)
  val size = sizeMapper(bytes)
  if (contentLength != -1L && contentLength != size.toLong()) {
    throw IOException("Content-Length ($contentLength) and stream length ($size) disagree")
  }
  return bytes
}

internal fun ResponseBody.commonClose() = source().closeQuietly()

                wordsList.add(word);
                readingList.add(l.toArray(new String[l.size()]));
            }
            if (wordsList.isEmpty()) {
                return null;
            }
            return new SuggestItem(wordsList.toArray(new String[wordsList.size()]), readingList.toArray(new String[readingList.size()][]),
                    fields, 0, score, -1, tags, roles, langs, SuggestItem.Kind.QUERY);