Ran go fmt

5 files changed, 356 insertions, 278 deletions

diff --git a/autoaudio.go b/autoaudio.go
index dcf6cb9..5bd6fd3 100644
--- a/autoaudio.go
+++ b/autoaudio.go
@@ -20,76 +20,94 @@ along with AutoArt.  If not, see <https://www.gnu.org/licenses/>.
 package main
 
 import (
-    "bufio"
-    "os"
-    "github.com/pommicket/autoart/autoart"
-    "github.com/pommicket/autoart/autoutils"
-    "fmt"
-    "math/rand"
-    "time"
+	"bufio"
+	"fmt"
+	"github.com/pommicket/autoart/autoart"
+	"github.com/pommicket/autoart/autoutils"
+	"math/rand"
+	"os"
+	"time"
 )
 
 func generateAudio(seed int64, length int64, sampleRate int64, functionLength int64, number int64) error {
-    rand.Seed(seed)
-    dir := fmt.Sprintf("autoaudio%v", seed)
-    err := os.MkdirAll(dir, 0700)
-    if err != nil { return err }
-    err = autoutils.RunInBatches(number, "Generating audio...", func (n int64, errs chan<- error) {
-        filename := fmt.Sprintf("%v/%09d.wav", dir, n)
-        file, err := os.Create(filename)
-        if err != nil {
-            errs <- err
-            return
-        }
-        err = autoart.GenerateAudio(file, float64(length), int32(sampleRate), int(functionLength), autoart.MOD)
-        if err != nil {
-            errs <- err
-            return
-        }
-        errs <- file.Close()
-    })
-    if err != nil { return err }
-    fmt.Println("Done. Your audio is in this directory:", dir)
-    return nil
+	rand.Seed(seed)
+	dir := fmt.Sprintf("autoaudio%v", seed)
+	err := os.MkdirAll(dir, 0700)
+	if err != nil {
+		return err
+	}
+	err = autoutils.RunInBatches(number, "Generating audio...", func(n int64, errs chan<- error) {
+		filename := fmt.Sprintf("%v/%09d.wav", dir, n)
+		file, err := os.Create(filename)
+		if err != nil {
+			errs <- err
+			return
+		}
+		err = autoart.GenerateAudio(file, float64(length), int32(sampleRate), int(functionLength), autoart.MOD)
+		if err != nil {
+			errs <- err
+			return
+		}
+		errs <- file.Close()
+	})
+	if err != nil {
+		return err
+	}
+	fmt.Println("Done. Your audio is in this directory:", dir)
+	return nil
 }
 
 func autoAudio(reader *bufio.Reader) error {
-    prompt := `How many options do you want?
+	prompt := `How many options do you want?
 1. None - Just make some audio
 2. Some - Basic options
 3. All  - Advanced options
 Please enter 1, 2, or 3 (default: 1): `
-    option, err := readInt64(reader, prompt, func (i int64) bool {
-        return i >= 1 && i <= 3
-    }, 1)
-    if err != nil {
-        return err
-    }
-    t := time.Now().UTC().UnixNano()
-    if option == 1 {
-        filename := fmt.Sprintf("autoaudio%v.wav", t)
-        rand.Seed(t)
-        file, err := os.Create(filename)
-        if err != nil { return err }
-        err = autoart.GenerateAudio(file, 60, 44100, 80, autoart.MOD)
-        if err != nil { return err }
-        fmt.Println("Generated audio:", filename)
-        return nil
-    }
-    positive := func (i int64) bool { return i > 0 }
-    length, err := readInt64(reader, "Length in seconds (default: 60)? ", positive, 60)
-    if err != nil { return err }
-    number, err := readInt64(reader, "Number (default: 1)? ", positive, 1)
-    if err != nil { return err }
-    if option == 2 {
-        return generateAudio(t, length, 44100, 80, number)
-    }
-    sampleRate, err := readInt64(reader, "Sample rate (default: 44100)? ", positive, 44100)
-    if err != nil { return err }
-    functionLength, err := readInt64(reader, "Function length (default: 80)? ", positive, 80)
-    if err != nil { return err }
-    seed, err := readInt64(reader, "Random seed (default: current time)? ", positive, t)
-    if err != nil { return err }
-    return generateAudio(seed, length, sampleRate, functionLength, number)
+	option, err := readInt64(reader, prompt, func(i int64) bool {
+		return i >= 1 && i <= 3
+	}, 1)
+	if err != nil {
+		return err
+	}
+	t := time.Now().UTC().UnixNano()
+	if option == 1 {
+		filename := fmt.Sprintf("autoaudio%v.wav", t)
+		rand.Seed(t)
+		file, err := os.Create(filename)
+		if err != nil {
+			return err
+		}
+		err = autoart.GenerateAudio(file, 60, 44100, 80, autoart.MOD)
+		if err != nil {
+			return err
+		}
+		fmt.Println("Generated audio:", filename)
+		return nil
+	}
+	positive := func(i int64) bool { return i > 0 }
+	length, err := readInt64(reader, "Length in seconds (default: 60)? ", positive, 60)
+	if err != nil {
+		return err
+	}
+	number, err := readInt64(reader, "Number (default: 1)? ", positive, 1)
+	if err != nil {
+		return err
+	}
+	if option == 2 {
+		return generateAudio(t, length, 44100, 80, number)
+	}
+	sampleRate, err := readInt64(reader, "Sample rate (default: 44100)? ", positive, 44100)
+	if err != nil {
+		return err
+	}
+	functionLength, err := readInt64(reader, "Function length (default: 80)? ", positive, 80)
+	if err != nil {
+		return err
+	}
+	seed, err := readInt64(reader, "Random seed (default: current time)? ", positive, t)
+	if err != nil {
+		return err
+	}
+	return generateAudio(seed, length, sampleRate, functionLength, number)
 
-}
\ No newline at end of file
+}
diff --git a/autoimages.go b/autoimages.go
index 983e12c..54a7a0f 100644
--- a/autoimages.go
+++ b/autoimages.go
@@ -20,15 +20,15 @@ along with AutoArt.  If not, see <https://www.gnu.org/licenses/>.
 package main
 
 import (
-    "fmt"
-    "bufio"
-    "github.com/pommicket/autoart/autoart"
-    "github.com/pommicket/autoart/autoutils"
-    "os"
-    "image/png"
-    "math/rand"
-    "time"
+	"bufio"
+	"fmt"
+	"github.com/pommicket/autoart/autoart"
+	"github.com/pommicket/autoart/autoutils"
 	"image"
+	"image/png"
+	"math/rand"
+	"os"
+	"time"
 )
 
 // AutoImages client
@@ -40,85 +40,102 @@ func genImage(width int, height int, paletted bool, conf *autoart.Config, pconf
 	} else {
 		img = autoart.GenerateImage(width, height, *conf)
 	}
-    file, err := os.Create(filename)
-    if err != nil { return err }
-    err = png.Encode(file, img)
-    if err != nil {
-        file.Close()
-        return err
-    }
-    return file.Close()
+	file, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+	err = png.Encode(file, img)
+	if err != nil {
+		file.Close()
+		return err
+	}
+	return file.Close()
 }
 
 func batchedImages(seed int64, width int, height int, paletted bool, conf *autoart.Config, pconf *autoart.PaletteConfig, number int64) error {
-    // Create a directory for the images
+	// Create a directory for the images
 	rand.Seed(seed)
 	dir := fmt.Sprintf("autoimages%v", seed)
-    err := os.MkdirAll(dir, 0700)
-    if err != nil { return err }
-    err = autoutils.RunInBatches(number, "Generating images...", func (n int64, errs chan<- error) {
-        filename := fmt.Sprintf("%v/%09d.png", dir, n)
-        errs <- genImage(width, height, paletted, conf, pconf, filename)
-    })
+	err := os.MkdirAll(dir, 0700)
+	if err != nil {
+		return err
+	}
+	err = autoutils.RunInBatches(number, "Generating images...", func(n int64, errs chan<- error) {
+		filename := fmt.Sprintf("%v/%09d.png", dir, n)
+		errs <- genImage(width, height, paletted, conf, pconf, filename)
+	})
 
-    if err != nil { return err }
-    fmt.Println("Done! Your images are in this directory:", dir)
-    return nil
+	if err != nil {
+		return err
+	}
+	fmt.Println("Done! Your images are in this directory:", dir)
+	return nil
 }
 
 func autoImages(reader *bufio.Reader) error {
-    prompt := `How many options do you want?
+	prompt := `How many options do you want?
 1. None - Just make an image
 2. Some - Basic options
 3. All  - Advanced options
 Please enter 1, 2, or 3 (default: 1): `
-    option, err := readInt64(reader, prompt, func (i int64) bool {
-        return i >= 1 && i <= 3
-    }, 1)
-    if err != nil {
-        return err
-    }
-    var conf autoart.Config
+	option, err := readInt64(reader, prompt, func(i int64) bool {
+		return i >= 1 && i <= 3
+	}, 1)
+	if err != nil {
+		return err
+	}
+	var conf autoart.Config
 	var pconf autoart.PaletteConfig
-    t := time.Now().UTC().UnixNano()
-    if option == 1 {
-        rand.Seed(t)
-        fmt.Println("Generating image...")
-        filename := fmt.Sprintf("autoimages%d.png", t)
-        err = genImage(1920, 1080, false, &conf, &pconf, filename)
-        if err != nil {
-            // We're done!
-            fmt.Println("Generated an image:", filename)
-        }
-        return err
-    }
-    // Basic options
-    positive := func (i int64) bool { return i > 0 }
-    width, err := readInt64(reader, "Width (default: 1920)? ", positive, 1920)
-    if err != nil { return err }
-    height, err := readInt64(reader, "Height (default: 1080)? ", positive, 1080)
-    if err != nil { return err }
-    number, err := readInt64(reader, "How many (default: 1)? ", positive, 1)
-    if err != nil { return err }
-    if option == 2 {
-        return batchedImages(t, int(width), int(height), false, &conf, &pconf, number)
-    }
+	t := time.Now().UTC().UnixNano()
+	if option == 1 {
+		rand.Seed(t)
+		fmt.Println("Generating image...")
+		filename := fmt.Sprintf("autoimages%d.png", t)
+		err = genImage(1920, 1080, false, &conf, &pconf, filename)
+		if err != nil {
+			// We're done!
+			fmt.Println("Generated an image:", filename)
+		}
+		return err
+	}
+	// Basic options
+	positive := func(i int64) bool { return i > 0 }
+	width, err := readInt64(reader, "Width (default: 1920)? ", positive, 1920)
+	if err != nil {
+		return err
+	}
+	height, err := readInt64(reader, "Height (default: 1080)? ", positive, 1080)
+	if err != nil {
+		return err
+	}
+	number, err := readInt64(reader, "How many (default: 1)? ", positive, 1)
+	if err != nil {
+		return err
+	}
+	if option == 2 {
+		return batchedImages(t, int(width), int(height), false, &conf, &pconf, number)
+	}
 
 	paletted, err := readBool(reader, "Should a palette be used (y/n, default: n)? ", false)
-	if err != nil { return err }
-
+	if err != nil {
+		return err
+	}
 
-    // Advanced options
+	// Advanced options
 	if paletted {
 		err = readPaletteConf(reader, &pconf)
-		if err != nil { return err }
+		if err != nil {
+			return err
+		}
 	} else {
 		err = readConf(reader, &conf)
-		if err != nil { return err }
+		if err != nil {
+			return err
+		}
 	}
-	seed, err := readInt64(reader, "Random seed (default: current time)? ", func (i int64) bool {
-        return true
-    }, t)
+	seed, err := readInt64(reader, "Random seed (default: current time)? ", func(i int64) bool {
+		return true
+	}, t)
 
-    return batchedImages(seed, int(width), int(height), paletted, &conf, &pconf, number)
+	return batchedImages(seed, int(width), int(height), paletted, &conf, &pconf, number)
 }
