import os
import heapq

def merge_and_split(file_list_path, output_prefix, num_splits=16):
    """Merges files listed in a file and splits the content into multiple files.

    Args:
        file_list_path: Path to the file containing the list of file paths.
        output_prefix: Prefix for the output files (e.g., "/tmp/merged_").
        num_splits: Number of output files to create.
    """

    try:
        with open(file_list_path, 'r') as f:
            file_paths = [line.strip() for line in f]
    except FileNotFoundError:
        print(f"Error: File list not found at {file_list_path}")
        return

    # Sort files by size (largest first) using a heap (more efficient for large lists)
    file_sizes = []
    for path in file_paths:
        try:
            size = os.path.getsize(path)
            heapq.heappush(file_sizes, (-size, path))  # Negative size for max-heap
        except FileNotFoundError:
            print(f"Warning: File not found: {path}. Skipping.")
            continue

    output_files = [open(f"{output_prefix}{i}", 'wb') for i in range(num_splits)]
    output_sizes = [0] * num_splits

    while file_sizes:
        _, file_path = heapq.heappop(file_sizes)

        # Find the smallest output file
        min_size = float('inf')
        min_index = -1
        for i in range(num_splits):
            if output_sizes[i] < min_size:
                min_size = output_sizes[i]
                min_index = i

        try:
            with open(file_path, 'rb') as infile:
                data = infile.read()  # Read in binary mode
                output_files[min_index].write(data)
                output_sizes[min_index] += len(data)

        except FileNotFoundError:
            print(f"Warning: File not found during merge: {file_path}. Skipping.")
            continue

    # Close all output files
    for file in output_files:
        file.close()

    print("Merge and split complete.")


# Example usage:
file_list_path = "/tmp/files"
output_prefix = "/tmp/merged_"
num_splits = 16

merge_and_split(file_list_path, output_prefix, num_splits)

mkdir -p /tmp/testfiles
for i in {1..1000}; do dd if=/dev/urandom of=/tmp/testfiles/file_$i bs=1k count=$((i%100 + 1)); done  # Create dummy files
find /tmp/testfiles/ -type f > /tmp/files # Create the file list

import os
import heapq

def merge_and_split(file_list_path, output_prefix, num_splits=16):
    """Merges files listed in a file and splits the content into multiple files.

    Args:
        file_list_path: Path to the file containing the list of file paths.
        output_prefix: Prefix for the output files (e.g., "/tmp/merged_").
        num_splits: Number of output files to create.
    """

    try:
        with open(file_list_path, 'r') as f:
            file_paths = [line.strip() for line in f]
    except FileNotFoundError:
        print(f"Error: File list not found at {file_list_path}")
        return

    # Sort files by size (largest first) using a heap (more efficient for large lists)
    file_sizes = []
    for path in file_paths:
        try:
            size = os.path.getsize(path)
            heapq.heappush(file_sizes, (-size, path))  # Negative size for max-heap
        except FileNotFoundError:
            print(f"Warning: File not found: {path}. Skipping.")
            continue

    output_files = [open(f"{output_prefix}{i}", 'wb') for i in range(num_splits)]
    output_sizes = [0] * num_splits

    while file_sizes:
        _, file_path = heapq.heappop(file_sizes)

        # Find the smallest output file
        min_size = float('inf')
        min_index = -1
        for i in range(num_splits):
            if output_sizes[i] < min_size:
                min_size = output_sizes[i]
                min_index = i

        try:
            with open(file_path, 'rb') as infile:
                data = infile.read()  # Read in binary mode
                output_files[min_index].write(data)
                output_sizes[min_index] += len(data)

        except FileNotFoundError:
            print(f"Warning: File not found during merge: {file_path}. Skipping.")
            continue

    # Close all output files
    for file in output_files:
        file.close()

    print("Merge and split complete.")


# Example usage:
file_list_path = "/tmp/files"
output_prefix = "/tmp/merged_"
num_splits = 16

merge_and_split(file_list_path, output_prefix, num_splits)

