func main() {
	defer profile.Start(&profile.Config{CPUProfile: true, ProfilePath: "/tmp/"}).Stop()

	//	nCPU := runtime.NumCPU()
	nCPU := 2
	runtime.GOMAXPROCS(nCPU)
	log.Printf("running on %d CPUs", nCPU)

	server := network.NewServer("8081")
	server.Start()

	world = NewWorld(entityManager, server)

	go world.worldTick()
	go world.networkTick()

	// wait for signal
	signalChan := make(chan os.Signal, 1)
	cleanupDone := make(chan bool)
	signal.Notify(signalChan, os.Interrupt)
	go func() {
		for _ = range signalChan {
			log.Printf("Received an interrupt, stopping services...\n")
			server.Stop()
			cleanupDone <- true
		}
	}()
	<-cleanupDone
}

func main() {
	password := flag.String("password", "", "Password for all redis instances")
	db := flag.Int("db", 0, "DB number")
	socket := flag.String("socket", "/tmp/redis-monitor.sock", "Socket to provide metrics over")
	flag.Parse()
	if len(flag.Args()) < 1 {
		flag.Usage()
		os.Exit(1)
	}
	s := &http.Server{
		Handler: &Addresses{
			Addr:     flag.Args(),
			Password: *password,
			DB:       int64(*db),
		},
	}

	l, err := util.CreateSocket(*socket)

	go func() {
		log.Println(http.ListenAndServe("localhost:6060", nil))
	}()

	defer profile.Start(profile.MemProfile).Stop()

	if err != nil {
		panic(err)
	}

	if err := s.Serve(l); err != nil {
		panic(err)
	}
}

func start(ctx *cli.Context) {
	if ctx.Bool("profile") {
		pcfg := profile.Config{
			CPUProfile:   true,
			MemProfile:   true,
			BlockProfile: true,
			ProfilePath:  ".",
		}
		p := profile.Start(&pcfg)
		defer p.Stop()
	}
	initLogrus(ctx)
	log.Info("Starting fullerite...")

	c, err := config.ReadConfig(ctx.String("config"))
	if err != nil {
		return
	}
	collectors := startCollectors(c)
	handlers := startHandlers(c)
	metrics := make(chan metric.Metric)
	readFromCollectors(collectors, metrics)
	for metric := range metrics {
		// Writing to handlers' channels. Sending metrics is
		// handled asynchronously in handlers' Run functions.
		writeToHandlers(handlers, metric)
	}
}

func main() {
	cfg := profile.Config{
		MemProfile:     true,
		CPUProfile:     true,
		BlockProfile:   true,
		ProfilePath:    ".",
		NoShutdownHook: true,
	}

	defer profile.Start(&cfg).Stop()
	c := make(chan int)
	go func() {
		//http.ListenAndServe("0.0.0.0:6060", nil)
	}()
	//<-c
	for i := 0; i < 1000; i++ {
		go func(i int) {
			//fmt.Println(test())
			test()
			c <- i
		}(i)
	}
	//<-c //for http
	for i := 0; i < 1000; i++ {
		<-c
	}

	//println(http.ListenAndServe("localhost:6062", nil))
}

func main() {
	defer profile.Start(profile.CPUProfile).Stop()
	flag.Parse()
	dm := docmap.NewDocMap()
	err := dm.DocReader()

	if err != nil {
		println(err)
		return
	}
	qm := querrymap.NewQuerryMap()

	qm.QuerryReader()

	im := invertmap.NewInvertMap()

	err = im.DocMToInM(dm)

	if err != nil {
		println(err)
	}

	if *startQuerry {
		qproc.QuerriesProc(dm, qm, im)
	} else {
		println("No webservice")
	}

}

func main() {
	// Set up a done channel, that's shared by the whole pipeline.
	// Closing this channel will kill all pipeline goroutines
	//done := make(chan struct{})
	//defer close(done)

	// Set up logging
	initializeLogging()

	// Flush the log before we shutdown
	defer log.Flush()

	// Parse the command line flags
	config := parseCommandLineFlags()
	gamq.SetConfig(&config)

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

	log.Infof("Broker started on port: %d", gamq.Configuration.Port)
	log.Infof("Executing on: %d threads", runtime.GOMAXPROCS(-1))

	connectionManager := gamq.NewConnectionManager()
	connectionManager.Start()
}

func TestPerft(t *testing.T) {
	t.SkipNow()
	cfg := profile.Config{
		CPUProfile:     false,
		MemProfile:     false,
		ProfilePath:    ".",  // store profiles in current directory
		NoShutdownHook: true, // do not hook SIGINT
	}
	p := profile.Start(&cfg)
	//t.SkipNow()
	loadPerft(t)

	for _, depth := range depths {
		setupBoard()
		res := perft(depth, t, g)
		excepted := sharperPerftLookup(depth, t)
		if res == excepted {
			t.Log("okPerft("+strconv.Itoa(depth)+") Result:", res, " Expected:", excepted)
		} else {
			t.Log("X Perft("+strconv.Itoa(depth)+") Result:", res, " Expected:", excepted)
			t.Fail()
		}
	}
	p.Stop()
}

