func start(ctx *cli.Context) {
	if ctx.Bool("profile") {
		defer profile.Start(profile.CPUProfile).Stop()
		defer profile.Start(profile.MemProfile).Stop()
		defer profile.Start(profile.BlockProfile).Stop()
		defer profile.Start(profile.ProfilePath("."))
	}
	quit := make(chan bool)
	initLogrus(ctx)
	log.Info("Starting fullerite...")

	c, err := config.ReadConfig(ctx.String("config"))
	if err != nil {
		return
	}
	handlers := createHandlers(c)
	hook := NewLogErrorHook(handlers)
	log.Logger.Hooks.Add(hook)

	startHandlers(handlers)
	collectors := startCollectors(c)

	collectorStatChan := make(chan metric.CollectorEmission)

	internalServer := internalserver.New(c,
		handlerStatFunc(handlers),
		readCollectorStat(collectorStatChan))

	go internalServer.Run()

	readFromCollectors(collectors, handlers, collectorStatChan)

	<-quit
}

// Main starts mc application
func Main() {
	// Enable profiling supported modes are [cpu, mem, block].
	// ``MC_PROFILER`` supported options are [cpu, mem, block].
	switch os.Getenv("MC_PROFILER") {
	case "cpu":
		defer profile.Start(profile.CPUProfile, profile.ProfilePath(mustGetProfileDir())).Stop()
	case "mem":
		defer profile.Start(profile.MemProfile, profile.ProfilePath(mustGetProfileDir())).Stop()
	case "block":
		defer profile.Start(profile.BlockProfile, profile.ProfilePath(mustGetProfileDir())).Stop()
	}

	probe.Init() // Set project's root source path.
	probe.SetAppInfo("Release-Tag", ReleaseTag)
	probe.SetAppInfo("Commit", ShortCommitID)

	app := registerApp()
	app.Before = registerBefore
	app.ExtraInfo = func() map[string]string {
		if _, e := pb.GetTerminalWidth(); e != nil {
			globalQuiet = true
		}
		if globalDebug {
			return getSystemData()
		}
		return make(map[string]string)
	}
	app.RunAndExitOnError()
}

func (p PkgProfile) Start() ProfilerStart {
	if *FLAGS.PROFILE_MEM {
		PROFILE = profile.Start(profile.MemProfile, profile.ProfilePath("."))
	} else {
		PROFILE = profile.Start(profile.CPUProfile, profile.ProfilePath("."))
	}
	return PROFILE
}

func main() {
	args.Bind = ":53"
	argParser := arg.MustParse(&args)

	// Enable profiling
	switch args.Profile {
	case "cpu":
		defer profile.Start(profile.CPUProfile).Stop()
	case "mem":
		defer profile.Start(profile.MemProfile).Stop()
	case "block":
		defer profile.Start(profile.BlockProfile).Stop()
	}

	// Control number of workers via GOMAXPROCS
	if args.Workers > 0 {
		runtime.GOMAXPROCS(args.Workers)
	}

	if len(args.Zones) == 0 {
		log.Println("must supply at least 1 zone file to serve")
		argParser.WriteUsage(os.Stderr)
		os.Exit(1)
	}

	var registry *realm.Registry
	registry = realm.NewRegistry()

	for _, filename := range args.Zones {
		// Load and parse the zone file
		var zone *realm.Zone
		var err error
		log.Printf("parsing zone file \"%s\"\n", filename)
		zone, err = realm.ParseZone(filename)
		if err != nil {
			log.Fatal(err)
		}
		registry.AddZone(zone)
	}

	// Create and start the server
	log.Printf("starting the server on \"%s\"\n", args.Bind)
	var server *realm.Server
	var err error
	server, err = realm.NewServer(args.Bind, registry, args.StatsD)
	if err != nil {
		log.Fatal(err)
	}

	log.Fatal(server.ListenAndServe())
}

func Profile(mode string) Stop {
	var stop Stop
	switch mode {
	case "mem":
		stop = profileOnExit(profile.Start(profile.MemProfile, profile.ProfilePath("."), profile.NoShutdownHook))
	case "cpu":
		stop = profileOnExit(profile.Start(profile.CPUProfile, profile.ProfilePath("."), profile.NoShutdownHook))
	case "block":
		stop = profileOnExit(profile.Start(profile.BlockProfile, profile.ProfilePath("."), profile.NoShutdownHook))
	default:
		stop = stopper{}
	}
	return stop
}