import os
import heapq

def merge_and_split(file_list_path, output_prefix, num_splits=16):
    """Merges files listed in a file and splits the content into multiple files.

    Args:
        file_list_path: Path to the file containing the list of file paths.
        output_prefix: Prefix for the output files (e.g., "/tmp/merged_").
        num_splits: Number of output files to create.
    """

    try:
        with open(file_list_path, 'r') as f:
            file_paths = [line.strip() for line in f]
    except FileNotFoundError:
        print(f"Error: File list not found at {file_list_path}")
        return

    # Sort files by size (largest first) using a heap (more efficient for large lists)
    file_sizes = []
    for path in file_paths:
        try:
            size = os.path.getsize(path)
            heapq.heappush(file_sizes, (-size, path))  # Negative size for max-heap
        except FileNotFoundError:
            print(f"Warning: File not found: {path}. Skipping.")
            continue

    output_files = [open(f"{output_prefix}{i}", 'wb') for i in range(num_splits)]
    output_sizes = [0] * num_splits

    while file_sizes:
        _, file_path = heapq.heappop(file_sizes)

        # Find the smallest output file
        min_size = float('inf')
        min_index = -1
        for i in range(num_splits):
            if output_sizes[i] < min_size:
                min_size = output_sizes[i]
                min_index = i

        try:
            with open(file_path, 'rb') as infile:
                data = infile.read()  # Read in binary mode
                output_files[min_index].write(data)
                output_sizes[min_index] += len(data)

        except FileNotFoundError:
            print(f"Warning: File not found during merge: {file_path}. Skipping.")
            continue

    # Close all output files
    for file in output_files:
        file.close()

    print("Merge and split complete.")


# Example usage:
file_list_path = "/tmp/files"
output_prefix = "/tmp/merged_"
num_splits = 16

merge_and_split(file_list_path, output_prefix, num_splits)

import os
import heapq

def merge_and_split(input_file_list, output_prefix, num_splits):
    """Merges files and splits the content into approximately equal-sized parts.

    Args:
        input_file_list: Path to the file containing the list of file paths.
        output_prefix: Prefix for the output files.
        num_splits: Number of output files to create.
    """

    with open(input_file_list, 'r') as f:
        file_paths = [line.strip() for line in f]

    # Sort files by size in descending order (largest first)
    file_paths.sort(key=lambda x: os.path.getsize(x), reverse=True)

    output_files = [open(f"{output_prefix}_{i}", "wb") for i in range(num_splits)]
    output_file_sizes = [0] * num_splits

    # Heap to track the smallest output file by size
    heap = [(size, i) for i, size in enumerate(output_file_sizes)]
    heapq.heapify(heap)

    for file_path in file_paths:
        try:
            _, smallest_index = heapq.heappop(heap)
            with open(file_path, "rb") as infile:
                while True:
                    chunk = infile.read(4096)  # Read in chunks (adjust as needed)
                    if not chunk:
                        break
                    output_files[smallest_index].write(chunk)
                    output_file_sizes[smallest_index] += len(chunk)
            heapq.heappush(heap, (output_file_sizes[smallest_index], smallest_index))
        except Exception as e:  # Handle potential errors like file not found
            print(f"Error processing file {file_path}: {e}")


    # Close all output files
    for file in output_files:
        file.close()


if __name__ == "__main__":
    input_file_list = "/tmp/files"
    output_prefix = "/tmp/merged"
    num_splits = 16

    # Ensure /tmp directory exists. Good practice especially in temporary environments.
    os.makedirs(os.path.dirname(output_prefix), exist_ok=True) 

    merge_and_split(input_file_list, output_prefix, num_splits)

    print("Merging and splitting complete.")

import os
import heapq

