func (h *sizeHistogram) mergeV1(v sizeHistogramV1) {
	var oidx, nidx int
	for oidx < len(v) {
		intOld, intNew := ObjectsHistogramIntervalsV1[oidx], ObjectsHistogramIntervals[nidx]
		// skip intervals that aren't common to both histograms
		if intOld.start != intNew.start || intOld.end != intNew.end {
			nidx++
			continue
		}
		h[nidx] += v[oidx]
		oidx++
		nidx++
	}
}

				return
			}
		}
		var pool *erasureSets
		for pidx := range z.serverPools {
			if pidx == idx {
				pool = z.serverPools[idx]
				break
			}
		}
		if pool == nil {
			// We didn't find any matching pools, invalid input
			writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, errInvalidArgument), r.URL)
			return
		}

		poolIndices = append(poolIndices, idx)
	}

			}
		}

		if found != nil && found.ETag != "" && partMetaQuorumMap[maxETag] >= readQuorum {
			partInfosInQuorum[pidx] = *found
			continue
		}
		partInfosInQuorum[pidx] = ObjectPartInfo{
			Number: partNumbers[pidx],
			Error: InvalidPart{
				PartNumber: partNumbers[pidx],
			}.Error(),
		}
	}
	return partInfosInQuorum, nil
}

func objPartToPartErr(part ObjectPartInfo) error {

	handleListener := func(idx int, ln net.Listener) {
		for {
			conn, err := ln.Accept()
			select {
			case listener.acceptCh <- acceptResult{conn, err, idx}:
			case <-listener.ctxDoneCh:
				return
			}
		}
	}

	// Start separate goroutine for each listener to handle connection.
	for idx, ln := range listener.listeners {
		go handleListener(idx, ln)
	}
}

	var wg sync.WaitGroup
	for idx, pool := range z.serverPools {
		if z.IsSuspended(idx) {
			continue
		}
		wg.Add(1)
		go func(idx int, pool *erasureSets) {
			defer wg.Done()
			result, err := pool.HealObject(ctx, bucket, object, versionID, opts)
			result.Object = decodeDirObject(result.Object)
			errs[idx] = err
			results[idx] = result
		}(idx, pool)
	}
	wg.Wait()

    }

    /**
     * Construct a SID from a domain SID and an RID
     * (relative identifier). For example, a domain SID
     * {@code S-1-5-21-1496946806-2192648263-3843101252} and RID {@code 1029} would
     * yield the SID {@code S-1-5-21-1496946806-2192648263-3843101252-1029}.
     */
    /**
     * Construct a SID from a domain SID and an RID (relative identifier).
     *
     * @param domsid the domain SID

                        final samr.SamrSamEntry entry = rpc.sam.entries[ei];

                        final SID[] mems = getGroupMemberSids(tc, authorityServerName, domSid, entry.idx, flags);
                        final SID groupSid = new SID(domSid, entry.idx);
                        groupSid.type = jcifs.SID.SID_TYPE_ALIAS;
                        groupSid.domainName = domSid.getDomainName();

			}
			hr, err := hash.NewReaderWithOpts(ctx, bytes.NewReader(fanOutBuf), hopts)
			if err != nil {
				errs[idx] = err
				return
			}

			reader := NewPutObjReader(hr)
			defer func() {
				if err := reader.Close(); err != nil {
					errs[idx] = err
				}
				if err := hr.Close(); err != nil {
					errs[idx] = err
				}
			}()

			userDefined := make(map[string]string, len(req.UserMetadata))

	if len(dir) == 0 {
		// Root
		idx := strings.Index(e.name, separator)
		return idx == -1 || idx == len(e.name)-len(separator)
	}
	ext := strings.TrimPrefix(e.name, dir)
	if len(ext) != len(e.name) {
		idx := strings.Index(ext, separator)
		// If separator is not found or is last entry, ok.
		return idx == -1 || idx == len(ext)-len(separator)
	}
	return false
}

		p.Pools[idx].LastUpdate = UTCNow()
		p.Pools[idx].Decommission.StartTime = time.Time{}
		p.Pools[idx].Decommission.Complete = false
		p.Pools[idx].Decommission.Failed = true
		p.Pools[idx].Decommission.Canceled = false
		return true
	}
	return false
}

func (p *poolMeta) DecommissionCancel(idx int) bool {
	if p.Pools[idx].Decommission != nil && !p.Pools[idx].Decommission.Canceled {