major refactor

Major refactor to use kong instead of cobra. All functionality that worked before should still be working now. Added `reorder` command
2024-12-05 10:52:58 +00:00 · 2021-07-31 22:10:44 -04:00 · 2021-07-31 22:10:44 -04:00 · 09ee1c6262
commit 09ee1c6262
parent bbf7d696db
27 changed files with 611 additions and 1155 deletions
--- a/README.md
+++ b/README.md
@ -28,9 +28,32 @@ diskii's major disadvantage is that it mostly doesn't exist yet.

 It rhymes with “whiskey”.

-Discussion/support is in
-[#apple2 on the retrocomputing Slack](https://retrocomputing.slack.com/messages/apple2/)
-(invites [here](https://retrocomputing.herokuapp.com)).
+Discussion/support is on the
+[apple2infinitum Slack](https://apple2infinitum.slack.com/)
+(invites [here](http://apple2.gs:3000/)).
+
+# Examples
+
+Get a listing of files on a DOS 3.3 disk image:
+```
+diskii ls dos33master.dsk
+```
+
+… or a ProDOS disk image:
+```
+diskii ls ProDOS_2_4_2.po
+```
+
+… or a Super-Mon disk image:
+```
+diskii ls Super-Mon-2.0.dsk 
+```
+
+Reorder the sectors in a disk image:
+```
+diskii reorder ProDOS_2_4_2.dsk ProDOS_2_4_2.po
+```
+

 # Goals

@ -74,14 +97,15 @@ My rough TODO list (apart from anything marked (✗) in the disk
 operations matrix is listed below. Anything that an actual user needs
 will be likely to get priority.

+- [ ] Make `put` accept load address for appropriate filetypes.
+- [ ] Implement `GetFile` for prodos
 - [x] Build per-platform binaries for Linux, MacOS, Windows.
 - [x] Implement `GetFile` for DOS 3.3
 - [ ] Add and implement the `-l` flag for `ls`
 - [x] Add `Delete` to the `disk.Operator` interface
  - [ ] Implement it for Super-Mon
  - [ ] Implement it for DOS 3.3
- [x] Add basic ProDOS structures
- [ ] Add ProDOS support
+- [ ] Add ProDOS support for all commands
 - [x] Make `filetypes` command use a tabwriter to write as a table

 # Related tools
--- a/cmd/applesoft.go
+++ b/cmd/applesoft.go
@ -3,87 +3,41 @@
 package cmd

 import (
-	"fmt"
 	"os"

-	"github.com/spf13/cobra"
 	"github.com/zellyn/diskii/basic"
 	"github.com/zellyn/diskii/basic/applesoft"
 	"github.com/zellyn/diskii/helpers"
+	"github.com/zellyn/diskii/types"
 )

-// applesoftCmd represents the applesoft command
-var applesoftCmd = &cobra.Command{
-	Use:   "applesoft",
-	Short: "work with applesoft programs",
-	Long: `diskii applesoft contains the subcommands useful for working
-	with Applesoft programs.`,
+type ApplesoftCmd struct {
+	Decode DecodeCmd `kong:"cmd,help='Convert a binary Applesoft program to a text LISTing.'"`
 }

-func init() {
-	RootCmd.AddCommand(applesoftCmd)
+type DecodeCmd struct {
+	Filename string `kong:"arg,default='-',type='existingfile',help='Binary Applesoft file to read, or “-” for stdin.'"`

-	// Here you will define your flags and configuration settings.
-
-	// Cobra supports Persistent Flags which will work for this command
-	// and all subcommands, e.g.:
-	// applesoftCmd.PersistentFlags().String("foo", "", "A help for foo")
-
-	// Cobra supports local flags which will only run when this command
-	// is called directly, e.g.:
-	// applesoftCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+	Location uint16 `kong:"type='anybaseuint16',default='0x801',help='Starting program location in memory.'"`
+	Raw      bool   `kong:"short='r',help='Print raw control codes (no escaping)'"`
 }

-// ----- applesoft decode command -------------------------------------------
-
-var location uint16      // flag for starting location in memory
-var rawControlCodes bool // flag for whether to skip escaping control codes
-
-// decodeCmd represents the decode command
-var decodeCmd = &cobra.Command{
-	Use:   "decode filename",
-	Short: "convert a binary applesoft program to a LISTing",
-	Long: `
-decode converts a binary Applesoft program to a text LISTing.
-
-Examples:
-decode filename # read filename
-decode -        # read stdin`,
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runDecode(args); err != nil {
-			fmt.Fprintln(os.Stderr, err.Error())
-			os.Exit(-1)
-		}
-	},
+func (d DecodeCmd) Help() string {
+	return `Examples:
+	# Dump the contents of HELLO and then decode it.
+	diskii dump dos33master.dsk HELLO | diskii applesoft decode -`
 }

-func init() {
-	applesoftCmd.AddCommand(decodeCmd)
-
-	// Here you will define your flags and configuration settings.
-
-	// Cobra supports Persistent Flags which will work for this command
-	// and all subcommands, e.g.:
-	// decodeCmd.PersistentFlags().String("foo", "", "A help for foo")
-
-	decodeCmd.Flags().Uint16VarP(&location, "location", "l", 0x801, "Starting program location in memory")
-	decodeCmd.Flags().BoolVarP(&rawControlCodes, "raw", "r", false, "Print raw control codes (no escaping)")
-}
-
-// runDecode performs the actual decode logic.
-func runDecode(args []string) error {
-	if len(args) != 1 {
-		return fmt.Errorf("decode expects one argument: the filename (or - for stdin)")
-	}
-	contents, err := helpers.FileContentsOrStdIn(args[0])
+func (d *DecodeCmd) Run(globals *types.Globals) error {
+	contents, err := helpers.FileContentsOrStdIn(d.Filename)
 	if err != nil {
 		return err
 	}
-	listing, err := applesoft.Decode(contents, location)
+	listing, err := applesoft.Decode(contents, d.Location)
 	if err != nil {
 		return err
 	}
-	if rawControlCodes {
+	if d.Raw {
 		os.Stdout.WriteString(listing.String())
 	} else {
 		os.Stdout.WriteString(basic.ChevronControlCodes(listing.String()))
--- a/cmd/catalog.go
+++ b/cmd/catalog.go
@ -11,8 +11,8 @@ import (
 )

 type LsCmd struct {
-	Order  string `kong:"default='auto',enum='auto,do,po',help='Logical-to-physical sector order.'"`
-	System string `kong:"default='auto',enum='auto,dos3',help='DOS system used for image.'"`
+	Order  types.DiskOrder `kong:"default='auto',enum='auto,do,po',help='Logical-to-physical sector order.'"`
+	System string          `kong:"default='auto',enum='auto,dos3',help='DOS system used for image.'"`

 	ShortNames bool     `kong:"short='s',help='Whether to print short filenames (only makes a difference on Super-Mon disks).'"`
 	Image      *os.File `kong:"arg,required,help='Disk/device image to read.'"`
@ -20,7 +20,7 @@ type LsCmd struct {
 }

 func (l *LsCmd) Run(globals *types.Globals) error {
-	op, order, err := disk.OpenImage(l.Image, l.Order, l.System, globals)
+	op, order, err := disk.OpenFile(l.Image, l.Order, l.System, globals.DiskOperatorFactories, globals.Debug)
 	if err != nil {
 		return fmt.Errorf("%w: %s", err, l.Image.Name())
 	}
--- a/cmd/delete.go
+++ b/cmd/delete.go
@ -2,57 +2,40 @@

 package cmd

-/*
-var missingok bool // flag for whether to consider deleting a nonexistent file okay
+import (
+	"fmt"

-// deleteCmd represents the delete command, used to delete a file.
-var deleteCmd = &cobra.Command{
-	Use:   "delete",
-	Short: "delete a file",
-	Long: `Delete a file.
+	"github.com/zellyn/diskii/disk"
+	"github.com/zellyn/diskii/types"
+)

-delete disk-image.dsk HELLO
-`,
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runDelete(args); err != nil {
-			fmt.Fprintln(os.Stderr, err.Error())
-			os.Exit(-1)
-		}
-	},
+type DeleteCmd struct {
+	Order     types.DiskOrder `kong:"default='auto',enum='auto,do,po',help='Logical-to-physical sector order.'"`
+	System    string          `kong:"default='auto',enum='auto,dos3',help='DOS system used for image.'"`
+	MissingOk bool            `kong:"short='f',help='Overwrite existing file?'"`
+
+	DiskImage string `kong:"arg,required,type='existingfile',help='Disk image to modify.'"`
+	Filename  string `kong:"arg,required,help='Filename to use on disk.'"`
 }

-func init() {
-	RootCmd.AddCommand(deleteCmd)
-	deleteCmd.Flags().BoolVarP(&missingok, "missingok", "f", false, "if true, don't consider deleting a nonexistent file an error")
+func (d DeleteCmd) Help() string {
+	return `Examples:
+	# Delete file GREMLINS on disk image games.dsk.
+	diskii rm games.dsk GREMLINS`
 }

-// runDelete performs the actual delete logic.
-func runDelete(args []string) error {
-	if len(args) != 2 {
-		return fmt.Errorf("delete expects a disk image filename, and a filename")
-	}
-	op, err := disk.Open(args[0])
+func (d *DeleteCmd) Run(globals *types.Globals) error {
+	op, order, err := disk.OpenFilename(d.DiskImage, d.Order, d.System, globals.DiskOperatorFactories, globals.Debug)
 	if err != nil {
 		return err
 	}
-	deleted, err := op.Delete(args[1])
+
+	deleted, err := op.Delete(d.Filename)
 	if err != nil {
 		return err
 	}
-	if !deleted && !missingok {
-		return fmt.Errorf("file %q not found", args[1])
+	if !deleted && !d.MissingOk {
+		return fmt.Errorf("file %q not found (use -f to prevent this being an error)", d.Filename)
 	}
-	f, err := os.Create(args[0])
-	if err != nil {
-		return err
-	}
-	_, err = op.Write(f)
-	if err != nil {
-		return err
-	}
-	if err = f.Close(); err != nil {
-		return err
-	}
-	return nil
+	return disk.WriteBack(d.DiskImage, op, order, true)
 }
-*/
--- a/cmd/dump.go
+++ b/cmd/dump.go
@ -2,43 +2,40 @@

 package cmd

-/*
-// dumpCmd represents the dump command, used to dump the raw contents
-// of a file.
-var dumpCmd = &cobra.Command{
-	Use:   "dump",
-	Short: "dump the raw contents of a file",
-	Long: `Dump the raw contents of a file.
+import (
+	"os"

-dump disk-image.dsk HELLO
-`,
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runDump(args); err != nil {
-			fmt.Fprintln(os.Stderr, err.Error())
-			os.Exit(-1)
-		}
-	},
+	"github.com/zellyn/diskii/disk"
+	"github.com/zellyn/diskii/types"
+)
+
+type DumpCmd struct {
+	Order  types.DiskOrder `kong:"default='auto',enum='auto,do,po',help='Logical-to-physical sector order.'"`
+	System string          `kong:"default='auto',enum='auto,dos3',help='DOS system used for image.'"`
+
+	DiskImage string `kong:"arg,required,type='existingfile',help='Disk image to modify.'"`
+	Filename  string `kong:"arg,required,help='Filename to use on disk.'"`
 }

-func init() {
-	RootCmd.AddCommand(dumpCmd)
+func (d DumpCmd) Help() string {
+	return `Examples:
+	# Dump file GREMLINS on disk image games.dsk.
+	diskii dump games.dsk GREMLINS`
 }

-// runDump performs the actual dump logic.
-func runDump(args []string) error {
-	if len(args) != 2 {
-		return fmt.Errorf("dump expects a disk image filename, and a filename")
-	}
-	op, err := disk.Open(args[0])
+func (d *DumpCmd) Run(globals *types.Globals) error {
+	op, _, err := disk.OpenFilename(d.DiskImage, d.Order, d.System, globals.DiskOperatorFactories, globals.Debug)
 	if err != nil {
 		return err
 	}
-	file, err := op.GetFile(args[1])
+
+	file, err := op.GetFile(d.Filename)
+	if err != nil {
+		return err
+	}
+	_, err = os.Stdout.Write(file.Data)
 	if err != nil {
 		return err
 	}
-	// TODO(zellyn): allow writing to files
-	os.Stdout.Write(file.Data)
 	return nil
 }
-*/
--- a/cmd/nakedos.go
+++ b/cmd/nakedos.go
@ -2,81 +2,78 @@

 package cmd

-/*
-// nakedosCmd represents the nakedos command
-var nakedosCmd = &cobra.Command{
-	Use:   "nakedos",
-	Short: "work with NakedOS disks",
-	Long: `diskii nakedos contains the subcommands useful for working
-with NakedOS (and Super-Mon) disks`,
-	Aliases: []string{"supermon"},
-}
+import (
+	"fmt"

-func init() {
-	RootCmd.AddCommand(nakedosCmd)
-}
+	"github.com/zellyn/diskii/disk"
+	"github.com/zellyn/diskii/supermon"
+	"github.com/zellyn/diskii/types"
+)

-// ----- mkhello command ----------------------------------------------------
-
-var address uint16         // flag for address to load at
-var start uint16           // flag for address to start execution at
 const helloName = "FHELLO" // filename to use (if Super-Mon)

-// mkhelloCmd represents the mkhello command
-var mkhelloCmd = &cobra.Command{
-	Use:   "mkhello <disk-image> filename",
-	Short: "create an FHELLO program that loads and runs another file",
-	Long: `
-mkhello creates file DF01:FHELLO that loads and runs another program at a specific address.
+type NakedOSCmd struct {
+	Mkhello MkHelloCmd `kong:"cmd,help='Create an FHELLO program that loads and runs another file.'"`
+}

+// Help shows extended help on NakedOS/Super-Mon.
+func (n NakedOSCmd) Help() string {
+	return `NakedOS and Super-Mon were created by the amazing Martin Haye. For more information see:
+	Source/docs: https://bitbucket.org/martin.haye/super-mon/
+	Presentation: https://www.kansasfest.org/2012/08/2010-haye-nakedos/`
+}
+
+type MkHelloCmd struct {
+	Order types.DiskOrder `kong:"default='auto',enum='auto,do,po',help='Logical-to-physical sector order.'"`
+
+	DiskImage string `kong:"arg,required,type='existingfile',help='Disk image to modify.'"`
+	Filename  string `kong:"arg,required,help='Name of NakedOS file to load.'"`
+
+	Address uint16 `kong:"type='anybaseuint16',default='0x6000',help='Address to load the code at.'"`
+	Start   uint16 `kong:"type='anybaseuint16',default='0xFFFF',help='Address to jump to. Defaults to 0xFFFF, which means “same as address flag”'"`
+}
+
+func (m MkHelloCmd) Help() string {
+	return `This command creates a very short DF01:FHELLO program that simply loads another program of your choice.
+	
 Examples:
-mkhello test.dsk FDEMO  # load and run FDEMO at the default address, then jump to the start of the loaded code.
-mkhello test.dsk --address 0x2000 --start 0x2100 DF06  # load and run file DF06 at address 0x2000, and jump to 0x2100.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runMkhello(args); err != nil {
-			fmt.Fprintln(os.Stderr, err.Error())
-			os.Exit(-1)
-		}
-	},
+	# Load and run FDEMO at the default address, then jump to the start of the loaded code.
+	mkhello test.dsk FDEMO
+
+	# Load and run file DF06 at address 0x2000, and jump to 0x2100.
+	mkhello test.dsk --address 0x2000 --start 0x2100 DF06`
 }

-func init() {
-	nakedosCmd.AddCommand(mkhelloCmd)
-
-	// Here you will define your flags and configuration settings.
-
-	mkhelloCmd.Flags().Uint16VarP(&address, "address", "a", 0x6000, "memory location to load code at")
-	mkhelloCmd.Flags().Uint16VarP(&start, "start", "s", 0x6000, "memory location to jump to")
-}
-
-// runMkhello performs the actual mkhello logic.
-func runMkhello(args []string) error {
-	if len(args) != 2 {
-		return fmt.Errorf("usage: diskii mkhello <disk image> <file-to-load>")
+func (m *MkHelloCmd) Run(globals *types.Globals) error {
+	if m.Start == 0xFFFF {
+		m.Start = m.Address
 	}
-	if address%256 != 0 {
-		return fmt.Errorf("address %d (%04X) not on a page boundary", address, address)
+
+	if m.Address%256 != 0 {
+		return fmt.Errorf("address %d (%04X) not on a page boundary", m.Address, m.Address)
 	}
-	if start < address {
-		return fmt.Errorf("start address %d (%04X) < load address %d (%04X)", start, start, address, address)
+	if m.Start < m.Address {
+		return fmt.Errorf("start address %d (%04X) < load address %d (%04X)", m.Start, m.Start, m.Address, m.Address)
 	}
-	op, err := disk.Open(args[0])
+
+	op, order, err := disk.OpenFilename(m.DiskImage, m.Order, "auto", globals.DiskOperatorFactories, globals.Debug)
 	if err != nil {
 		return err
 	}
+
 	if op.Name() != "nakedos" {
 		return fmt.Errorf("mkhello only works on disks of type %q; got %q", "nakedos", op.Name())
 	}
 	nakOp, ok := op.(supermon.Operator)
 	if !ok {
-		return fmt.Errorf("internal error: cannot cast to expected supermon.Operator type")
+		return fmt.Errorf("internal error: cannot cast to expected supermon.Operator type (got %T)", op)
 	}
-	addr, symbolAddr, _, err := nakOp.ST.FilesForCompoundName(args[1])
+	addr, symbolAddr, _, err := nakOp.ST.FilesForCompoundName(m.Filename)
 	if err != nil {
 		return err
 	}
 	if addr == 0 && symbolAddr == 0 {
-		return fmt.Errorf("cannot parse %q as valid filename", args[1])
+		return fmt.Errorf("cannot parse %q as valid filename", m.Filename)
 	}
 	toLoad := addr
 	if addr == 0 {
@ -86,33 +83,24 @@ func runMkhello(args []string) error {
 		0x20, 0x40, 0x03, // JSR  NAKEDOS
 		0x6D, 0x01, 0xDC, // ADC  NKRDFILE
 		0x2C, toLoad, 0xDF, // BIT ${file number to load}
-		0x2C, 0x00, byte(address >> 8), // BIT ${target page}
-		0xD8,                                // CLD
-		0x4C, byte(start), byte(start >> 8), // JMP ${target page}
+		0x2C, 0x00, byte(m.Address >> 8), // BIT ${target page}
+		0xD8,                                    // CLD
+		0x4C, byte(m.Start), byte(m.Start >> 8), // JMP ${target page}
 	}
-	fileInfo := disk.FileInfo{
-		Descriptor: disk.Descriptor{
+	fileInfo := types.FileInfo{
+		Descriptor: types.Descriptor{
 			Name:   fmt.Sprintf("DF01:%s", helloName),
 			Length: len(contents),
-			Type:   disk.FiletypeBinary,
+			Type:   types.FiletypeBinary,
 		},
 		Data: contents,
 	}
+	_ = fileInfo
+
 	_, err = op.PutFile(fileInfo, true)
 	if err != nil {
 		return err
 	}
-	f, err := os.Create(args[0])
-	if err != nil {
-		return err
-	}
-	_, err = op.Write(f)
-	if err != nil {
-		return err
-	}
-	if err = f.Close(); err != nil {
-		return err
-	}
-	return nil
+
+	return disk.WriteBack(m.DiskImage, op, order, true)
 }
-*/
--- a/cmd/put.go
+++ b/cmd/put.go
@ -2,75 +2,63 @@

 package cmd

-/*
-var filetypeName string // flag for file type
-var overwrite bool      // flag for whether to overwrite
+import (
+	"fmt"

-// putCmd represents the put command, used to put the raw contents
-// of a file.
-var putCmd = &cobra.Command{
-	Use:   "put",
-	Short: "put the raw contents of a file",
-	Long: `Put the raw contents of a file.
+	"github.com/zellyn/diskii/disk"
+	"github.com/zellyn/diskii/helpers"
+	"github.com/zellyn/diskii/types"
+)

-put disk-image.dsk HELLO <name of file with contents>
-`,
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runPut(args); err != nil {
-			fmt.Fprintln(os.Stderr, err.Error())
-			os.Exit(-1)
+type PutCmd struct {
+	Order        types.DiskOrder `kong:"default='auto',enum='auto,do,po',help='Logical-to-physical sector order.'"`
+	System       string          `kong:"default='auto',enum='auto,dos3',help='DOS system used for image.'"`
+	FiletypeName string          `kong:"default='B',help='Type of file (“diskii filetypes” to list).'"`
+	Overwrite    bool            `kong:"short='f',help='Overwrite existing file?'"`
+
+	DiskImage      string `kong:"arg,required,type='existingfile',help='Disk image to modify.'"`
+	TargetFilename string `kong:"arg,required,help='Filename to use on disk.'"`
+	SourceFilename string `kong:"arg,required,type='existingfile',help='Name of file containing data to put.'"`
+}
+
+func (p PutCmd) Help() string {
+	return `Examples:
+	# Put file gremlins.o onto disk image games.dsk, using the filename GREMLINS.
+	diskii put games.dsk GREMLINS gremlins.o`
+}
+
+func (p *PutCmd) Run(globals *types.Globals) error {
+	if p.DiskImage == "-" {
+		if p.SourceFilename == "-" {
+			return fmt.Errorf("cannot get both disk image and file contents from stdin")
 		}
-	},
-}
-
-func init() {
-	RootCmd.AddCommand(putCmd)
-	putCmd.Flags().StringVarP(&filetypeName, "type", "t", "B", "Type of file (`diskii filetypes` to list)")
-	putCmd.Flags().BoolVarP(&overwrite, "overwrite", "f", false, "whether to overwrite existing files")
-}
-
-// runPut performs the actual put logic.
-func runPut(args []string) error {
-	if len(args) != 3 {
-		return fmt.Errorf("usage: put <disk image> <target filename> <source filename>")
 	}
-	op, err := disk.Open(args[0])
-	if err != nil {
-		return err
-	}
-	contents, err := helpers.FileContentsOrStdIn(args[2])
+	op, order, err := disk.OpenFilename(p.DiskImage, p.Order, p.System, globals.DiskOperatorFactories, globals.Debug)
 	if err != nil {
 		return err
 	}

-	filetype, err := disk.FiletypeForName(filetypeName)
+	contents, err := helpers.FileContentsOrStdIn(p.SourceFilename)
 	if err != nil {
 		return err
 	}

-	fileInfo := disk.FileInfo{
-		Descriptor: disk.Descriptor{
-			Name:   args[1],
+	filetype, err := types.FiletypeForName(p.FiletypeName)
+	if err != nil {
+		return err
+	}
+	fileInfo := types.FileInfo{
+		Descriptor: types.Descriptor{
+			Name:   p.TargetFilename,
 			Length: len(contents),
 			Type:   filetype,
 		},
 		Data: contents,
 	}
-	_, err = op.PutFile(fileInfo, overwrite)
+	_, err = op.PutFile(fileInfo, p.Overwrite)
 	if err != nil {
 		return err
 	}
-	f, err := os.Create(args[0])
-	if err != nil {
-		return err
-	}
-	_, err = op.Write(f)
-	if err != nil {
-		return err
-	}
-	if err = f.Close(); err != nil {
-		return err
-	}
-	return nil
+
+	return disk.WriteBack(p.DiskImage, op, order, true)
 }
-*/
--- a/cmd/reorder.go
+++ b/cmd/reorder.go
@ -2,8 +2,6 @@ package cmd

 import (
 	"fmt"
-	"path"
-	"strings"

 	"github.com/zellyn/diskii/disk"
 	"github.com/zellyn/diskii/helpers"
@ -11,9 +9,9 @@ import (
 )

 type ReorderCmd struct {
-	Order    string `kong:"default='auto',enum='auto,do,po',help='Logical-to-physical sector order.'"`
-	NewOrder string `kong:"default='auto',enum='auto,do,po',help='New Logical-to-physical sector order.'"`
-	Force    bool   `kong:"short='s',help='Overwrite existing file?'"`
+	Order     types.DiskOrder `kong:"default='auto',enum='auto,do,po',help='Logical-to-physical sector order.'"`
+	NewOrder  types.DiskOrder `kong:"default='auto',enum='auto,do,po',help='New Logical-to-physical sector order.'"`
+	Overwrite bool            `kong:"short='f',help='Overwrite existing file?'"`

 	DiskImage    string `kong:"arg,required,type='existingfile',help='Disk image to read.'"`
 	NewDiskImage string `kong:"arg,optional,type='path',help='Disk image to write, if different.'"`
@ -44,11 +42,18 @@ func (r *ReorderCmd) Run(globals *types.Globals) error {
 	if err != nil {
 		return err
 	}
-	return helpers.WriteOutput(r.NewDiskImage, tobytes, r.DiskImage, r.Force)
+
+	overwrite := r.Overwrite
+	filename := r.NewDiskImage
+	if filename == "" {
+		filename = r.DiskImage
+		overwrite = true
+	}
+	return helpers.WriteOutput(filename, tobytes, overwrite)
 }

 // getOrders returns the input order, and the output order.
-func getOrders(inFilename string, inOrder string, outFilename string, outOrder string) (string, string, error) {
+func getOrders(inFilename string, inOrder types.DiskOrder, outFilename string, outOrder types.DiskOrder) (types.DiskOrder, types.DiskOrder, error) {
 	if inOrder == "auto" && outOrder != "auto" {
 		return oppositeOrder(outOrder), outOrder, nil
 	}
@ -62,40 +67,27 @@ func getOrders(inFilename string, inOrder string, outFilename string, outOrder s
 		return "", "", fmt.Errorf("identical order and new-order")
 	}

-	inGuess, outGuess := orderFromFilename(inFilename), orderFromFilename(outFilename)
+	inGuess, outGuess := disk.OrderFromFilename(inFilename, types.DiskOrderUnknown), disk.OrderFromFilename(outFilename, types.DiskOrderUnknown)
 	if inGuess == outGuess {
-		if inGuess == "" {
+		if inGuess == types.DiskOrderUnknown {
 			return "", "", fmt.Errorf("cannot determine input or output order from file extensions")
 		}
 		return "", "", fmt.Errorf("guessed order (%s) from file %q is the same as guessed order (%s) from file %q", inGuess, inFilename, outGuess, outFilename)
 	}

-	if inGuess == "" {
+	if inGuess == types.DiskOrderUnknown {
 		return oppositeOrder(outGuess), outGuess, nil
 	}
-	if outGuess == "" {
+	if outGuess == types.DiskOrderUnknown {
 		return inGuess, oppositeOrder(inGuess), nil
 	}
 	return inGuess, outGuess, nil
 }

 // oppositeOrder returns the opposite order from the input.
-func oppositeOrder(order string) string {
-	if order == "do" {
-		return "po"
-	}
-	return "do"
-}
-
-// orderFromFilename tries to guess the disk order from the filename, using the extension.
-func orderFromFilename(filename string) string {
-	ext := strings.ToLower(path.Ext(filename))
-	switch ext {
-	case ".dsk", ".do":
-		return "do"
-	case ".po":
-		return "po"
-	default:
-		return ""
+func oppositeOrder(order types.DiskOrder) types.DiskOrder {
+	if order == types.DiskOrderDO {
+		return types.DiskOrderPO
 	}
+	return types.DiskOrderDO
 }
--- a/cmd/root.go
+++ b/cmd/root.go
@ -1,31 +0,0 @@
-// Copyright © 2016 Zellyn Hunter <zellyn@gmail.com>
-
-package cmd
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/spf13/cobra"
-)
-
-var cfgFile string
-
-// RootCmd represents the base command when called without any subcommands
-var RootCmd = &cobra.Command{
-	Use:   "diskii",
-	Short: "Operate on Apple II disk images and their contents",
-	Long: `diskii is a commandline tool for working with Apple II disk
-images.
-
-Eventually, it aims to be a comprehensive disk image manipulation tool.`,
-}
-
-// Execute adds all child commands to the root command sets flags appropriately.
-// This is called by main.main(). It only needs to happen once to the rootCmd.
-func Execute() {
-	if err := RootCmd.Execute(); err != nil {
-		fmt.Println(err)
-		os.Exit(-1)
-	}
-}
--- a/cmd/sd.go
+++ b/cmd/sd.go
@ -4,68 +4,62 @@ package cmd

 import (
 	"fmt"
+	"io"
 	"os"

-	"github.com/spf13/cobra"
 	"github.com/zellyn/diskii/disk"
 	"github.com/zellyn/diskii/helpers"
+	"github.com/zellyn/diskii/types"
 )

-var sdAddress uint16 // flag for address to load at
-var sdStart uint16   // flag for address to start execution at
+type SDCmd struct {
+	Order types.DiskOrder `kong:"default='auto',enum='auto,do,po',help='Logical-to-physical sector order.'"`

-// mksdCmd represents the mksd command
-var mksdCmd = &cobra.Command{
-	Use:   "mksd",
-	Short: "create a Standard-Delivery disk image",
-	Long: `diskii mksd creates a "Standard Delivery" disk image containing a binary.
+	DiskImage string   `kong:"arg,required,type='path',help='Disk image to write.'"`
+	Binary    *os.File `kong:"arg,required,help='Binary file to write to the disk.'"`
+
+	Address uint16 `kong:"type='anybaseuint16',default='0x6000',help='Address to load the code at.'"`
+	Start   uint16 `kong:"type='anybaseuint16',default='0xFFFF',help='Address to jump to. Defaults to 0xFFFF, which means “same as address flag”'"`
+}
+
+func (s SDCmd) Help() string {
+	return `
 See https://github.com/peterferrie/standard-delivery for details.

 Examples:
-mksd test.dsk foo.o  # load and run foo.o at the default address, then jump to the start of the loaded code.
-mksd test.dsk foo.o --address 0x2000 --start 0x2100  # load foo.o at address 0x2000, then jump to 0x2100.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		if err := runMkSd(args); err != nil {
-			fmt.Fprintln(os.Stderr, err.Error())
-			os.Exit(-1)
-		}
-	},
+	# Load and run foo.o at the default address, then jump to the start of the loaded code.
+	diskii mksd test.dsk foo.o
+
+	# Load foo.o at address 0x2000, then jump to 0x2100.
+	diskii mksd test.dsk foo.o --address 0x2000 --start 0x2100`
 }

-func init() {
-	RootCmd.AddCommand(mksdCmd)
-	mksdCmd.Flags().Uint16VarP(&sdAddress, "address", "a", 0x6000, "memory location to load code at")
-	mksdCmd.Flags().Uint16VarP(&sdStart, "start", "s", 0x6000, "memory location to jump to")
-}
-
-// ----- mksd command -------------------------------------------------------
-
-// runMkSd performs the actual mksd logic.
-func runMkSd(args []string) error {
-	if len(args) != 2 {
-		return fmt.Errorf("usage: diskii mksd <disk image> <file-to-load>")
+func (s *SDCmd) Run(globals *types.Globals) error {
+	if s.Start == 0xFFFF {
+		s.Start = s.Address
 	}
-	contents, err := helpers.FileContentsOrStdIn(args[1])
+
+	contents, err := io.ReadAll(s.Binary)
 	if err != nil {
 		return err
 	}
-	if sdAddress%256 != 0 {
-		return fmt.Errorf("address %d (%04X) not on a page boundary", sdAddress, sdAddress)
+	if s.Address%256 != 0 {
+		return fmt.Errorf("address %d (%04X) not on a page boundary", s.Address, s.Address)
 	}
-	if sdStart < sdAddress {
-		return fmt.Errorf("start address %d (%04X) < load address %d (%04X)", sdStart, sdStart, sdAddress, sdAddress)
+	if s.Start < s.Address {
+		return fmt.Errorf("start address %d (%04X) < load address %d (%04X)", s.Start, s.Start, s.Address, s.Address)
 	}

-	if int(sdStart) >= int(sdAddress)+len(contents) {
-		end := int(sdAddress) + len(contents)
+	if int(s.Start) >= int(s.Address)+len(contents) {
+		end := int(s.Address) + len(contents)
 		return fmt.Errorf("start address %d (%04X) is beyond load address %d (%04X) + file length = %d (%04X)",
-			sdStart, sdStart, sdAddress, sdAddress, end, end)
+			s.Start, s.Start, s.Address, s.Address, end, end)
 	}

-	if int(sdStart)+len(contents) > 0xC000 {
-		end := int(sdStart) + len(contents)
+	if int(s.Start)+len(contents) > 0xC000 {
+		end := int(s.Start) + len(contents)
 		return fmt.Errorf("start address %d (%04X) + file length %d (%04X) = %d (%04X), but we can't load past page 0xBF00",
-			sdStart, sdStart, len(contents), len(contents), end, end)
+			s.Start, s.Start, len(contents), len(contents), end, end)
 	}

 	sectors := (len(contents) + 255) / 256
@ -76,11 +70,11 @@ func runMkSd(args []string) error {
 		0xc8, 0xa5, 0x27, 0xf0, 0xdf, 0x8a, 0x4a, 0x4a, 0x4a, 0x4a, 0x09, 0xc0, 0x48, 0xa9, 0x5b,
 		0x48, 0x60, 0xe6, 0x41, 0x06, 0x40, 0x20, 0x37, 0x08, 0x18, 0x20, 0x3c, 0x08, 0xe6, 0x40,
 		0xa5, 0x40, 0x29, 0x03, 0x2a, 0x05, 0x2b, 0xa8, 0xb9, 0x80, 0xc0, 0xa9, 0x30, 0x4c, 0xa8,
-		0xfc, 0x4c, byte(sdStart), byte(sdStart >> 8),
+		0xfc, 0x4c, byte(s.Start), byte(s.Start >> 8),
 	}

 	if len(loader)+sectors+1 > 256 {
-		return fmt.Errorf("file %q is %d bytes long, max is %d", args[1], len(contents), (255-len(loader))*256)
+		return fmt.Errorf("file %q is %d bytes long, max is %d", s.Binary.Name(), len(contents), (255-len(loader))*256)
 	}

 	for len(contents)%256 != 0 {
@ -102,7 +96,7 @@ func runMkSd(args []string) error {
 			}
 		}

-		address := int(sdAddress) + i
+		address := int(s.Address) + i
 		loader = append(loader, byte(address>>8))
 		if err := disk.WriteSector(diskbytes, track, sector, contents[i:i+256]); err != nil {
 			return err
@ -118,17 +112,13 @@ func runMkSd(args []string) error {
 		return err
 	}

-	f, err := os.Create(args[0])
+	order := s.Order
+	if order == types.DiskOrderAuto {
+		order = disk.OrderFromFilename(s.DiskImage, types.DiskOrderDO)
+	}
+	rawBytes, err := disk.Swizzle(diskbytes, disk.PhysicalToLogicalByName[order])
 	if err != nil {
 		return err
 	}
-	return fmt.Errorf("write not implemented")
-	//_, err = sd.Write(f)
-	if err != nil {
-		return err
-	}
-	if err = f.Close(); err != nil {
-		return err
-	}
-	return nil
+	return helpers.WriteOutput(s.DiskImage, rawBytes, true)
 }
--- a/data/disks/prodos-users-disk.dsk
+++ b/data/disks/prodos-users-disk.dsk
--- a/disk/disk.go
+++ b/disk/disk.go
@ -4,13 +4,16 @@
 // file formats.
 package disk

+import "github.com/zellyn/diskii/types"
+
 // Various DOS33 disk characteristics.
 const (
 	FloppyTracks  = 35
 	FloppySectors = 16 // Sectors per track
 	// FloppyDiskBytes is the number of bytes on a DOS 3.3 disk.
-	FloppyDiskBytes  = 143360              // 35 tracks * 16 sectors * 256 bytes
-	FloppyTrackBytes = 256 * FloppySectors // Bytes per track
+	FloppyDiskBytes         = 143360              // 35 tracks * 16 sectors * 256 bytes
+	FloppyTrackBytes        = 256 * FloppySectors // Bytes per track
+	FloppyDiskBytes13Sector = 35 * 13 * 256
 )

 // Dos33LogicalToPhysicalSectorMap maps logical sector numbers to physical ones.
@ -43,16 +46,18 @@ var ProDosPhysicalToLogicalSectorMap = []int{

 // LogicalToPhysicalByName maps from "do" and "po" to the corresponding
 // logical-to-physical ordering.
-var LogicalToPhysicalByName map[string][]int = map[string][]int{
-	"do": Dos33LogicalToPhysicalSectorMap,
-	"po": ProDOSLogicalToPhysicalSectorMap,
+var LogicalToPhysicalByName map[types.DiskOrder][]int = map[types.DiskOrder][]int{
+	types.DiskOrderDO:  Dos33LogicalToPhysicalSectorMap,
+	types.DiskOrderPO:  ProDOSLogicalToPhysicalSectorMap,
+	types.DiskOrderRaw: {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F},
 }

 // PhysicalToLogicalByName maps from "do" and "po" to the corresponding
 // physical-to-logical ordering.
-var PhysicalToLogicalByName map[string][]int = map[string][]int{
-	"do": Dos33PhysicalToLogicalSectorMap,
-	"po": ProDosPhysicalToLogicalSectorMap,
+var PhysicalToLogicalByName map[types.DiskOrder][]int = map[types.DiskOrder][]int{
+	types.DiskOrderDO:  Dos33PhysicalToLogicalSectorMap,
+	types.DiskOrderPO:  ProDosPhysicalToLogicalSectorMap,
+	types.DiskOrderRaw: {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F},
 }

 // TrackSector is a pair of track/sector bytes.
--- a/disk/open.go
+++ b/disk/open.go
@ -7,24 +7,81 @@ import (
 	"path"
 	"strings"

+	"github.com/zellyn/diskii/helpers"
 	"github.com/zellyn/diskii/types"
 )

-// OpenImage attempts to open an image on disk, using the provided ordering and system type.
-func OpenImage(file *os.File, order string, system string, globals *types.Globals) (types.Operator, string, error) {
+// OpenFilename attempts to open a disk or device image, using the provided ordering and system type.
+func OpenFilename(filename string, order types.DiskOrder, system string, operatorFactories []types.OperatorFactory, debug bool) (types.Operator, types.DiskOrder, error) {
+	if filename == "-" {
+		return OpenFile(os.Stdin, order, system, operatorFactories, debug)
+	}
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, "", err
+	}
+	return OpenFile(file, order, system, operatorFactories, debug)
+}
+
+// OpenImage attempts to open a disk or device image, using the provided ordering and system type.
+// OpenImage will close the file.
+func OpenFile(file *os.File, order types.DiskOrder, system string, operatorFactories []types.OperatorFactory, debug bool) (types.Operator, types.DiskOrder, error) {
 	bb, err := io.ReadAll(file)
 	if err != nil {
 		return nil, "", err
 	}
-	if len(bb) == FloppyDiskBytes {
-		return openDoOrPo(bb, order, system, globals, strings.ToLower(path.Ext(file.Name())))
+	if err := file.Close(); err != nil {
+		return nil, "", err
 	}
-	return nil, "", fmt.Errorf("OpenImage not implemented yet for non-disk-sized images")
+	return OpenImage(bb, file.Name(), order, system, operatorFactories, debug)
 }

-func openDoOrPo(diskbytes []byte, order string, system string, globals *types.Globals, ext string) (types.Operator, string, error) {
+// OpenImage attempts to open a disk or device image, using the provided ordering and system type.
+func OpenImage(filebytes []byte, filename string, order types.DiskOrder, system string, operatorFactories []types.OperatorFactory, debug bool) (types.Operator, types.DiskOrder, error) {
+	ext := strings.ToLower(path.Ext(filename))
+	size := len(filebytes)
+	if size == FloppyDiskBytes {
+		return openDoOrPo(filebytes, order, system, ext, operatorFactories, debug)
+	}
+	if size == FloppyDiskBytes13Sector {
+		return nil, "", fmt.Errorf("cannot open 13-sector disk images (yet)")
+	}
+
+	if ext == ".hdv" {
+		return openHDV(filebytes, order, system, operatorFactories, debug)
+	}
+	return nil, "", fmt.Errorf("can only open disk-sized images and .hdv files")
+}
+
+func openHDV(rawbytes []byte, order types.DiskOrder, system string, operatorFactories []types.OperatorFactory, debug bool) (types.Operator, types.DiskOrder, error) {
+	size := len(rawbytes)
+	if size%512 > 0 {
+		return nil, "", fmt.Errorf("can only open .hdv files that are a multiple of 512 bytes: %d %% 512 == %d", size, size%512)
+	}
+	if size/512 > 65536 {
+		return nil, "", fmt.Errorf("can only open .hdv up to size 32MiB (%d); got %d", 65536*512, size)
+	}
+	if order != "auto" && order != types.DiskOrderPO {
+		return nil, "", fmt.Errorf("cannot open .hdv file in %q order", order)
+	}
+	if system != "auto" && system != "prodos" {
+		return nil, "", fmt.Errorf("cannot open .hdv file with %q system", system)
+	}
+	for _, factory := range operatorFactories {
+		if factory.Name() == "prodos" {
+			op, err := factory.Operator(rawbytes, debug)
+			if err != nil {
+				return nil, "", err
+			}
+			return op, types.DiskOrderPO, nil
+		}
+	}
+	return nil, "", fmt.Errorf("unable to find prodos module to open .hdv file") // Should not happen.
+}
+
+func openDoOrPo(rawbytes []byte, order types.DiskOrder, system string, ext string, operatorFactories []types.OperatorFactory, debug bool) (types.Operator, types.DiskOrder, error) {
 	var factories []types.OperatorFactory
-	for _, factory := range globals.DiskOperatorFactories {
+	for _, factory := range operatorFactories {
 		if system == "auto" || system == factory.Name() {
 			factories = append(factories, factory)
 		}
@ -32,18 +89,18 @@ func openDoOrPo(diskbytes []byte, order string, system string, globals *types.Gl
 	if len(factories) == 0 {
 		return nil, "", fmt.Errorf("cannot find disk system with name %q", system)
 	}
-	orders := []string{order}
+	orders := []types.DiskOrder{order}
 	switch order {
-	case "do", "po":
+	case types.DiskOrderDO, types.DiskOrderPO:
 		// nothing more
-	case "auto":
+	case types.DiskOrderAuto:
 		switch ext {
 		case ".po":
-			orders = []string{"po"}
+			orders = []types.DiskOrder{types.DiskOrderPO}
 		case ".do":
-			orders = []string{"do"}
+			orders = []types.DiskOrder{types.DiskOrderDO}
 		case ".dsk", "":
-			orders = []string{"do", "po"}
+			orders = []types.DiskOrder{types.DiskOrderDO, types.DiskOrderPO}
 		default:
 			return nil, "", fmt.Errorf("unknown disk image extension: %q", ext)
 		}
@ -52,31 +109,36 @@ func openDoOrPo(diskbytes []byte, order string, system string, globals *types.Gl
 	}

 	for _, order := range orders {
-		swizzled, err := Swizzle(diskbytes, LogicalToPhysicalByName[order])
+		swizzled, err := Swizzle(rawbytes, LogicalToPhysicalByName[order])
 		if err != nil {
 			return nil, "", err
 		}
 		for _, factory := range factories {
+			diskbytes, err := Swizzle(swizzled, PhysicalToLogicalByName[factory.DiskOrder()])
+			if err != nil {
+				return nil, "", err
+			}
+
 			if len(orders) == 1 && system != "auto" {
-				if globals.Debug {
+				if debug {
 					fmt.Fprintf(os.Stderr, "Attempting to open with order=%s, system=%s.\n", order, factory.Name())
 				}
-				op, err := factory.Operator(swizzled, globals.Debug)
+				op, err := factory.Operator(diskbytes, debug)
 				if err != nil {
 					return nil, "", err
 				}
 				return op, order, nil
 			}

-			if globals.Debug {
+			if debug {
 				fmt.Fprintf(os.Stderr, "Testing whether order=%s, system=%s seems to match.\n", order, factory.Name())
 			}
-			if factory.SeemsToMatch(swizzled, globals.Debug) {
-				op, err := factory.Operator(swizzled, globals.Debug)
+			if factory.SeemsToMatch(diskbytes, debug) {
+				op, err := factory.Operator(diskbytes, debug)
 				if err == nil {
 					return op, order, nil
 				}
-				if globals.Debug {
+				if debug {
 					fmt.Fprintf(os.Stderr, "Got error opening with order=%s, system=%s: %v\n", order, factory.Name(), err)
 				}
 			}
@ -140,3 +202,39 @@ func validateOrder(order []int) error {
 	}
 	return nil
 }
+
+// OrderFromFilename tries to guess the disk order from the filename, using the extension.
+func OrderFromFilename(filename string, defaultOrder types.DiskOrder) types.DiskOrder {
+	ext := strings.ToLower(path.Ext(filename))
+	switch ext {
+	case ".dsk", ".do":
+		return types.DiskOrderDO
+	case ".po":
+		return types.DiskOrderPO
+	default:
+		return defaultOrder
+	}
+}
+
+// WriteBack writes a disk image back out.
+func WriteBack(filename string, op types.Operator, diskFileOrder types.DiskOrder, overwrite bool) error {
+	logicalBytes := op.GetBytes()
+	// If it's not floppy-sized, we don't swizzle at all.
+	if len(logicalBytes) != FloppyDiskBytes {
+		return helpers.WriteOutput(filename, logicalBytes, overwrite)
+	}
+
+	// Go from logical sectors for the operator back to physical sectors.
+	physicalBytes, err := Swizzle(logicalBytes, LogicalToPhysicalByName[op.DiskOrder()])
+	if err != nil {
+		return err
+	}
+
+	// Go from physical sectors to the disk order (DO or PO)
+	diskBytes, err := Swizzle(physicalBytes, PhysicalToLogicalByName[diskFileOrder])
+	if err != nil {
+		return err
+	}
+
+	return helpers.WriteOutput(filename, diskBytes, overwrite)
+}
--- a/dos3/dos3.go
+++ b/dos3/dos3.go
@ -671,6 +671,16 @@ func (o operator) PutFile(fileInfo types.FileInfo, overwrite bool) (existed bool
 	return false, fmt.Errorf("%s does not implement PutFile yet", operatorName)
 }

+// DiskOrder returns the Physical-to-Logical mapping order.
+func (o operator) DiskOrder() types.DiskOrder {
+	return types.DiskOrderDO
+}
+
+// GetBytes returns the disk image bytes, in logical order.
+func (o operator) GetBytes() []byte {
+	return o.data
+}
+
 // OperatorFactory is a types.OperatorFactory for DOS 3.3 disks.
 type OperatorFactory struct {
 }
@ -682,13 +692,9 @@ func (of OperatorFactory) Name() string {

 // SeemsToMatch returns true if the []byte disk image seems to match the
 // system of this operator.
-func (of OperatorFactory) SeemsToMatch(rawbytes []byte, debug bool) bool {
+func (of OperatorFactory) SeemsToMatch(diskbytes []byte, debug bool) bool {
 	// For now, just return true if we can run Catalog successfully.
-	swizzled, err := of.swizzle(rawbytes)
-	if err != nil {
-		return false
-	}
-	_, _, err = ReadCatalog(swizzled, debug)
+	_, _, err := ReadCatalog(diskbytes, debug)
 	if err != nil {
 		return false
 	}
@ -696,14 +702,11 @@ func (of OperatorFactory) SeemsToMatch(rawbytes []byte, debug bool) bool {
 }

 // Operator returns an Operator for the []byte disk image.
-func (of OperatorFactory) Operator(rawbytes []byte, debug bool) (types.Operator, error) {
-	swizzled, err := of.swizzle(rawbytes)
-	if err != nil {
-		return nil, err
-	}
-	return operator{data: swizzled, debug: debug}, nil
+func (of OperatorFactory) Operator(diskbytes []byte, debug bool) (types.Operator, error) {
+	return operator{data: diskbytes, debug: debug}, nil
 }

-func (of OperatorFactory) swizzle(rawbytes []byte) ([]byte, error) {
-	return disk.Swizzle(rawbytes, disk.Dos33PhysicalToLogicalSectorMap)
+// DiskOrder returns the Physical-to-Logical mapping order.
+func (of OperatorFactory) DiskOrder() types.DiskOrder {
+	return operator{}.DiskOrder()
 }
--- a/generate.go
+++ b/generate.go
@ -1,8 +0,0 @@
-// This file contains the list of commands to run to re-generate
-// generated files.
-
-// Use go-bindata to embed static assets that we need.
-//go:generate go-bindata -pkg data -prefix "data/" -o data/data.go data/disks data/boot
-//go:generate goimports -w data/data.go
-
-package main
--- a/go.mod
+++ b/go.mod
@ -3,8 +3,7 @@ module github.com/zellyn/diskii
 go 1.16

 require (
-	github.com/alecthomas/kong v0.2.17 // indirect
+	github.com/alecthomas/kong v0.2.17
 	github.com/kr/pretty v0.2.1
-	github.com/spf13/cobra v1.1.3
-	github.com/spf13/viper v1.8.1
+	github.com/rogpeppe/go-internal v1.8.0
 )
--- a/go.sum
+++ b/go.sum
@ -1,673 +1,30 @@
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
-cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
-cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
-cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
-cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
-cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
-cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
-cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
-cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
-cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
-cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
-cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
-cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
-cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI=
-cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk=
-cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg=
-cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8=
-cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0=
-cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
-cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
-cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
-cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
-cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
-cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
-cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
-cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
-cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk=
-cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
-cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
-cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
-cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
-cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
-cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
-cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
-cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
-cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
-dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/alecthomas/kong v0.2.17 h1:URDISCI96MIgcIlQyoCAlhOmrSw6pZScBNkctg8r0W0=
 github.com/alecthomas/kong v0.2.17/go.mod h1:ka3VZ8GZNPXv9Ov+j4YNLkI8mTuhXyr/0ktSlqIydQQ=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
-github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
-github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
-github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
-github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
-github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
-github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84=
-github.com/bketelsen/crypt v0.0.4/go.mod h1:aI6NrJ0pMGgvZKL1iVgXLnfIFJtfV+bKCoqOes/6LfM=
-github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
-github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
-github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
-github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
-github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
-github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
-github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
-github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
-github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
-github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
-github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
-github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
-github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
-github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
-github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
-github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
-github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
-github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
-github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
-github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=