def merge_and_split(input_file_list, output_prefix, num_splits):
    """Merges files and splits the content into approximately equal-sized parts.

    Args:
        input_file_list: Path to the file containing the list of file paths.
        output_prefix: Prefix for the output files.
        num_splits: Number of output files to create.
    """

    with open(input_file_list, 'r') as f:
        file_paths = [line.strip() for line in f]

    # Sort files by size in descending order (largest first)
    file_paths.sort(key=lambda x: os.path.getsize(x), reverse=True)

    output_files = [open(f"{output_prefix}_{i}", "wb") for i in range(num_splits)]
    output_file_sizes = [0] * num_splits

    # Heap to track the smallest output file by size
    heap = [(size, i) for i, size in enumerate(output_file_sizes)]
    heapq.heapify(heap)

    for file_path in file_paths:
        try:
            _, smallest_index = heapq.heappop(heap)
            with open(file_path, "rb") as infile:
                while True:
                    chunk = infile.read(4096)  # Read in chunks (adjust as needed)
                    if not chunk:
                        break
                    output_files[smallest_index].write(chunk)
                    output_file_sizes[smallest_index] += len(chunk)
            heapq.heappush(heap, (output_file_sizes[smallest_index], smallest_index))
        except Exception as e:  # Handle potential errors like file not found
            print(f"Error processing file {file_path}: {e}")


    # Close all output files
    for file in output_files:
        file.close()


if __name__ == "__main__":
    input_file_list = "/tmp/files"
    output_prefix = "/tmp/merged"
    num_splits = 16

    # Ensure /tmp directory exists. Good practice especially in temporary environments.
    os.makedirs(os.path.dirname(output_prefix), exist_ok=True) 

    merge_and_split(input_file_list, output_prefix, num_splits)

    print("Merging and splitting complete.")

import os
import heapq

def merge_and_split(input_file_list, output_prefix, num_splits):
    """Merges files and splits the content into approximately equal-sized parts.

    Args:
        input_file_list: Path to the file containing the list of file paths.
        output_prefix: Prefix for the output files.
        num_splits: Number of output files to create.
    """

    with open(input_file_list, 'r') as f:
        file_paths = [line.strip() for line in f]

    # Sort files by size in descending order (largest first)
    file_paths.sort(key=lambda x: os.path.getsize(x), reverse=True)

    output_files = [open(f"{output_prefix}_{i}", "wb") for i in range(num_splits)]
    output_file_sizes = [0] * num_splits

    # Heap to track the smallest output file by size
    heap = [(size, i) for i, size in enumerate(output_file_sizes)]
    heapq.heapify(heap)

    for file_path in file_paths:
        try:
            _, smallest_index = heapq.heappop(heap)
            with open(file_path, "rb") as infile:
                while True:
                    chunk = infile.read(4096)  # Read in chunks (adjust as needed)
                    if not chunk:
                        break
                    output_files[smallest_index].write(chunk)
                    output_file_sizes[smallest_index] += len(chunk)
            heapq.heappush(heap, (output_file_sizes[smallest_index], smallest_index))
        except Exception as e:  # Handle potential errors like file not found
            print(f"Error processing file {file_path}: {e}")


    # Close all output files
    for file in output_files:
        file.close()


if __name__ == "__main__":
    input_file_list = "/tmp/files"
    output_prefix = "/tmp/merged"
    num_splits = 16

    # Ensure /tmp directory exists. Good practice especially in temporary environments.
    os.makedirs(os.path.dirname(output_prefix), exist_ok=True) 

    merge_and_split(input_file_list, output_prefix, num_splits)

    print("Merging and splitting complete.")

import os
import heapq