func activateProfiline(profileType string, dir string) {
	// activating
	switch profileType {
	case "cpu":
		defer profile.Start(profile.ProfilePath(dir), profile.CPUProfile).Stop()
	case "mem":
		defer profile.Start(profile.ProfilePath(dir), profile.MemProfile).Stop()
	case "block":
		defer profile.Start(profile.ProfilePath(dir), profile.BlockProfile).Stop()
	default:
		// do nothing
	}

}

// Starts a profiler returns nil if profiler is not enabled, caller needs to handle this.
func startProfiler(profiler string) interface {
	Stop()
} {
	// Enable profiler if ``_MINIO_PROFILER`` is set. Supported options are [cpu, mem, block].
	switch profiler {
	case "cpu":
		return profile.Start(profile.CPUProfile, profile.NoShutdownHook)
	case "mem":
		return profile.Start(profile.MemProfile, profile.NoShutdownHook)
	case "block":
		return profile.Start(profile.BlockProfile, profile.NoShutdownHook)
	default:
		return nil
	}
}

func ExampleStart_withFlags() {
	// use the flags package to selectively enable profiling.
	mode := flag.String("profile.mode", "", "enable profiling mode, one of [cpu, mem, block]")
	flag.Parse()
	switch *mode {
	case "cpu":
		defer profile.Start(profile.CPUProfile).Stop()
	case "mem":
		defer profile.Start(profile.MemProfile).Stop()
	case "block":
		defer profile.Start(profile.BlockProfile).Stop()
	default:
		// do nothing
	}
}

func main() {
	flag.Parse()
	if *clients > *num {
		log.Println("# of clients can't be greater than # of keys written")
		return
	}
	runtime.GOMAXPROCS(*procs)
	if *profileEnable {
		defer profile.Start().Stop()
	}
	s := NewScrambled()
	value = make([]byte, *vsize)
	s.Read(value)
	perClient = *num / *clients
	perGroup := perClient / *groups
	if perGroup == 0 {
		log.Printf("Can't split %d writes across %d groups", perClient, *groups)
		log.Println("Need -num to be at least:", *clients**groups)
		return
	}

	log.Println("Using streaming api:", *streamTest)

	if *vsWriteTest || *vsReadTest {
		VSTests()
	}
	if *gsWriteTest || *gsReadTest {
		GSTests()
	}
	return
}

func main() {
	r := rand.New(rand.NewSource(4))

	players := make([]*player, numPlayers)
	m := make(map[int]map[*player]bool)
	m[0] = make(map[*player]bool)
	for i := range players {
		players[i] = &player{
			skill: r.NormFloat64() * skillStdDev,
		}
		m[0][players[i]] = true
	}

	a := arena{
		r:              r,
		allPlayers:     players,
		playersByStars: m,
	}
	defer profile.Start().Stop()
	for i := 0; i < numPlayers*avgNumGamesPerPlayer; i++ {

		a.fight()
	}
	a.print()
}

func main() {

	thrust.InitLogger()
	// Set any Custom Provisioners before Start
	thrust.SetProvisioner(provisioner.NewSingleBinaryThrustProvisioner())
	// thrust.Start() must always come before any bindings are created.
	thrust.Start()

	thrustWindow := thrust.NewWindow(thrust.WindowOptions{
		RootUrl:  "http://breach.cc/",
		HasFrame: true,
	})
	thrustWindow.Show()
	thrustWindow.Focus()

	// Lets do a window timeout
	go func() {
		// <-time.After(time.Second * 5)
		// thrustWindow.Close()
		// thrust.Exit()
	}()

	// In lieu of something like an http server, we need to lock this thread
	// in order to keep it open, and keep the process running.
	// Dont worry we use runtime.Gosched :)
	defer profile.Start().Stop()
	thrust.LockThread()
}

func main() {
	p := profile.Start(profile.MemProfile, profile.ProfilePath("."), profile.NoShutdownHook)
	// initialize representation
	index, _ = iindex.IndexDirectory("/home/rhibbitts/Dropbox/Notes/WorkNotes")
	// run  user interface
	ui()
	p.Stop()
}

