func CollyAddress(target string, savePage bool, ip bool) {
	if ip {  
		target = "http://" + target + "/"  
	}
	c := colly.NewCollector()  
	c.IgnoreRobotsTxt = true   
	c.OnRequest(func(r *colly.Request) {
		fmt.Println("Visiting", r.URL)
	})
	c.OnError(func(_ *colly.Response, err error) {  
		ct.Foreground(ct.Red, true)  
		log.Println("Something went wrong:", err)
		ct.ResetColor()  
	})
	c.OnResponse(func(r *colly.Response) {
		fmt.Println("Visited", r.Request.URL)
		fmt.Println("Response:", r.StatusCode)
	})
	c.OnScraped(func(r *colly.Response) {  
		fmt.Println("Finished", r.Request.URL)
		if savePage {  
			err := r.Save(r.FileName())  
			CheckErr(err)
			ct.Foreground(ct.Green, true)  
			fmt.Println("Saved - ", r.FileName())
			ct.ResetColor()  
		}
	})
	c.Visit(target)  
}
CollyAddress - scrapes a website link
package utils
import (
	"bytes"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"math"
	"math/rand"
	"net/http"
	"os"
	"os/exec"
	"os/user"
	"strings"
	"syscall"
	"time"
	ct "github.com/daviddengcn/go-colortext"
	"github.com/gocolly/colly"
	"github.com/shirou/gopsutil/cpu"
	"github.com/shirou/gopsutil/host"
	"github.com/shirou/gopsutil/load"
	"github.com/shirou/gopsutil/mem"
	"golang.org/x/crypto/ssh/terminal"
)
func BytesToGigabytes(bytes uint64) float64 {
	const conversionFactor = 1000000000
	result := float64(bytes) / conversionFactor
	result = float64(math.Round(result*100) / 100)
	return result
}
func CheckTarget(target string) {
	if target == "" {  
		CheckErr(fmt.Errorf("target cannot be empty when performing this task"))
	}
}
func CheckErr(err error) {
	if err != nil {  
		ct.Foreground(ct.Red, true)  
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}
func CheckSudo() {
	user, _ := user.Current()
	if !strings.Contains(user.Username, "root") {
		CheckErr(fmt.Errorf("cannot run this task without root/sudo"))
	}
}
func RunCmd(command string, arg ...string) string {
	cmd := exec.Command(command)
	for _, arg := range arg {
		cmd.Args = append(cmd.Args, arg)
	}
	var o bytes.Buffer
	cmd.Stdout = &o  
	err := cmd.Run()
	CheckErr(err)
	return o.String()
}
func ReadFileIntoByte(filename string) []byte {
	var data []byte                 
	file, err := os.Open(filename)  
	defer file.Close()              
	CheckErr(err)
	data, err = ioutil.ReadAll(file)  
	if err != nil {
		ct.Foreground(ct.Red, true)  
		panic(err.Error())
	}
	return data  
}
func GetPassword() string {
	bytePassword, err := terminal.ReadPassword(int(syscall.Stdin))  
	CheckErr(err)
	password := string(bytePassword)  
	return password
}
func RandomColor() ct.Color {
	rand.Seed(time.Now().UTC().UnixNano())
	switch randInt(0, 5) {
	case 0:
		ct.Foreground(ct.Blue, true)
		return ct.Blue
	case 1:
		ct.Foreground(ct.Red, true)
		return ct.Red
	case 2:
		ct.Foreground(ct.Yellow, true)
		return ct.Yellow
	case 3:
		ct.Foreground(ct.Magenta, true)
		return ct.Magenta
	case 4:
		ct.Foreground(ct.Green, true)
		return ct.Green
	}
	return ct.White
}
func randInt(min int, max int) int {
	return min + rand.Intn(max-min)
}
func DownloadFile(filepath string, url string) error {
	out, err := os.Create(filepath)
	if err != nil {
		return err
	}
	defer out.Close()
	resp, err := http.Get(url)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	_, err = io.Copy(out, resp.Body)
	if err != nil {
		return err
	}
	return nil
}
func PrintBanner() {
	RandomColor()
	fmt.Println(`
 __  __       _ _   _    ____
|  \/  |_   _| | |_(_)  / ___| ___
| |\/| | | | | | __| | | |  _ / _ \
| |  | | |_| | | |_| | | |_| | (_) |
|_|  |_|\__,_|_|\__|_|  \____|\___/`)
}