func start(ctx *cli.Context) {
	if ctx.Bool("profile") {
		pcfg := profile.Config{
			CPUProfile:   true,
			MemProfile:   true,
			BlockProfile: true,
			ProfilePath:  ".",
		}
		p := profile.Start(&pcfg)
		defer p.Stop()
	}
	initLogrus(ctx)
	log.Info("Starting fullerite...")

	c, err := config.ReadConfig(ctx.String("config"))
	if err != nil {
		return
	}
	collectors := startCollectors(c)
	handlers := startHandlers(c)

	internalServer := internalserver.New(c, &handlers)
	go internalServer.Run()

	metrics := make(chan metric.Metric)
	readFromCollectors(collectors, metrics)

	hook := NewLogErrorHook(metrics)
	log.Logger.Hooks.Add(hook)

	relayMetricsToHandlers(handlers, metrics)
}

func main() {
	port := flag.Int("port", 8080, "port")
	backends := flag.Int("workers", 3, "number of workers")
	strategy := flag.String("strategy", "majority", "balancing strategy ['one', 'two', 'majority', 'all']")
	flag.Parse()

	cfg := profile.Config{
		CPUProfile:  true,
		MemProfile:  true,
		ProfilePath: ".",
	}
	p := profile.Start(&cfg)
	defer p.Stop()

	balancer := newBalancer(backends, strategy)

	a := gin.Default()
	a.GET("/", func(c *gin.Context) {
		timeouted := make(chan bool)
		result := processFirstResponse(timeouted, balancer)

		select {
		case data := <-result:
			c.JSON(200, data)
		case <-time.After(globalTimeout):
			c.JSON(500, nil)
			timeouted <- true
		}

	})
	a.Run(fmt.Sprintf(":%d", *port))

}

func main() {

	/* # # # # #  ENABLING PROFILING # # # # # */
	defer profile.Start(profile.CPUProfile).Stop()
	/*
		profileConfig := profile.Config{
			CPUProfile:     true,
			MemProfile:     true,
			ProfilePath:    ".",  // store profiles in current directory
			NoShutdownHook: true, // do not hook SIGINT
		}
		p := profile.Start(&profileConfig)
		defer p.Stop()
	*/
	/* # # # # #  ENABLING PROFILING # # # # # */

	ts.Cache("index.html", "home.html", "404.html")

	mux := MuxInstance()
	mux.Handle("GET", "/index", index)
	mux.Handle("GET", "/home", home)
	mux.Handle("GET", "/404", err404)
	mux.Handle("GET", "/user", user)
	mux.Handle("GET", "/user/add", userAdd)
	mux.Handle("GET", "/user/:id", userId)
	mux.Handle("GET", "/:slug", landing)
	mux.Handle("GET", "/login/:slug", multiLogin)
	mux.Handle("GET", "/logout/:slug", logout)
	mux.Handle("GET", "/protected/:slug", protected)

	http.ListenAndServe(":8080", mux)
}

func main() {
	address := flag.String("s", "127.0.0.1", "Bind Address")
	port := flag.String("p", "11211", "Bind Port")
	filename := flag.String("f", "./memcached.db", "path and file for database")
	pf := flag.Bool("q", false, "Enable profiling")

	flag.Usage = func() {
		fmt.Println("Usage: beano [-s ip] [-p port] [-f /path/to/db/file -q]")
		fmt.Println("default ip: 127.0.0.1")
		fmt.Println("default port: 11211")
		fmt.Println("default file: ./memcached.db")
		fmt.Println("-q enables profiling to /tmp/*.prof")
		os.Exit(1)
	}
	flag.Parse()
	if *pf == true {
		c := profile.Config{BlockProfile: true, CPUProfile: true, ProfilePath: "/tmp", MemProfile: true, Quiet: false}
		defer profile.Start(&c).Stop()
	}
	var cpuinfo string
	if n := runtime.NumCPU(); n > 1 {
		runtime.GOMAXPROCS(n)
		cpuinfo = fmt.Sprintf("%d CPUs", n)
	} else {
		cpuinfo = "1 CPU"
	}

	log.Info("beano (%s)", cpuinfo)

	initializeMetrics(*filename)

	serve(*address, *port, *filename)

}

