"encoding/base64"
	"encoding/binary"
	"fmt"
	"hash/crc32"
	"hash/crc64"
	"math/bits"
)

// AddPart will merge a part checksum into the current,
// as if the content of each was appended.
// The size of the content that produced the second checksum must be provided.
// Not all checksum types can be merged, use the CanMerge method to check.
// Checksum types must match.
func (c *Checksum) AddPart(other Checksum, size int64) error {

   * merge does not affect its value. For example, if {@code rangeMap} had one entry {@code [1, 5]
   * => 3} then {@code rangeMap.merge(Range.closed(0,2), 3, Math::max)} could yield a map with the
   * entries {@code [0, 1) => 3, [1, 2] => 3, (2, 5] => 3}.
   *
   * @since 28.1
   */
  void merge(
      Range<K> range,
      @Nullable V value,

After checking all these things and ensuring the PR has the right labels, you can merge it.

## Dependabot PRs

Dependabot will create PRs to update dependencies for several things, and those PRs all look similar, but some are way more delicate than others.

		var loi ListObjectsInfo
		merged, err := z.listPath(ctx, &opts)
		if err != nil && err != io.EOF {
			if !isErrBucketNotFound(err) {
				storageLogOnceIf(ctx, err, "erasure-list-objects-path-"+bucket)
			}
			return loi, toObjectErr(err, bucket)
		}
		merged.forwardPast(opts.Marker)
		defer merged.truncate(0) // Release when returning

		if contextCanceled(ctx) {

				return
			}
			continue
		}

		// Merge entries and send
		queue = append(queue, toSend)
		if debugPrint {
			fmt.Println("Merging", len(queue), "messages")
		}

		merged = merged[:0]
		m := message{Op: OpMerged, Seq: uint32(len(queue))}
		var err error
		merged, err = m.MarshalMsg(merged)
		if err != nil {
			gridLogIf(ctx, fmt.Errorf("msg.MarshalMsg: %w", err))

        PomTestWrapper pom = buildPom("merged-plugin-exec-goals-order/wo-plugin-mgmt/sub");

        assertEquals(5, ((List<?>) pom.getValue("build/plugins[1]/executions[1]/goals")).size());
        assertEquals("child-a", pom.getValue("build/plugins[1]/executions[1]/goals[1]"));
        assertEquals("merged", pom.getValue("build/plugins[1]/executions[1]/goals[2]"));

            }
        }
        return list.toArray(new Kind[list.size()]);
    }

    /**
     * Merges two suggest items.
     * @param item1 The first suggest item.
     * @param item2 The second suggest item.
     * @return The merged suggest item.
     */
    public static SuggestItem merge(final SuggestItem item1, final SuggestItem item2) {
        if (!item1.getId().equals(item2.getId())) {

		}
		ContentLengthRange contentLengthRange
	}
}

// implemented to ensure that duplicate keys in JSON
// are merged together into a single JSON key, also
// to remove any extraneous JSON bodies.
//
// Go stdlib doesn't support parsing JSON with duplicate
// keys, so we need to use this technique to merge the
// keys.
func sanitizePolicy(r io.Reader) (io.Reader, error) {
	var buf bytes.Buffer
	e := json.NewEncoder(&buf)

  public void testAbsent() {
    assertEquals(
        "Map.merge(absent, value, function) should return value",
        v3(),
        getMap()
            .merge(
                k3(),
                v3(),
                (oldV, newV) -> {
                  throw new AssertionFailedError(
                      "Should not call merge function if key was absent");
                }));
    expectAdded(e3());
  }

  public void testAbsent() {
    assertEquals(
        "Map.merge(absent, value, function) should return value",
        v3(),
        getMap()
            .merge(
                k3(),
                v3(),
                (oldV, newV) -> {
                  throw new AssertionFailedError(
                      "Should not call merge function if key was absent");
                }));
    expectAdded(e3());
  }