diff --git a/autovideos.go b/autovideos.go
index dd22753..65321d6 100644
--- a/autovideos.go
+++ b/autovideos.go
@@ -21,24 +21,26 @@ package main
 
 import (
 	"bufio"
-	"github.com/pommicket/autoart/autoart"
-	"time"
 	"fmt"
-	"os"
-    "os/exec"
-	"math/rand"
+	"github.com/pommicket/autoart/autoart"
 	"io/ioutil"
+	"math/rand"
+	"os"
+	"os/exec"
+	"time"
 )
 
 func autoVideos(reader *bufio.Reader) error {
-    // Check if the user has ffmpeg
-    cmd := exec.Command("ffmpeg", "-version")
+	// Check if the user has ffmpeg
+	cmd := exec.Command("ffmpeg", "-version")
 	if err := cmd.Run(); err != nil {
 		return fmt.Errorf("Is ffmpeg installed? (%v)", err)
 	}
 
 	tmp, err := ioutil.TempFile("", "frame*.png")
-	if err != nil { return err }
+	if err != nil {
+		return err
+	}
 	tmpName := tmp.Name()
 	tmp.Close()
 	os.Remove(tmpName)
@@ -51,84 +53,107 @@ func autoVideos(reader *bufio.Reader) error {
 2. Some - Basic options
 3. All  - Advanced options
 Please enter 1, 2, or 3 (default: 1): `
-    option, err := readInt64(reader, prompt, func (i int64) bool {
-        return i >= 1 && i <= 3
-    }, 1)
-    if err != nil {
-        return err
-    }
-    var conf autoart.Config
-    t := time.Now().UTC().UnixNano()
+	option, err := readInt64(reader, prompt, func(i int64) bool {
+		return i >= 1 && i <= 3
+	}, 1)
+	if err != nil {
+		return err
+	}
+	var conf autoart.Config
+	t := time.Now().UTC().UnixNano()
 	if option == 1 {
-        rand.Seed(t)
-        filename := fmt.Sprintf("autovideos%v.mp4", t)
+		rand.Seed(t)
+		filename := fmt.Sprintf("autovideos%v.mp4", t)
 		err := autoart.GenerateVideo(1440, 900, conf, 10, 24, filename, true)
-        fmt.Println("Generated video:", filename)
-        return err
+		fmt.Println("Generated video:", filename)
+		return err
 	}
-	positive := func (i int64) bool { return i > 0 }
+	positive := func(i int64) bool { return i > 0 }
 	width, err := readInt64(reader, "Width (default: 1440)? ", positive, 1440)
-	if err != nil { return err }
+	if err != nil {
+		return err
+	}
 	height, err := readInt64(reader, "Height (default: 900)? ", positive, 900)
-	if err != nil { return err }
+	if err != nil {
+		return err
+	}
 	length, err := readInt64(reader, "Length in seconds (default: 10)? ", positive, 10)
-	if err != nil { return err }
+	if err != nil {
+		return err
+	}
 	number, err := readInt64(reader, "Number (default: 1)? ", positive, 1)
-	if err != nil { return err }
+	if err != nil {
+		return err
+	}
 	if option == 2 {
 		dir := fmt.Sprintf("autovideos%v", t)
 		err = os.MkdirAll(dir, 0700)
-        if err != nil { return err }
+		if err != nil {
+			return err
+		}
 		rand.Seed(t)
 		for i := int64(0); i < number; i++ {
 			err = autoart.GenerateVideo(int(width), int(height), conf,
-										float64(length), 24,
-										fmt.Sprintf("%v/%09d.mp4", dir, i), true)
-			if err != nil { return err }
+				float64(length), 24,
+				fmt.Sprintf("%v/%09d.mp4", dir, i), true)
+			if err != nil {
+				return err
+			}
 		}
-        fmt.Println("Done. Your videos are in this directory:", dir)
+		fmt.Println("Done. Your videos are in this directory:", dir)
 		return nil
 	}
 
-    framerate, err := readInt64(reader, "Frame rate (default: 24)? ", positive, 24)
+	framerate, err := readInt64(reader, "Frame rate (default: 24)? ", positive, 24)
 
-    var pconf autoart.PaletteConfig
+	var pconf autoart.PaletteConfig
 	paletted, err := readBool(reader, "Should a palette be used (y/n, default: n)? ", false)
-	if err != nil { return err }
-
+	if err != nil {
+		return err
+	}
 
-    // Advanced options
+	// Advanced options
 	if paletted {
 		err = readPaletteConf(reader, &pconf)
-		if err != nil { return err }
+		if err != nil {
+			return err
+		}
 	} else {
 		err = readConf(reader, &conf)
-		if err != nil { return err }
+		if err != nil {
+			return err
+		}
 	}
-	seed, err := readInt64(reader, "Random seed (default: current time)? ", func (i int64) bool {
-        return true
-    }, t)
+	seed, err := readInt64(reader, "Random seed (default: current time)? ", func(i int64) bool {
+		return true
+	}, t)
 
-    dir := fmt.Sprintf("autovideos%v", seed)
-    err = os.MkdirAll(dir, 0700)
-    if err != nil { return err }
-    rand.Seed(seed)
-    if paletted {
-        for i := int64(0); i < number; i++ {
-            err = autoart.GenerateVideoPalette(int(width), int(height), pconf,
-                float64(length), int(framerate),
-                fmt.Sprintf("%v/%09d.mp4", dir, i), true)
-            if err != nil { return err }
-        }
-    } else {
+	dir := fmt.Sprintf("autovideos%v", seed)
+	err = os.MkdirAll(dir, 0700)
+	if err != nil {
+		return err
+	}
+	rand.Seed(seed)
+	if paletted {
+		for i := int64(0); i < number; i++ {
+			err = autoart.GenerateVideoPalette(int(width), int(height), pconf,
+				float64(length), int(framerate),
+				fmt.Sprintf("%v/%09d.mp4", dir, i), true)
+			if err != nil {
+				return err
+			}
+		}
+	} else {
 		for i := int64(0); i < number; i++ {
 			err = autoart.GenerateVideo(int(width), int(height), conf,
 				float64(length), int(framerate),
 				fmt.Sprintf("%v/%09d.mp4", dir, i), true)
-			if err != nil { return err }
+			if err != nil {
+				return err
+			}
 		}
-    }
-    fmt.Println("Done. Your videos are in this directory:", dir)
-    return nil
+	}
+	fmt.Println("Done. Your videos are in this directory:", dir)
+	return nil
 
 }
diff --git a/io.go b/io.go
index dffae9d..aab5765 100644
--- a/io.go
+++ b/io.go
@@ -22,127 +22,145 @@ package main
 // Some functions for dealing with user input
 
 import (
-    "bufio"
-    "strconv"
-    "strings"
-    "fmt"
+	"bufio"
+	"fmt"
 	"github.com/pommicket/autoart/autoart"
+	"strconv"
+	"strings"
 )
 
-
 // Reads an int64 from a buffered reader, after giving the user the given prompt
 // If the number that the user entered does not satisfy valid, the user will
 // be prompted again. If the user enters nothing, the default will be used.
 func readInt64(reader *bufio.Reader, prompt string,
-               valid func (int64) bool, def int64) (int64, error) {
-    fmt.Print(prompt)
-    for {
-        line, err := reader.ReadString('\n')
-        if err != nil {
-            return 0, err
-        }
-        line = strings.TrimSpace(line)
-        if line == "" {
-            return def, nil
-        }
-        num, err := strconv.ParseInt(line, 0, 64)
-        if err != nil {
-            fmt.Println("Please enter a number.")
-            fmt.Print(prompt)
-            continue
-        }
-        if !valid(num) {
-            fmt.Println("Please enter a valid option.")
-            fmt.Print(prompt)
-            continue
-        }
-        return num, nil
-    }
+	valid func(int64) bool, def int64) (int64, error) {
+	fmt.Print(prompt)
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			return 0, err
+		}
+		line = strings.TrimSpace(line)
+		if line == "" {
+			return def, nil
+		}
+		num, err := strconv.ParseInt(line, 0, 64)
+		if err != nil {
+			fmt.Println("Please enter a number.")
+			fmt.Print(prompt)
+			continue
+		}
+		if !valid(num) {
+			fmt.Println("Please enter a valid option.")
+			fmt.Print(prompt)
+			continue
+		}
+		return num, nil
+	}
 }
 
 // Reads a bool from the reader, prompting the user until they enter y/n.
 func readBool(reader *bufio.Reader, prompt string, def bool) (bool, error) {
 	for {
-        fmt.Print(prompt)
-        line, err := reader.ReadString('\n')
-        if err != nil { return false, err }
-        line = strings.ToLower(strings.TrimSpace(line))
-        if line == "" {
-            return def, nil
-        }
-        switch line[0] {
-        case 'y':
-            return true, nil
-        case 'n':
-            return false, nil
-    	}
+		fmt.Print(prompt)
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			return false, err
+		}
+		line = strings.ToLower(strings.TrimSpace(line))
+		if line == "" {
+			return def, nil
+		}
+		switch line[0] {
+		case 'y':
+			return true, nil
+		case 'n':
+			return false, nil
+		}
 		fmt.Println("Please enter yes or no.")
-    }
+	}
 }
 
 // Reads an autoart.Config
 func readConf(reader *bufio.Reader, conf *autoart.Config) error {
-	positive := func (i int64) bool { return i > 0 }
+	positive := func(i int64) bool { return i > 0 }
 	functionLength, err := readInt64(reader, "Function length (default: 40)? ", positive, 40)
-    if err != nil { return err }
-    colorSpace, err := readInt64(reader, `Which color space should be used?
+	if err != nil {
+		return err
+	}
+	colorSpace, err := readInt64(reader, `Which color space should be used?
 1. RGB
 2. Grayscale
 3. CMYK
 4. HSV
 5. YCbCr
-Please enter a number between 1 and 5 (default: 1): `, func (i int64) bool {
-        return i >= 1 && i <= 5
-    }, 1)
-
-    if err != nil { return err }
-    alpha, err := readBool(reader, "Should an alpha channel be included (yes/no, default: no)? ", false)
-	if err != nil { return err }
+Please enter a number between 1 and 5 (default: 1): `, func(i int64) bool {
+		return i >= 1 && i <= 5
+	}, 1)
 
+	if err != nil {
+		return err
+	}
+	alpha, err := readBool(reader, "Should an alpha channel be included (yes/no, default: no)? ", false)
+	if err != nil {
+		return err
+	}
 
-    rectifier, err := readInt64(reader, `How should out of range values be dealt with?
+	rectifier, err := readInt64(reader, `How should out of range values be dealt with?
 1. Modulo
 2. Clamp
 3. Sigmoid
-Please enter 1, 2, or 3 (default: 1): `, func (i int64) bool {
-        return i >= 1 && i <= 3
-    }, 1)
-	if err != nil { return err }
-
-    coords, err := readInt64(reader, `Which coordinate system should be used?
+Please enter 1, 2, or 3 (default: 1): `, func(i int64) bool {
+		return i >= 1 && i <= 3
+	}, 1)
+	if err != nil {
+		return err
+	}
+
+	coords, err := readInt64(reader, `Which coordinate system should be used?
 1. x, y
 2. r, theta
-Please enter 1 or 2 (default: 1): `, func (i int64) bool {
-        return i >= 1 && i <= 2
-    }, 1)
-	if err != nil { return err }
+Please enter 1 or 2 (default: 1): `, func(i int64) bool {
+		return i >= 1 && i <= 2
+	}, 1)
+	if err != nil {
+		return err
+	}
 
 	conf.FunctionLength = int(functionLength)
 	conf.ColorSpace = int(colorSpace - 1)
 	conf.Alpha = alpha
 	conf.Rectifier = int(rectifier - 1)
-    conf.CoordinateSys = int(coords - 1)
+	conf.CoordinateSys = int(coords - 1)
 	return nil
 }
 
 func readPaletteConf(reader *bufio.Reader, conf *autoart.PaletteConfig) error {
-	positive := func (i int64) bool { return i > 0 }
+	positive := func(i int64) bool { return i > 0 }
 	ncolors, err := readInt64(reader, "How many colors do you want (default: 10)? ", positive, 10)
-	if err != nil { return err }
+	if err != nil {
+		return err
+	}
 	alpha, err := readBool(reader, "Should an alpha channel be included (yes/no, default: no)? ", false)
-	if err != nil { return err }
+	if err != nil {
+		return err
+	}
 	functionLength, err := readInt64(reader, "Function length (default: 40)? ", positive, 40)
-	if err != nil { return err }
-    coords, err := readInt64(reader, `Which coordinate system should be used?
+	if err != nil {
+		return err
+	}
+	coords, err := readInt64(reader, `Which coordinate system should be used?
 1. x, y
 2. r, theta
-Please enter 1 or 2 (default: 1): `, func (i int64) bool {
-        return i >= 1 && i <= 2
-    }, 1)
-	if err != nil { return err }
+Please enter 1 or 2 (default: 1): `, func(i int64) bool {
+		return i >= 1 && i <= 2
+	}, 1)
+	if err != nil {
+		return err
+	}
 	conf.NColors = int(ncolors)
 	conf.Alpha = alpha
 	conf.FunctionLength = int(functionLength)
-    conf.CoordinateSys = int(coords - 1)
+	conf.CoordinateSys = int(coords - 1)
 	return nil
 }
diff --git a/main.go b/main.go
index 7f2f131..3f280c6 100644
--- a/main.go
+++ b/main.go
@@ -20,37 +20,37 @@ along with AutoArt.  If not, see <https://www.gnu.org/licenses/>.
 package main
 
 import (
-    "fmt"
-    "os"
-    "bufio"
+	"bufio"
+	"fmt"
+	"os"
 )
 
 func main() {
-    reader := bufio.NewReader(os.Stdin)
-    prompt := `Please select one of the following:
+	reader := bufio.NewReader(os.Stdin)
+	prompt := `Please select one of the following:
 1. AutoImages
 2. AutoVideos
 3. AutoAudio
 Please enter 1, 2, or 3 (default: 1): `
 
-    option, err := readInt64(reader, prompt, func (i int64) bool {
-        return i >= 1 && i <= 3
-    }, 1)
-    if err != nil {
-        fmt.Println("Error reading user input:", err)
-    }
+	option, err := readInt64(reader, prompt, func(i int64) bool {
+		return i >= 1 && i <= 3
+	}, 1)
+	if err != nil {
+		fmt.Println("Error reading user input:", err)
+	}
 
-    switch option {
+	switch option {
 	case 1:
-	    err = autoImages(reader)
+		err = autoImages(reader)
 	case 2:
 		err = autoVideos(reader)
-    case 3:
-        err = autoAudio(reader)
-    }
+	case 3:
+		err = autoAudio(reader)
+	}
 
-    if err != nil {
-        fmt.Println("An error occured:", err)
-    }
+	if err != nil {
+		fmt.Println("An error occured:", err)
+	}
 
 }