func main() {

	fmt.Println("Server Starting on port:8080")
	defer profile.Start(profile.CPUProfile).Stop()
	pc := controller.NewProjectController(getDbSession())
	uc := controller.NewUserController(getDbSession())
	sc := controller.NewSensorController(getDbSession())
	vc := controller.NewVirtSensorController(getDbSession())

	router := httprouter.New()

	//Project Management Routings
	router.Handle("GET", "/projects", pc.Project)
	router.Handle("POST", "/addproject", pc.AddProject)
	router.Handle("GET", "/projects/:projectName/selectsensors", pc.SelectSensors)
	router.Handle("POST", "/projects/:projectName/addvirtualsensors", pc.AddSensorToProject)
	router.Handle("GET", "/projects/:projectName/dashboard", pc.Dashboard)
	router.Handle("GET", "/projects/:projectName/terminate", pc.TerminateProject)
	/*router.Handle("GET", "/sendvirtualsensordetails/", handle)
	router.Handle("POST", "/projects/:projectName/addvirtualsensors", handle)
	router.Handle("GET", "/projects/:projectName/startvirtsensor/:vsensorid", handle)
	router.Handle("GET", "/projects/:projectName/stopvirtsensor/:vsensorid", handle)
	router.Handle("GET", "/projects/:projectName/terminatevirtsensor/:vsensorid", handle)*/

	// User Management Routings
	router.Handle("GET", "/", uc.Index)
	router.Handle("GET", "/logout", uc.Logout)
	router.Handle("POST", "/users/login", uc.Login)
	router.Handle("POST", "/users/signup", uc.Signup)
	router.Handle("PUT", "/users/updateuser/:username", uc.UpdateUser)
	router.Handle("DELETE", "/users/deleteuser/:username", uc.DeleteUser)
	router.Handle("GET", "/time", uc.Datahandler)
	router.Handle("GET", "/gettime", uc.HandlerGetData)

	//Physical Sensor Management Routings
	router.Handle("POST", "/sensors", sc.AddSensor)
	router.Handle("PUT", "/sensors/updatesensor/:sensorName", sc.UpdateSensor)
	router.Handle("DELETE", "/sensors/deletesensor/:sensorName", sc.DeleteSensor)
	router.Handle("GET", "/sensors/getsensor/:sensorName", sc.GetSensorByName)
	router.Handle("POST", "/authenticatesenor", sc.AuthenticateSensor)
	router.Handle("GET", "/getsensorbyowner/:ownerId", sc.GetSensorByOwner)
	router.Handle("GET", "/getallsharedsensors", sc.GetAllSharedSensors)
	//router.Handle("POST", "/getsensordata",sc.GetSensorData)
	//router.Handle("PUT", "/sensors/togglesensor/:sensorName", ToggelSensor)
	/*router.Handle("GET", "/getsensorbyowner/:ownerId", GetSensorById)*/

	// Virtual Sensor Management Routings
	router.Handle("POST", "/virtsensors", vc.AddVirtSensor)
	router.Handle("PUT", "/removevirtsensors/:vSensorName", vc.RemoveVirtSensor)
	router.Handle("GET", "/stopvirtsensors/:vSensorName", vc.StopVirtSensor)
	router.Handle("GET", "/resumevirtsensors/:vSensorName", vc.ResumeVirtSensor)
	router.Handle(("GET"), "/projects/:projectName/sensors/:vSensorName", vc.GetVSensorDetails)

	//fileServer := http.StripPrefix("/static/", http.FileServer(http.Dir("static")))
	router.NotFound = http.StripPrefix("/static/", http.FileServer(http.Dir("static")))
	log.Fatal(http.ListenAndServe(":8081", router))
}

func main() {
	profileKind := os.Args[1]
	switch profileKind {
	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:
		fmt.Println("only cpu, mem and block are valid profile arguments")
		return
	}

	for i := 0; i < 1000000; i++ {
		user := &User{
			Name: "Emil Sjölander",
			Repos: []Repo{
				Repo{
					Name:  "goson",
					URL:   "https://github.com/emilsjolander/goson",
					Stars: 0,
					Forks: 0,
				},
				Repo{
					Name:  "StickyListHeaders",
					URL:   "https://github.com/emilsjolander/StickyListHeaders",
					Stars: 722,
					Forks: 197,
				},
				Repo{
					Name:  "android-FlipView",
					URL:   "https://github.com/emilsjolander/android-FlipView",
					Stars: 157,
					Forks: 47,
				},
			},
		}

		goson.Render("user", goson.Args{"User": user})
	}
}

func main() {
	defer profile.Start(profile.CPUProfile).Stop()

	flag.Parse()
	for _, path := range flag.Args() {
		err := flac2wav(path)
		if err != nil {
			log.Fatalln(err)
		}
	}
}

