// srcend R4
// dstend R5
// data   R6-R17
// tmp1   R14

// Copies are split into 3 main cases: small copies of up to 32 bytes, medium
// copies of up to 128 bytes, and large copies. The overhead of the overlap
// check is negligible since it is only required for large copies.
//
// Large copies use a software pipelined loop processing 64 bytes per iteration.

// necessary methods, optimized for speed.

var globalInc atomic.Uint64 // PCG stream

const multiplier uint64 = 6364136223846793005

// pcgRand is a PRNG. It should not be copied or shared. No Rand methods are
// concurrency safe.
type pcgRand struct {
	noCopy noCopy // help avoid mistakes: ask vet to ensure that we don't make a copy
	state  uint64
	inc    uint64
}

limitations under the License.
*/

package util

import (
	"os/exec"
)

// CopyDir copies the content of a folder
func CopyDir(src string, dst string) ([]byte, error) {
	// /E Copies directories and subdirectories, including empty ones.
	// /H Copies hidden and system files also.
	return exec.Command("xcopy", "/E", "/H", src, dst).CombinedOutput()

     * replace string should use the '$1' syntax to refer to capture groups in the source regular expression.  Files
     * that do not match the source regular expression will be copied with the original name.
     *
     * <p> Example:
     * <pre>
     * rename '(.*)_OEM_BLUE_(.*)', '$1$2'
     * </pre>
     * would map the file 'style_OEM_BLUE_.css' to 'style.css'
     *

	a, err := meta.Accessor(o)
	if err != nil {
		// The object is not a `metav1.Object`, ignore it.
		return o
	}
	a.SetManagedFields(nil)
	return o
}

// PrintObj copies the object and omits the managed fields from the copied object before printing it.
func (p *OmitManagedFieldsPrinter) PrintObj(obj runtime.Object, w io.Writer) error {
	if obj == nil {
		return p.Delegate.PrintObj(obj, w)
	}
	if meta.IsListType(obj) {

        assertEquals("maven-core", clonedProject.getArtifactId());
        Map<?, ?> clonedMap = clonedProject.getManagedVersionMap();
        assertNotNull(clonedMap, "ManagedVersionMap not copied");
        assertTrue(clonedMap.isEmpty(), "ManagedVersionMap is not empty");
    }

    @Test
    void testCloneWithDependencyManagement() throws Exception {

 * limitations under the License.
 */

package org.gradle.api.file;

import org.gradle.api.GradleException;

/**
 * Thrown when more than one file with the same relative path name is to be copied
 * and the {@link DuplicatesStrategy} is set to DuplicatesStrategy.FAIL
 */
public class DuplicateFileCopyingException extends GradleException {
    public DuplicateFileCopyingException(String desc) {
        super(desc);

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

            task test(type: PathSensitiveTask) {
                outputFile = file("build/output.txt")
            }
        """
    }

    def "copy task stays up-to-date after files are moved but end up copied to the same destination"() {
        file("src/data/input.txt").text = "data"

        when:
        buildFile << """
            task copy(type: Copy) {
                outputs.cacheIf { true }

// The encoding is a simple Lempel-Ziv program, with codes to emit literal bits and to repeat the
// last n bits c times.
//
// The possible codes are:
//
//	00000000: stop
//	0nnnnnnn: emit n bits copied from the next (n+7)/8 bytes, least significant bit first
//	10000000 n c: repeat the previous n bits c times; n, c are varints
//	1nnnnnnn c: repeat the previous n bits c times; c is a varint
//