/* The following fails to compile:
     *
     * The method append(Iterable<? extends FluentIterableTest.A>) in the type
     * FluentIterable<FluentIterableTest.A> is not applicable for the arguments
     * (Iterable<FluentIterableTest.B>)
     */
    // FluentIterable.from(aIterable).append(bIterable);

    /* The following fails to compile:
     *

	bs.mu.Lock()
	defer bs.mu.Unlock()

	if len(bs.info) > bootstrapTraceLimit {
		return
	}
	bs.info = append(bs.info, info)
}

func (bs *bootstrapTracer) Events() []madmin.TraceInfo {
	traceInfo := make([]madmin.TraceInfo, 0, bootstrapTraceLimit)

	bs.mu.RLock()
	traceInfo = append(traceInfo, bs.info...)
	bs.mu.RUnlock()

	return traceInfo
}

	if debug {
		s3Client.TraceOn(os.Stderr)
	}

	var buckets []string
	if bucket != "" {
		buckets = append(buckets, bucket)
	} else {
		bucketsInfo, err := s3Client.ListBuckets(context.Background())
		if err != nil {
			log.Fatalln(err)
		}
		for _, b := range bucketsInfo {
			buckets = append(buckets, b.Name)
		}
	}

	for _, bucket := range buckets {
		opts := minio.ListObjectsOptions{

	for _, ip := range ipV4s {
		ips = append(ips, ip.String())
	}

	return append(nonIPs, ips...)
}

func getConsoleEndpoints() (consoleEndpoints []string) {
	if globalBrowserRedirectURL != nil {
		return []string{globalBrowserRedirectURL.String()}
	}
	var ipList []string
	if globalMinioConsoleHost == "" {
		ipList = sortIPs(localIP4.ToSlice())
		ipList = append(ipList, localIP6.ToSlice()...)
	} else {

	// map header, size 0
	_ = z
	err = en.Append(0x80)
	if err != nil {
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z BucketBandwidthReport) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 0
	_ = z
	o = append(o, 0x80)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler

		return fmt.Errorf("the limit of `%d` subscribers is reached", ps.maxSubscribers)
	}
	ps.Lock()
	defer ps.Unlock()

	sub := &Sub[T]{ch: subCh, types: Mask(mask.Mask()), filter: filter}
	ps.subs = append(ps.subs, sub)

	// We hold a lock, so we are safe to update
	combined := Mask(atomic.LoadUint64(&ps.types))
	combined.Merge(Mask(mask.Mask()))
	atomic.StoreUint64(&ps.types, uint64(combined))

	go func() {

                result.append("<$name")
            }

            @Override
            void onHtmlElementAttribute(String name, String value) {
                result.append(" $name='$value'")
            }

            @Override
            void onStartHtmlElementComplete(String name) {
                result.append(">")
            }

            @Override

            sb.append("The option ");
            if (option.getOpt() != null) {
                sb.append("-").append(option.getOpt());
            }
            if (option.getLongOpt() != null) {
                if (option.getOpt() != null) {
                    sb.append(",");
                }
                sb.append("--").append(option.getLongOpt());
            }

		hostErrs = append(hostErrs, globalNotificationSys.StartProfiling(ctx, profiler)...)

		// Start profiling locally as well.
		prof, err := startProfiler(profiler)
		if err != nil {
			hostErrs = append(hostErrs, NotificationPeerErr{
				Host: *thisAddr,
				Err:  err,
			})
		} else {
			globalProfiler[profiler] = prof
			hostErrs = append(hostErrs, NotificationPeerErr{

            if (event.getArtifact() != null) {
                trackingData.add(indent.toString() + event.getArtifact());
                indent.append("  ");
            }
            trackingData.add(indent + plugin.getGroupId() + ":" + plugin.getArtifactId() + ":" + plugin.getVersion());
            indent.append("  ");

            InputLocation location = plugin.getLocation("");
            if (location != null && location.getSource() != null) {