def merge_and_split_files(file_list_path, output_prefix, num_chunks=16):
    """Merges files listed in a file and splits the content into chunks.

    Args:
        file_list_path: Path to the file containing the list of file paths.
        output_prefix: Prefix for the output chunk files.
        num_chunks: Number of output chunks.
    """

    with open(file_list_path, 'r') as f:
        file_paths = [line.strip() for line in f]

    # Sort files by size in descending order
    file_paths.sort(key=lambda x: os.path.getsize(x), reverse=True)


    chunk_sizes = [0] * num_chunks
    chunk_files = []
    for i in range(num_chunks):
        chunk_file_path = f"{output_prefix}_{i}"
        chunk_files.append(open(chunk_file_path, 'wb'))  # Open in binary write mode


    for file_path in file_paths:
        # Find the smallest chunk
        min_index = chunk_sizes.index(min(chunk_sizes))

        try:
            with open(file_path, 'rb') as infile: # Open in binary read mode
                chunk_files[min_index].write(infile.read())
                chunk_sizes[min_index] += os.path.getsize(file_path)
        except FileNotFoundError:
            print(f"Warning: File not found: {file_path}")
        except Exception as e:
            print(f"Error processing file {file_path}: {e}")


    # Close all chunk files
    for chunk_file in chunk_files:
        chunk_file.close()