func initProfiler() {
	cfg := profile.Config{
		MemProfile:  true,
		CPUProfile:  true,
		ProfilePath: ".", // store profiles in current directory
	}

	// p.Stop() must be called before the program exits to
	// ensure profiling information is written to disk.
	profiler = profile.Start(&cfg)
}

func main() {
	defer profile.Start(profile.CPUProfile).Stop()

	if cmdTarget == "" {
		flag.PrintDefaults()
		return
	}

	s, err := gosnmp.NewGoSNMP(cmdTarget, cmdCommunity, gosnmp.Version2c, cmdTimeout)
	s.SetVerbose(true)
	if err != nil {
		fmt.Printf("UNKNOWN: Error creating SNMP instance: %s\n", err.Error())
		os.Exit(utils.UNKNOWN)
	}

	const totalSwapOid string = ".1.3.6.1.4.1.2021.4.3.0"
	const availSwapOid string = ".1.3.6.1.4.1.2021.4.4.0"

	resp, err := s.Get(totalSwapOid)
	if err != nil {
		fmt.Printf("UNKNOWN: Error getting response: %s\n", err.Error())
		os.Exit(utils.UNKNOWN)
	} else {
		totalSwap = resp.Variables[0].Value.(int)
		fmt.Printf("total swap [%d]\n", totalSwap)
	}

	availResp, err := s.Get(availSwapOid)
	if err != nil {
		fmt.Printf("UNKNOWN: Error getting response: %s\n", err.Error())
		os.Exit(utils.UNKNOWN)
	} else {
		availSwap = availResp.Variables[0].Value.(int)
		fmt.Printf("availSwap [%d]\n", availSwap)
	}

	if availSwap != totalSwap {

		usedSwap = int(100 - int(100*float64(float64(availSwap)/float64(totalSwap))))
		fmt.Printf("Used swap = %d\n", usedSwap)

		if usedSwap >= swapLimit {

			fmt.Printf("CRITICAL - SWAP Available [%d] Total [%d] In Use [%d%%]", availSwap, totalSwap, usedSwap)
			os.Exit(utils.CRITICAL)
		}

	}

	fmt.Printf("OK - SWAP Available [%d] Total [%d] In Use [%d%%]", availSwap, totalSwap, usedSwap)
	os.Exit(utils.OK)

}

func main() {

	defer profile.Start(profile.CPUProfile).Stop()

	c := make(chan int, 1)

	c <- 1
	fmt.Println(<-c)
	c <- 2
	fmt.Println(<-c)

}

func main() {

	runtime.GOMAXPROCS(runtime.NumCPU() - 2)

	gopath := os.Getenv("GOPATH")
	path := filepath.Join(gopath, "prof", "github.com", "reggo", "reggo", "nnet")

	nInputs := 10
	nOutputs := 3
	nLayers := 2
	nNeurons := 50
	nSamples := 1000000
	nRuns := 50

	config := &profile.Config{
		CPUProfile:  true,
		ProfilePath: path,
	}

	defer profile.Start(config).Stop()

	net, err := nnet.NewSimpleTrainer(nInputs, nOutputs, nLayers, nNeurons, nnet.Linear{})
	if err != nil {
		log.Fatal(err)
	}

	// Generate some random data
	inputs := mat64.NewDense(nSamples, nInputs, nil)
	outputs := mat64.NewDense(nSamples, nOutputs, nil)
	for i := 0; i < nSamples; i++ {
		for j := 0; j < nInputs; j++ {
			inputs.Set(i, j, rand.Float64())
		}
		for j := 0; j < nOutputs; j++ {
			outputs.Set(i, j, rand.Float64())
		}
	}

	// Create trainer
	prob := train.NewBatchGradBased(net, true, inputs, outputs, nil, nil, nil)
	nParameters := net.NumParameters()

	parameters := make([]float64, nParameters)
	derivative := make([]float64, nParameters)

	for i := 0; i < nRuns; i++ {
		net.RandomizeParameters()
		net.Parameters(parameters)
		prob.ObjGrad(parameters, derivative)
		fmt.Println(floats.Sum(derivative))
	}
}

func main() {
	for _, arg := range os.Args {
		if arg == "--debug" {
			util.DEBUG = true
			config := &profile.Config{
				MemProfile: true,
				CPUProfile: true,
			}
			defer profile.Start(config).Stop()
		}
	}
	client(os.Args)
}

func main() {
	defer profile.Start(profile.CPUProfile).Stop()
	start := time.Now()
	args := parseArgs()
	bc, err := clock.NewBallClock(args.NumBalls, args.Duration)
	if err != nil {
		log.Printf("Unable to create the Ball Clock. Error : %s", err.Error())
	}
	result := bc.RunClock()
	fmt.Println(result)
	end := time.Now()
	log.Printf("Elapsed time : %s", end.Sub(start).String())
}