// NOTE: ReadFile looks the same at the start of the function
func WriteFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error) {
	var _p0 *byte
	if len(buf) > 0 {
		_p0 = &buf[0]
                // NOTE: Don't allow writing buffers larger than 4GB as ReadFile takes uint32
		if len(buf) > 4<<30 {
			err = EINVAL
			return
		}
	}
	r1, _, e1 := Syscall6(procWriteFile.Addr(), 5, uintptr(handle), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(unsafe.Pointer(done)), uintptr(unsafe.Pointer(overlapped)), 0)
	if r1 == 0 {
		if e1 != 0 {
			err = errnoErr(e1)
		} else {
			err = EINVAL
		}
	}
	return
}

// Windows can't read or write 4GB+ files at a time with syscall.Read or syscall.Write
// even on 64-bit systems.
// Use 1GB instead of, say, 2GB-1, to keep subsequent reads aligned.
const maxRW = 1 << 30

// Read implements io.Reader.
func (fd *FD) Read(buf []byte) (int, error) {
	if err := fd.readLock(); err != nil {
		return 0, err
	}
	defer fd.readUnlock()

	var n int
	var err error
	if fd.isFile || fd.isDir || fd.isConsole {
		fd.l.Lock()
		defer fd.l.Unlock()
		if fd.isConsole {
			n, err = fd.readConsole(buf)
		} else {
			if len(buf) > maxRW {
				buf = buf[:maxRW]
			}
			n, err = syscall.Read(fd.Sysfd, buf)
		}
		if err != nil {
			n = 0
		}
	} else {
		o := &fd.rop
		o.InitBuf(buf)
		n, err = rsrv.ExecIO(o, func(o *operation) error {
			return syscall.WSARecv(o.fd.Sysfd, &o.buf, 1, &o.qty, &o.flags, &o.o, nil)
		})
		if race.Enabled {
			race.Acquire(unsafe.Pointer(&ioSync))
		}
	}
	if len(buf) != 0 {
		err = fd.eofError(n, err)
	}
	return n, err
}

// Write implements io.Writer.
func (fd *FD) Write(buf []byte) (int, error) {
	if err := fd.writeLock(); err != nil {
		return 0, err
	}
	defer fd.writeUnlock()

	var n int
	var err error
	if fd.isFile || fd.isDir || fd.isConsole {
		fd.l.Lock()
		defer fd.l.Unlock()
		if fd.isConsole {
			n, err = fd.writeConsole(buf)
			if err != nil {
				n = 0
			}
		} else {
			var nn int
			for {
				max := len(buf)
				if max-nn > maxRW {
					max = nn + maxRW
				}
				n, err = syscall.Write(fd.Sysfd, buf[nn:max])
				if n > 0 {
					nn += n
				}
				if nn == len(buf) {
					return nn, err
				}
				if err != nil {
					return nn, err
				}
				if n == 0 {
					return nn, io.ErrUnexpectedEOF
				}
			}
		}
	} else {
		if race.Enabled {
			race.ReleaseMerge(unsafe.Pointer(&ioSync))
		}
		o := &fd.wop
		o.InitBuf(buf)
		n, err = wsrv.ExecIO(o, func(o *operation) error {
			return syscall.WSASend(o.fd.Sysfd, &o.buf, 1, &o.qty, 0, &o.o, nil)
		})
	}
	return n, err
}

package main

import (
	"fmt"
	"io/ioutil"
)

const (
	slightlyLargerThan4GB = 4470475739
)

func main() {
	// Write large file, add text "end-of-the-file" to the end of it
	text := "end-of-the-file"
	data := make([]byte, slightlyLargerThan4GB-len(text), slightlyLargerThan4GB)
	data = append(data, text...)
	fmt.Printf("Writing %d bytes to \"test_write_4gb\"\n", len(data))
	err := ioutil.WriteFile("test_write_4gb", data, 0644)
	if err != nil {
		fmt.Printf("%s\n", err)
	} else {
		fmt.Printf("Written %d bytes to file.\n", len(data))
	}

	// Read large file, get the last bit of text
	fmt.Printf("Reading file \"test_write_4gb\"...\n")
	bytes, err := ioutil.ReadFile("test_write_4gb")
	if err != nil {
		panic(err)
	}
	endText := string(bytes[len(bytes)-len(text) : len(bytes)])
	if endText == "end-of-the-file" {
		fmt.Printf("SUCCESS! Loaded: %d bytes, End of file has text: %s\n", len(bytes), endText)
	} else {
		fmt.Printf("FAILURE! Loaded: %d bytes, End of file has text: %s\n", len(bytes), endText)
	}
}