if __name__ == "__main__":
    file_list_path = "/tmp/files"
    output_prefix = "/tmp/merged"
    num_chunks = 16

    merge_and_split_files(file_list_path, output_prefix, num_chunks)
    print("Files merged and split successfully.")

   mkdir /tmp/testfiles
   touch /tmp/testfiles/file1.txt
   echo "some content" > /tmp/testfiles/file2.txt
   # ... create more files

   ls /tmp/testfiles/* > /tmp/files  # List file paths into /tmp/files
   

import os
import heapq

def merge_and_split_files(file_list_path, output_prefix, num_chunks=16):
    """Merges files listed in a file and splits the content into chunks.

    Args:
        file_list_path: Path to the file containing the list of file paths.
        output_prefix: Prefix for the output chunk files.
        num_chunks: Number of output chunks.
    """

    with open(file_list_path, 'r') as f:
        file_paths = [line.strip() for line in f]

    # Sort files by size in descending order
    file_paths.sort(key=lambda x: os.path.getsize(x), reverse=True)


    chunk_sizes = [0] * num_chunks
    chunk_files = []
    for i in range(num_chunks):
        chunk_file_path = f"{output_prefix}_{i}"
        chunk_files.append(open(chunk_file_path, 'wb'))  # Open in binary write mode


    for file_path in file_paths:
        # Find the smallest chunk
        min_index = chunk_sizes.index(min(chunk_sizes))

        try:
            with open(file_path, 'rb') as infile: # Open in binary read mode
                chunk_files[min_index].write(infile.read())
                chunk_sizes[min_index] += os.path.getsize(file_path)
        except FileNotFoundError:
            print(f"Warning: File not found: {file_path}")
        except Exception as e:
            print(f"Error processing file {file_path}: {e}")


    # Close all chunk files
    for chunk_file in chunk_files:
        chunk_file.close()



if __name__ == "__main__":
    file_list_path = "/tmp/files"
    output_prefix = "/tmp/merged"
    num_chunks = 16

    merge_and_split_files(file_list_path, output_prefix, num_chunks)
    print("Files merged and split successfully.")

import os
import heapq

def merge_and_split_files(file_list_path, output_prefix, num_chunks=16):
    """Merges files listed in a file and splits the content into chunks.

    Args:
        file_list_path: Path to the file containing the list of file paths.
        output_prefix: Prefix for the output chunk files.
        num_chunks: Number of output chunks.
    """

    with open(file_list_path, 'r') as f:
        file_paths = [line.strip() for line in f]

    # Sort files by size in descending order
    file_paths.sort(key=lambda x: os.path.getsize(x), reverse=True)


    chunk_sizes = [0] * num_chunks
    chunk_files = []
    for i in range(num_chunks):
        chunk_file_path = f"{output_prefix}_{i}"
        chunk_files.append(open(chunk_file_path, 'wb'))  # Open in binary write mode


    for file_path in file_paths:
        # Find the smallest chunk
        min_index = chunk_sizes.index(min(chunk_sizes))

        try:
            with open(file_path, 'rb') as infile: # Open in binary read mode
                chunk_files[min_index].write(infile.read())
                chunk_sizes[min_index] += os.path.getsize(file_path)
        except FileNotFoundError:
            print(f"Warning: File not found: {file_path}")
        except Exception as e:
            print(f"Error processing file {file_path}: {e}")


    # Close all chunk files
    for chunk_file in chunk_files:
        chunk_file.close()



if __name__ == "__main__":
    file_list_path = "/tmp/files"
    output_prefix = "/tmp/merged"
    num_chunks = 16

    merge_and_split_files(file_list_path, output_prefix, num_chunks)
    print("Files merged and split successfully.")

import os
import heapq

def merge_and_split(input_list_path, output_prefix, num_splits):
    """Merges files listed in input_list_path and splits content into num_splits files.

    Args:
        input_list_path: Path to the file containing a list of file paths.
        output_prefix: Prefix for the output files.
        num_splits: Number of output files to create.
    """

    with open(input_list_path, 'r') as f:
        file_paths = [line.strip() for line in f]

    # Sort files by size in descending order (largest first)
    file_paths.sort(key=lambda x: os.path.getsize(x), reverse=True)

    # Initialize output files and their sizes
    output_files = [open(f"{output_prefix}_{i}", "wb") for i in range(num_splits)]
    output_sizes = [0] * num_splits

    # Heap to keep track of the smallest output file
    heap = [(size, i) for i, size in enumerate(output_sizes)]
    heapq.heapify(heap)

    for file_path in file_paths:
        with open(file_path, "rb") as infile:
            # Get the smallest output file
            smallest_size, smallest_index = heapq.heappop(heap)

            # Write the contents of the current file to the smallest output file
            while True:
                chunk = infile.read(4096)  # Read in chunks to handle large files efficiently
                if not chunk:
                    break
                output_files[smallest_index].write(chunk)
                smallest_size += len(chunk)

            # Update the size of the output file and put it back into the heap
            heapq.heappush(heap, (smallest_size, smallest_index))

    # Close all output files
    for outfile in output_files:
        outfile.close()



if __name__ == "__main__":
    input_list_path = "/tmp/files"
    output_prefix = "/tmp/merged"
    num_splits = 16

    # Create /tmp/files and populate it with some dummy data for testing:
    os.makedirs("/tmp", exist_ok=True)
    with open("/tmp/files", "w") as f:
      for i in range(100): # Create 100 dummy files
        filename = f"/tmp/file_{i}"
        with open(filename, "w") as temp_f:
          temp_f.write(f"This is file {i}\n" * (i+1)) # Varying sizes
        f.write(filename + "\n")



    merge_and_split(input_list_path, output_prefix, num_splits)


    print("Merge and split complete.")

import os
import heapq

def merge_and_split(input_list_path, output_prefix, num_splits):
    """Merges files listed in input_list_path and splits content into num_splits files.

    Args:
        input_list_path: Path to the file containing a list of file paths.
        output_prefix: Prefix for the output files.
        num_splits: Number of output files to create.
    """

    with open(input_list_path, 'r') as f:
        file_paths = [line.strip() for line in f]

    # Sort files by size in descending order (largest first)
    file_paths.sort(key=lambda x: os.path.getsize(x), reverse=True)

    # Initialize output files and their sizes
    output_files = [open(f"{output_prefix}_{i}", "wb") for i in range(num_splits)]
    output_sizes = [0] * num_splits

    # Heap to keep track of the smallest output file
    heap = [(size, i) for i, size in enumerate(output_sizes)]
    heapq.heapify(heap)

    for file_path in file_paths:
        with open(file_path, "rb") as infile:
            # Get the smallest output file
            smallest_size, smallest_index = heapq.heappop(heap)

            # Write the contents of the current file to the smallest output file
            while True:
                chunk = infile.read(4096)  # Read in chunks to handle large files efficiently
                if not chunk:
                    break
                output_files[smallest_index].write(chunk)
                smallest_size += len(chunk)

            # Update the size of the output file and put it back into the heap
            heapq.heappush(heap, (smallest_size, smallest_index))

    # Close all output files
    for outfile in output_files:
        outfile.close()



if __name__ == "__main__":
    input_list_path = "/tmp/files"
    output_prefix = "/tmp/merged"
    num_splits = 16

    # Create /tmp/files and populate it with some dummy data for testing:
    os.makedirs("/tmp", exist_ok=True)
    with open("/tmp/files", "w") as f:
      for i in range(100): # Create 100 dummy files
        filename = f"/tmp/file_{i}"
        with open(filename, "w") as temp_f:
          temp_f.write(f"This is file {i}\n" * (i+1)) # Varying sizes
        f.write(filename + "\n")



    merge_and_split(input_list_path, output_prefix, num_splits)


    print("Merge and split complete.")

import os
import heapq

def merge_and_split(input_list_path, output_prefix, num_splits):
    """Merges files listed in input_list_path and splits content into num_splits files.

    Args:
        input_list_path: Path to the file containing a list of file paths.
        output_prefix: Prefix for the output files.
        num_splits: Number of output files to create.
    """

    with open(input_list_path, 'r') as f:
        file_paths = [line.strip() for line in f]

    # Sort files by size in descending order (largest first)
    file_paths.sort(key=lambda x: os.path.getsize(x), reverse=True)

    # Initialize output files and their sizes
    output_files = [open(f"{output_prefix}_{i}", "wb") for i in range(num_splits)]
    output_sizes = [0] * num_splits

    # Heap to keep track of the smallest output file
    heap = [(size, i) for i, size in enumerate(output_sizes)]
    heapq.heapify(heap)

    for file_path in file_paths:
        with open(file_path, "rb") as infile:
            # Get the smallest output file
            smallest_size, smallest_index = heapq.heappop(heap)

            # Write the contents of the current file to the smallest output file
            while True:
                chunk = infile.read(4096)  # Read in chunks to handle large files efficiently
                if not chunk:
                    break
                output_files[smallest_index].write(chunk)
                smallest_size += len(chunk)

            # Update the size of the output file and put it back into the heap
            heapq.heappush(heap, (smallest_size, smallest_index))

    # Close all output files
    for outfile in output_files:
        outfile.close()



if __name__ == "__main__":
    input_list_path = "/tmp/files"
    output_prefix = "/tmp/merged"
    num_splits = 16

    # Create /tmp/files and populate it with some dummy data for testing:
    os.makedirs("/tmp", exist_ok=True)
    with open("/tmp/files", "w") as f:
      for i in range(100): # Create 100 dummy files
        filename = f"/tmp/file_{i}"
        with open(filename, "w") as temp_f:
          temp_f.write(f"This is file {i}\n" * (i+1)) # Varying sizes
        f.write(filename + "\n")



    merge_and_split(input_list_path, output_prefix, num_splits)


    print("Merge and split complete.")

import os
import heapq

def merge_and_split(input_file_list, output_prefix, num_splits=16):
    """Merges files listed in input_file_list and splits the content into num_splits files.

    Args:
        input_file_list: Path to a file containing a list of file paths, one per line.
        output_prefix: Prefix for output file names (e.g., /tmp/merged_).
        num_splits: Number of output files to create.
    """

    with open(input_file_list, 'r') as f:
        file_paths = [line.strip() for line in f]

    # Sort files by size (largest first) using a heap (more efficient for large numbers of files)
    file_sizes = []
    for path in file_paths:
        try:
            size = os.path.getsize(path)
            heapq.heappush(file_sizes, (-size, path)) # Negative size for max-heap
        except FileNotFoundError:
            print(f"Warning: File not found: {path}")
            continue


    output_files = []
    output_sizes = [0] * num_splits

    # Create output files and store file handles
    for i in range(num_splits):
        file_path = f"{output_prefix}{i}"
        output_files.append(open(file_path, 'wb'))


    while file_sizes:
        _, file_path = heapq.heappop(file_sizes)
        try:
            # Find the smallest output file
            min_index = output_sizes.index(min(output_sizes))

            with open(file_path, 'rb') as infile:
                for chunk in iter(lambda: infile.read(4096), b''):  # Read in chunks to handle large files
                    output_files[min_index].write(chunk)
                    output_sizes[min_index] += len(chunk)
        except FileNotFoundError:
            print(f"Warning: File not found during merge: {file_path}")
            continue

    # Close all output files
    for file in output_files:
        file.close()

# Example usage:
input_file_list = "/tmp/files"  # Replace with your input file list path
output_prefix = "/tmp/merged_"
num_splits = 16
merge_and_split(input_file_list, output_prefix, num_splits)

import os
import heapq

def merge_and_split(input_file_list, output_prefix, num_splits=16):
    """Merges files listed in input_file_list and splits the content into num_splits files.

    Args:
        input_file_list: Path to a file containing a list of file paths, one per line.
        output_prefix: Prefix for output file names (e.g., /tmp/merged_).
        num_splits: Number of output files to create.
    """

    with open(input_file_list, 'r') as f:
        file_paths = [line.strip() for line in f]

    # Sort files by size (largest first) using a heap (more efficient for large numbers of files)
    file_sizes = []
    for path in file_paths:
        try:
            size = os.path.getsize(path)
            heapq.heappush(file_sizes, (-size, path)) # Negative size for max-heap
        except FileNotFoundError:
            print(f"Warning: File not found: {path}")
            continue


    output_files = []
    output_sizes = [0] * num_splits

    # Create output files and store file handles
    for i in range(num_splits):
        file_path = f"{output_prefix}{i}"
        output_files.append(open(file_path, 'wb'))


    while file_sizes:
        _, file_path = heapq.heappop(file_sizes)
        try:
            # Find the smallest output file
            min_index = output_sizes.index(min(output_sizes))

            with open(file_path, 'rb') as infile:
                for chunk in iter(lambda: infile.read(4096), b''):  # Read in chunks to handle large files
                    output_files[min_index].write(chunk)
                    output_sizes[min_index] += len(chunk)
        except FileNotFoundError:
            print(f"Warning: File not found during merge: {file_path}")
            continue

    # Close all output files
    for file in output_files:
        file.close()

# Example usage:
input_file_list = "/tmp/files"  # Replace with your input file list path
output_prefix = "/tmp/merged_"
num_splits = 16
merge_and_split(input_file_list, output_prefix, num_splits)

import os
import heapq

def merge_and_split(input_file_list, output_prefix, num_splits=16):
    """Merges files listed in input_file_list and splits the content into num_splits files.

    Args:
        input_file_list: Path to a file containing a list of file paths, one per line.
        output_prefix: Prefix for output file names (e.g., /tmp/merged_).
        num_splits: Number of output files to create.
    """

    with open(input_file_list, 'r') as f:
        file_paths = [line.strip() for line in f]

    # Sort files by size (largest first) using a heap (more efficient for large numbers of files)
    file_sizes = []
    for path in file_paths:
        try:
            size = os.path.getsize(path)
            heapq.heappush(file_sizes, (-size, path)) # Negative size for max-heap
        except FileNotFoundError:
            print(f"Warning: File not found: {path}")
            continue


    output_files = []
    output_sizes = [0] * num_splits

    # Create output files and store file handles
    for i in range(num_splits):
        file_path = f"{output_prefix}{i}"
        output_files.append(open(file_path, 'wb'))


    while file_sizes:
        _, file_path = heapq.heappop(file_sizes)
        try:
            # Find the smallest output file
            min_index = output_sizes.index(min(output_sizes))

            with open(file_path, 'rb') as infile:
                for chunk in iter(lambda: infile.read(4096), b''):  # Read in chunks to handle large files
                    output_files[min_index].write(chunk)
                    output_sizes[min_index] += len(chunk)
        except FileNotFoundError:
            print(f"Warning: File not found during merge: {file_path}")
            continue

    # Close all output files
    for file in output_files:
        file.close()

# Example usage:
input_file_list = "/tmp/files"  # Replace with your input file list path
output_prefix = "/tmp/merged_"
num_splits = 16
merge_and_split(input_file_list, output_prefix, num_splits)