receiver to allocate each destination file to its
              eventual size before writing data to the file.  Rsync  will  only
              use  the  real filesystem‐level preallocation support provided by
              Linux’s fallocate(2) system call or Cygwin’s  posix_fallocate(3),
              not  the  slow  glibc implementation that writes a null byte into
              each block.

              Without this option, larger files may not be entirely  contiguous
              on  the filesystem, but with this option rsync will probably copy
              more slowly.  If the  destination  is  not  an  extent‐supporting
              filesystem  (such as ext4, xfs, NTFS, etc.), this option may have
              no positive effect at all.

              If combined with --sparse, the file will only have sparse  blocks
              (as  opposed  to allocated sequences of null bytes) if the kernel
              version and filesystem type support creating holes in  the  allo‐
              cated data.

       --dry‐run, -n
              This  makes  rsync  perform  a  trial  run  that doesn’t make any
              changes (and produces mostly the same output as a real run).   It
              is  most  commonly  used  in  combination with the --verbose (-v)
              and/or --itemize‐changes (-i) options to see what an  rsync  com‐
              mand is going to do before one actually runs it.

              The  output  of  --itemize‐changes  is supposed to be exactly the
              same on a dry run and a subsequent real run (barring  intentional
              trickery  and  system  call failures); if it isn’t, that’s a bug.
              Other output should be mostly unchanged, but may differ  in  some
              areas.  Notably, a dry run does not send the actual data for file
              transfers,  so --progress has no effect, the "bytes sent", "bytes
              received", "literal data", and "matched data" statistics are  too
              small,  and  the  "speedup" value is equivalent to a run where no
              file transfers were needed.

       --whole‐file, -W
              This option  disables  rsync’s  delta‐transfer  algorithm,  which
              causes  all transferred files to be sent whole.  The transfer may
              be faster if this option is used when the bandwidth  between  the
              source  and  destination machines is higher than the bandwidth to
              disk (especially when the "disk" is actually a networked filesys‐
              tem).  This is the default when both the source  and  destination
              are specified as local paths, but only if no batch‐writing option
              is in effect.

       --no‐whole‐file, --no‐W
              Disable  whole‐file  updating when it is enabled by default for a
              local transfer.  This usually slows rsync down,  but  it  can  be
              useful  if  you are trying to minimize the writes to the destina‐
              tion file (if combined with --inplace) or for testing the  check‐
              sum‐based update algorithm.

              See also the --whole‐file option.

       --checksum‐choice=STR, --cc=STR
              This  option overrides the checksum algorithms.  If one algorithm
              name is specified, it is used for both the transfer checksums and
              (assuming --checksum is specified)  the  pre‐transfer  checksums.
              If two comma‐separated names are supplied, the first name affects
              the  transfer  checksums,  and  the  second name affects the pre‐
              transfer checksums (-c).

              The checksum options that you may be able to use are:

              o      auto (the default automatic choice)

              o      xxh128

              o      xxh3

              o      xxh64 (aka xxhash)

              o      md5

              o      md4

              o      sha1

              o      none

              Run rsync