FLAGS[prefixFlag or FLAG_PADDED] = FLAGS[prefixFlag] + "|PADDED"
    }

    FLAGS[FLAG_END_HEADERS] = "END_HEADERS" // Same as END_PUSH_PROMISE.
    FLAGS[FLAG_PRIORITY] = "PRIORITY" // Same as FLAG_COMPRESSED.
    FLAGS[FLAG_END_HEADERS or FLAG_PRIORITY] = "END_HEADERS|PRIORITY" // Only valid on HEADERS.
    val frameFlags = intArrayOf(FLAG_END_HEADERS, FLAG_PRIORITY, FLAG_END_HEADERS or FLAG_PRIORITY)

    for (frameFlag in frameFlags) {

	--replicate "existing-objects,delete,delete-marker,replica-metadata-sync" --priority 2
sleep 1

echo "adding replication rule for c -> a : ${remote_arn}"
./mc replicate add sitec/bucket/ \
	--remote-bucket http://minio:minio123@127.0.0.1:9001/bucket \
	--replicate "existing-objects,delete,delete-marker,replica-metadata-sync" --priority 2
sleep 1

echo "adding replication rule for b -> c : ${remote_arn}"

        assertEquals(2, ingesters[1].getPriority());
        assertEquals(3, ingesters[2].getPriority());
    }

    private static class TestIngester extends Ingester {
        public TestIngester(int priority) {
            this.priority = priority;
        }
    }

 *
 * As a non-default component this now gets a negative priority relative to other implementations
 * of the same interface. Since we want to allow overriding this doesn't matter in this case.
 * (if it did we could add @Priority of 0 to match the priority given to default components.)
 *
 * @deprecated use {@code org.apache.maven.api.services.ModelBuilder} instead
 */

    public int getNumberOfBuilds() {
        return projectBuilds.size();
    }

    /**
     * Gets all the builds that have no reactor-dependencies, ordered by critical path priority
     *
     * @return A list of all the initial builds, ordered by priority (critical path first)
     */
    public List<MavenProject> getRootSchedulableBuilds() {
        Set<MavenProject> result = new LinkedHashSet<>();

        int priority = Thread.NORM_PRIORITY; // Use normal priority for tests
        dataIndexHelper.setCrawlerPriority(priority);

        try {
            Field field = DataIndexHelper.class.getDeclaredField("crawlerPriority");
            field.setAccessible(true);
            int actualPriority = (Integer) field.get(dataIndexHelper);
            assertEquals(priority, actualPriority);

	ID                      string                  `xml:"ID,omitempty" json:"ID,omitempty"`
	Status                  Status                  `xml:"Status" json:"Status"`
	Priority                int                     `xml:"Priority" json:"Priority"`
	DeleteMarkerReplication DeleteMarkerReplication `xml:"DeleteMarkerReplication" json:"DeleteMarkerReplication"`
	// MinIO extension to replicate versioned deletes

        this.crawlingExecutionInterval = crawlingExecutionInterval;
    }

    /**
     * Sets the thread priority for crawler threads.
     * This priority will be applied to all newly created crawler threads.
     *
     * @param crawlerPriority thread priority (typically Thread.MIN_PRIORITY to Thread.MAX_PRIORITY)
     */
    public void setCrawlerPriority(final int crawlerPriority) {

			targetMap[r.Destination.Bucket] = struct{}{}
		}
		if err := r.Validate(bucket, sameTarget); err != nil {
			return err
		}
		if _, ok := priorityMap[strconv.Itoa(r.Priority)]; ok {
			return errReplicationUniquePriority
		}
		priorityMap[strconv.Itoa(r.Priority)] = struct{}{}

		if r.Destination.LegacyArn() {
			legacyArn = true
		}
		if c.RoleArn == "" && !r.Destination.TargetArn() {
			return errDestinationArnMissing

 * defined as the <i>least</i> element in the queue according to the queue's comparator. But unlike
 * a regular priority queue, the methods {@link #peekLast}, {@link #pollLast} and {@link
 * #removeLast} are also provided, to act on the <i>greatest</i> element in the queue instead.
 *
 * <p>A min-max priority queue can be configured with a maximum size. If so, each time the size of