* connect to the given range and value.
   *
   * <p>Even if the input range is empty, if it is connected on both sides by ranges mapped to the
   * same value those two ranges will be coalesced.
   *
   * <p><b>Note:</b> coalescing requires calling {@code .equals()} on any connected values, which
   * may be expensive depending on the value type. Using this method on range maps with large values

			targetFailed = true
		} else if tgtSize != tgtCtnt.Size {
			fmt.Printf("unreadable on target - size differs upon read: %s\n", tgtCtnt.Key)
			targetFailed = true
		}
	}()
	wg.Wait()

	sobj.Close()
	tobj.Close()

	if !sourceFailed && !targetFailed {
		ssum := srcSha256.Sum(nil)
		tsum := tgtSha256.Sum(nil)
		allgood = bytes.Equal(ssum, tsum)
		if !allgood {

				select {
				case <-ctx.Done():
					return
				default:
				}

				stopFn := globalBatchJobsMetrics.trace(batchJobMetricExpire, ri.JobID, attempts)
				// Copying toDel to select from objects whose
				// deletion failed
				copy(toDelCopy, toDel)
				var failed int
				errs := r.Expire(ctx, api, vc, toDel)
				// reslice toDel in preparation for next retry attempt
				toDel = toDel[:0]

        // Note: here, type decides is artifact added to "build path" (for example during resolution)
        // and "build path" is intermediate data that is used to create actual Java classpath/modulepath
        // but to create those, proper filtering should happen via Type properties.
    }

    @Override
    public void addHandlers(Map<String, ArtifactHandler> handlers) {

  override fun setSSLParameters(p: SSLParameters) {
    delegate!!.sslParameters = p
  }

  @Throws(IOException::class)
  override fun close() {
    delegate!!.close()
  }

  override fun getInetAddress(): InetAddress = delegate!!.inetAddress

  @Throws(IOException::class)
  override fun getInputStream(): InputStream = delegate!!.inputStream

      builder.eventListenerFactory(LoggingEventListener.Factory(logger))
    }
    return builder.build()
  }

  fun close() {
    val okHttpClient = client as OkHttpClient
    okHttpClient.connectionPool.evictAll() // Close any persistent connections.
    okHttpClient.dispatcher.executorService.shutdownNow()
  }

  companion object {
    internal const val NAME = "okcurl"

                // Continue with destruction even if listener fails
            }
        }

        // Close the object if it implements AutoCloseable or Closeable
        final T obj = p.getObject();
        if (obj instanceof AutoCloseable) {
            try {
                ((AutoCloseable) obj).close();
            } catch (final Exception e) {

            final ObjectOutputStream oos = new ObjectOutputStream(baos);
            try {
                oos.writeObject(obj);
            } finally {
                oos.close();
            }
            return baos.toByteArray();
        } catch (final IOException ex) {
            throw new IORuntimeException(ex);
        }
    }

    /**

        throw new IOException("Failed to reconnect durable handle");
    }
}

@Override
public void close() throws IOException {
    try {
        // Normal close operations
        super.close();
    } finally {
        // Don't release durable handle on close if it's persistent
        if (handleManager != null && handleType != HandleType.PERSISTENT) {

 */

package jcifs.smb1.smb1;

import jcifs.smb1.Config;

class SmbComReadAndX extends AndXServerMessageBlock {

    private static final int BATCH_LIMIT = Config.getInt("jcifs.smb1.smb.client.ReadAndX.Close", 1);

    private long offset;
    private int fid;

    private final int openTimeout;
    int maxCount, minCount, remaining;

    SmbComReadAndX() {
        super(null);