// Main is the entry-point of the guble server.
func Main() {
	defer func() {
		if p := recover(); p != nil {
			logger.Fatal("Fatal error in gubled after recover")
		}
	}()

	parseConfig()

	log.SetFormatter(&logformatter.LogstashFormatter{Env: *Config.EnvName})
	level, err := log.ParseLevel(*Config.Log)
	if err != nil {
		logger.WithError(err).Fatal("Invalid log level")
	}
	log.SetLevel(level)

	switch *Config.Profile {
	case cpuProfile:
		logger.Info("starting to profile cpu")
		defer profile.Start(profile.CPUProfile).Stop()
	case memProfile:
		logger.Info("starting to profile memory")
		defer profile.Start(profile.MemProfile).Stop()
	case blockProfile:
		logger.Info("starting to profile blocking/contention")
		defer profile.Start(profile.BlockProfile).Stop()
	default:
		logger.Debug("no profiling was started")
	}

	if err := ValidateStoragePath(); err != nil {
		logger.Fatal("Fatal error in gubled in validation of storage path")
	}

	srv := StartService()
	if srv == nil {
		logger.Fatal("exiting because of unrecoverable error(s) when starting the service")
	}

	waitForTermination(func() {
		err := srv.Stop()
		if err != nil {
			logger.WithField("error", err.Error()).Error("errors occurred while stopping service")
		}
	})
}

// Starts a profiler returns nil if profiler is not enabled, caller needs to handle this.
func startProfiler(profiler string) interface {
	Stop()
} {
	// Set ``MINIO_PROFILE_DIR`` to the directory where profiling information should be persisted
	profileDir := os.Getenv("MINIO_PROFILE_DIR")
	// Enable profiler if ``MINIO_PROFILER`` is set. Supported options are [cpu, mem, block].
	switch profiler {
	case "cpu":
		return profile.Start(profile.CPUProfile, profile.NoShutdownHook, profile.ProfilePath(profileDir))
	case "mem":
		return profile.Start(profile.MemProfile, profile.NoShutdownHook, profile.ProfilePath(profileDir))
	case "block":
		return profile.Start(profile.BlockProfile, profile.NoShutdownHook, profile.ProfilePath(profileDir))
	default:
		return nil
	}
}

func main() {
	p := profile.Start(
		profile.MemProfile,
		profile.ProfilePath("."))
	defer p.Stop()

	q := queue.NewDeque()
	fill(q)
	clear(q)
}

func main() {
	//prof := profile.CPUProfile
	prof := profile.MemProfile
	defer profile.Start(prof, profile.ProfilePath(".")).Stop()

	t := bpt.NewTree()
	for i := 0; i < 1000000; i++ {
		x := []byte(fmt.Sprintf("%x", i))
		t.Set(x, x)
	}
	t.Close()
}

func main() {
	prof := profile.CPUProfile
	//prof := profile.MemProfile
	defer profile.Start(prof, profile.ProfilePath(".")).Stop()

	t := bptx.NewTree()
	for i := 0; i < 10000; i++ {
		x := bptx.UUID()
		t.Set(x, x)
	}
	t.Close()
}

func main() {
	flag.Parse()

	input := flag.Arg(0)
	output := flag.Arg(1)
	cwd, _ := os.Getwd()
	defer profile.Start(profile.ProfilePath(cwd)).Stop()

	m, _ := mapping.NewMap(input)

	r := rendering.NewRenderer(m, 5000, 5000)

	r.ClipToMap()
	r.DrawToFile(output)
}

func main() {
	p := profile.Start(
		profile.MemProfile,
		profile.ProfilePath("."),
		profile.NoShutdownHook)
	defer p.Stop()

	u := &command.Unit{"Test-01", 0, 0}
	s := command.NewCommandStack(10)
	s.Do(command.NewMoveUnitCommand(u, 10, 10))

	for i := 0; i < 10000000; i++ {
		s.Do(command.NewMoveUnitCommand(u, i*10, i*10))
	}
}

func main() {
	config.InitConfig()

	if config.EnableProfile {
		defer profile.Start(profile.CPUProfile).Stop()
	}

	runtime.GOMAXPROCS(runtime.NumCPU() * 3)
	utils.InitLogger()
	if config.RC.MySQLEnabled {
		query.RC_MySQLConf = config.RC.MySQLConf
		query.InitMySQL(query.RC_MySQLConf)
	}
	server.NewServer()

}