}
	if err := stream.WriteTo(os.Stdout); err != nil {
		printErrorAndExit("Error writing output stream:", err)

	"io"

	"os"

func (f FileModify) WriteTo(w io.Writer) error {
	_, err := fmt.Fprintf(w, "M 644 :%d %s\n", f.Blob, f.Path)
	return err

func (f FileModify) write() {
	fmt.Printf("M 644 :%d %s\n", f.Blob, f.Path)

func (c Commit) WriteTo(w io.Writer) error {
	if _, err := fmt.Fprintln(w, "commit refs/heads/"+c.Branch); err != nil {
		return err
	}

func (c Commit) write() {
	fmt.Println("commit refs/heads/" + c.Branch)

		if _, err := fmt.Fprintf(w, "mark :%d\n", c.Mark); err != nil {
			return err
		}
	}
	if _, err := fmt.Fprintln(w, "committer", c.Committer, formatTime(c.Timestamp)); err != nil {
		return err
	}
	if _, err := fmt.Fprintln(w, "data", len(c.Message)); err != nil {
		return err
	}
	if _, err := fmt.Fprintln(w, c.Message); err != nil {
		return err

		fmt.Printf("mark :%d\n", c.Mark)

	fmt.Println("committer", c.Committer, formatTime(c.Timestamp))
	fmt.Println("data", len(c.Message))
	fmt.Println(c.Message)

		if _, err := fmt.Fprintf(w, "from :%d\n", c.From); err != nil {
			return err
		}

		fmt.Printf("from :%d\n", c.From)

		if _, err := fmt.Fprintln(w, "deleteall"); err != nil {
			return err
		}

		fmt.Println("deleteall")

		if err := m.WriteTo(w); err != nil {
			return err
		}
	}
	if _, err := fmt.Fprintln(w); err != nil {
		return err

		m.write()

	return nil

	fmt.Println()

func (b Blob) WriteTo(w io.Writer) error {
	if _, err := fmt.Fprintln(w, "blob"); err != nil {
		return err
	}

func (b Blob) write() {
	fmt.Println("blob")

		if _, err := fmt.Fprintf(w, "mark :%d\n", b.Mark); err != nil {
			return err
		}

		fmt.Printf("mark :%d\n", b.Mark)

	if _, err := fmt.Fprintln(w, "data", len(b.Data)); err != nil {
		return err
	}
	if _, err := w.Write(b.Data); err != nil {
		return err
	}
	if _, err := fmt.Fprintln(w); err != nil {
		return err
	}
	return nil

	fmt.Println("data", len(b.Data))
	os.Stdout.Write(b.Data)
	fmt.Println()

// A FastExportStream is an in-memory representation of a fast-export stream.

// A FastExportStream is a representation of a fast-export stream.

	Commits []Commit
	Blobs   []Blob

	f.Commits = append(f.Commits, c)
}
func (f *FastExportStream) ReverseCommits() {
	for i, j := 0, len(f.Commits)-1; j > i; i, j = i+1, j-1 {
		f.Commits[i], f.Commits[j] = f.Commits[j], f.Commits[i]
	}
}
func (f *FastExportStream) WriteTo(w io.Writer) error {
	for _, b := range f.Blobs {
		if err := b.WriteTo(w); err != nil {
			return err
		}
	}
	for _, c := range f.Commits {
		if err := c.WriteTo(w); err != nil {
			return err
		}
	}
	return nil

	c.write()

	f.Blobs = append(f.Blobs, b)

	b.write()