}

    public void setLoc(final String loc) {
        this.loc = loc;
    }

    @Override
    public String getLastmod() {
        return lastmod;
    }

    public void setLastmod(final String lastmod) {
        this.lastmod = lastmod;
    }

    public String getChangefreq() {
        return changefreq;
    }

    public void setChangefreq(final String changefreq) {

<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <sitemap>
      <loc>http://www.example.com/sitemap1.xml.gz</loc>
      <lastmod>2004-10-01T18:23:17+00:00</lastmod>
   </sitemap>
   <sitemap>
      <loc>http://www.example.com/sitemap2.xml.gz</loc>
      <lastmod>2005-01-01</lastmod>
   </sitemap>

   </url>
   <url>
      <loc>http://www.example.com/catalog?item=74&amp;desc=vacation_newfoundland</loc>
      <lastmod>2004-12-23T18:00:15+00:00</lastmod>
      <priority>0.3</priority>
   </url>
   <url>
      <loc>http://www.example.com/catalog?item=83&amp;desc=vacation_usa</loc>
      <lastmod>2004-11-23</lastmod>
   </url>

    public String getLastmod() {
        return lastmod;
    }

    public void setLastmod(final String lastmod) {
        this.lastmod = lastmod;
    }

    @Override
    public boolean equals(final Object obj) {
        if (!(obj instanceof final SitemapFile sitemapUrl)) {
            return false;
        }
        if (StringUtil.equals(loc, sitemapUrl.loc) && StringUtil.equals(lastmod, sitemapUrl.lastmod)) {
            return true;

        private static final String PRIORITY_ELEMENT = "priority";

        private static final String CHANGEFREQ_ELEMENT = "changefreq";

        private static final String LASTMOD_ELEMENT = "lastmod";

        private static final String LOC_ELEMENT = "loc";

        private static final String URL_ELEMENT = "url";

        private SitemapSet sitemapSet;

        private SitemapUrl sitemapUrl;

type ReplicationLastHour struct {
	Totals  [60]AccElem
	LastMin int64
}

// Merge data of two ReplicationLastHour structure
func (l ReplicationLastHour) merge(o ReplicationLastHour) (merged ReplicationLastHour) {
	if l.LastMin > o.LastMin {
		o.forwardTo(l.LastMin)
		merged.LastMin = l.LastMin
	} else {
		l.forwardTo(o.LastMin)
		merged.LastMin = o.LastMin
	}

	for i := range merged.Totals {

import okio.BufferedSource
import okio.ByteString.Companion.encodeUtf8
import okio.Options

class ServerSentEventReader(
  private val source: BufferedSource,
  private val callback: Callback,
) {
  private var lastId: String? = null

  interface Callback {
    fun onEvent(
      id: String?,
      type: String?,
      data: String,
    )

    fun onRetryChange(timeMs: Long)
  }

  /**

				err = z.Totals[za0001].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Totals", za0001)
					return
				}
			}
		case "LastMin":
			z.LastMin, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "LastMin")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}

}

type latencyStat struct {
	lastmin lastMinuteLatency
	curr    time.Duration
	avg     time.Duration
	peak    time.Duration
	N       int64
}

func (l *latencyStat) update(d time.Duration) {
	l.lastmin.add(d)
	l.N++
	if d > l.peak {
		l.peak = d
	}
	l.curr = l.lastmin.getTotal().avg()
	l.avg = time.Duration((int64(l.avg)*(l.N-1) + int64(l.curr)) / l.N)
}

        while (pos >= 0) {
            final int lastPos = value.indexOf("-->", pos);
            if (lastPos < 0) {
                break;
            }
            if (pos == 0) {
                value = " " + value.substring(lastPos + 3);
            } else {
                value = value.substring(0, pos) + " " + value.substring(lastPos + 3);
            }
            pos = value.indexOf("<!--");