labels: 'comp:lite'

---

**System information**
- OS Platform and Distribution (e.g., Linux Ubuntu 16.04):
- TensorFlow installed from (source or binary):
- TensorFlow version (or github SHA if from source):


**Provide the text output from tflite_convert**

```
# Copy and paste here
```

**Standalone code to reproduce the issue** 

 */
internal class FileOperator(
  private val fileChannel: FileChannel,
) {
  /** Write [byteCount] bytes from [source] to the file at [pos]. */
  @Throws(IOException::class)
  fun write(
    pos: Long,
    source: Buffer,
    byteCount: Long,
  ) {
    if (byteCount < 0L || byteCount > source.size) {
      throw IndexOutOfBoundsException()
    }
    var mutablePos = pos
    var mutableByteCount = byteCount

        }

        final Map<String, Object> source = new HashMap<>();
        source.put(FieldNames.ARRAY_KEY, key);
        source.put(FieldNames.ARRAY_VALUE, value);
        source.put(FieldNames.TIMESTAMP, DateTimeFormatter.ISO_INSTANT.format(ZonedDateTime.now()));

        addToArrayIndex(arraySettingsIndexName, settingsId, createId(key, value), source);
    }

    /**
     * Delete values.

  class Reader
    @JvmOverloads
    constructor(
      source: Source,
      private val headerTableSizeSetting: Int,
      private var maxDynamicTableByteCount: Int = headerTableSizeSetting,
    ) {
      private val headerList = mutableListOf<Header>()
      private val source: BufferedSource = source.buffer()

      // Visible for testing.

        socket.sink.buffer().use { sink ->
          socket.source.buffer().use { source ->
            sink.writeUtf8("client says hello\n")
            sink.flush()

            assertThat(source.readUtf8Line()).isEqualTo("server says hello")

            sink.writeUtf8("client says goodbye\n")
            sink.flush()

            assertThat(source.readUtf8Line()).isEqualTo("server says goodbye")

          sink.writeAll(response.body.source())
        }
      }
    }

  private suspend fun readImportResults(): ImportResults =
    withContext(Dispatchers.IO) {
      val sortedRules: SortedSet<ByteString> = TreeSet()
      val sortedExceptionRules: SortedSet<ByteString> = TreeSet()
      var totalRuleBytes = 0
      var totalExceptionRuleBytes = 0

      fileSystem.source(publicSuffixListDotDat).buffer().use { source ->

				if rv.Len() > 0 {
					association.Error = association.Relationship.Field.Set(association.DB.Statement.Context, source, rv.Index(0).Addr().Interface())

					if association.Relationship.Field.FieldType.Kind() == reflect.Struct {
						assignBacks = append(assignBacks, assignBack{Source: source, Dest: rv.Index(0)})
					}
				}
			case reflect.Struct:
				if !rv.CanAddr() {
					association.Error = ErrInvalidValue

  }

  public void testPaddedPartition_empty() {
    Iterator<Integer> source = emptyIterator();
    Iterator<List<Integer>> partitions = Iterators.paddedPartition(source, 1);
    assertFalse(partitions.hasNext());
  }

  public void testPaddedPartition_singleton1() {
    Iterator<Integer> source = singletonIterator(1);
    Iterator<List<Integer>> partitions = Iterators.paddedPartition(source, 1);

        }
      }
    }

    return response
  }

  /**
   * Returns a new source that writes bytes to [cacheRequest] as they are read by the source
   * consumer. This is careful to discard bytes left over when the stream is closed; otherwise we
   * may never exhaust the source stream and therefore not complete the cached response.
   */
  @Throws(IOException::class)
  private fun cacheWritingResponse(

      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,