func (this *Scheduler) Loop() {
	collection, session := connectMongo()
	defer func() {
		session.Close()
		if err := recover(); err != nil {
			spew.Println(err)
		}
	}()
	for {
		select {
		case item := <-this.Queue:
			switch v := item.(type) {
			case Joke:
				spew.Println("[+] insert : ", v)
				v.Date = time.Now().Unix()
				v.Id = time.Now().UnixNano()
				spew.Println(v.Date, v.Id)
				collection.Insert(v)

			default:
				spew.Println("sth wrong?")
			}
			spew.Println("----------------------------------------------------------------------------")

			//case for other chan receive
			//...
		}
	}
}

// Less(CmpI) を実装した型であれば、CmpI 型として、このスーパーな関数が使えるようになるんだぜ。
func quickSortCmpI(buff []CmpI, low, high int) {
	p := buff[low+(high-low)/2] // 枢軸の値を決める。
	i, j := low, high
	spew.Println(" start:", "i:", i, "j:", j, "pvalue:", p, buff)
	for {
		for buff[i].Less(p) { // 左から（小さいグループ）要素 < 枢軸 が崩れるところまでインデックスを進める。
			i++
		}
		for p.Less(buff[j]) { // 右から（大きいグループ）枢軸 < 要素 が崩れるところまでインデックスを進める。
			j--
		}
		if i >= j { // 左右のインデックスが交わったらループ終了。
			break
		}
		// で、大小グループ関係が崩れているところをスワップ。
		buff[i], buff[j] = buff[j], buff[i]
		// インデックスを進めてループの先頭へ。
		i++
		j--
	}
	spew.Println("result:", "i:", i, "j:", j, "pvalue:", p, buff)
	fmt.Println()
	// 枢軸を基準に大小グループに分けられた。
	// こんどはそれらの大小グループに対して上の処理を繰り返す。
	// 以下で
	// x x x x P y y y y
	//       i j
	// って分割されるっぽい。
	if low < i-1 {
		quickSortCmpI(buff, low, i-1)
	}
	if high > j+1 {
		quickSortCmpI(buff, high, j+1)
	}
}

func main() {
	//* Go のシグナル通知はチャネル上の '''os.Signal''' 値を送信することで動作します。私達はこれらの通知を受け取るチャネルを一つ作成します（また、プログラムが exit 可能時に、そのチャネルが私達に通知するようにします）。
	// これなんでバッファ（非同期チャネルに）してんだ？バッファなし（同期チャネル）でも動くじゃん。
	sigs := make(chan os.Signal, 1)
	done := make(chan bool, 1)

	//* '''signal.Notify''' は特定のシグナル通知を受け取るチャネルを登録します。
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

	//* この goroutine はシグナル受信のブロッキングを実行します。シグナルを受信すると、プログラムが終了可能であることを通知します。
	// ブロッ......キング......レシーバー？
	// main が実行されると、ここの goroutine も並行して実行される。
	go func() {
		sig := <-sigs //signal 受信専用チャネル。
		spew.Println()
		spew.Println(sig) // signal キター。
		done <- true
	}()

	//* プログラムは期待された（上の groutine の '''done''' の値の送信で示された）シグナルを取得するまでここで待ちます。その後、exit します。
	// で、上の groutine と合わせて main() の処理も進む。
	spew.Println("awaiting signal")
	// 上の groutine の、done チャネルにデータが入ってくるまで待ち合わせ。
	<-done
	spew.Println("exiting")
}

func main() {
	// int
	var i int = 1
	var pi *int = &i

	// string
	var str string = "hello, world."
	var pstr *string = &str

	// array
	var ary [2]int = [2]int{1, 2}
	var pary *[2]int = &ary

	// slice
	var slc []int = []int{10, 20}
	var pslc *[]int = &slc

	// これは分かる。
	spew.Println("int")
	spew.Printf("i = %#+v, &i = %#+v, pi = %#+v, *pi = %#+v\n\n", i, &i, pi, *pi)

	spew.Println("string")
	spew.Printf("str = %#+v, &str = %#+v, pstr = %#+v, *pstr = %#+v\n\n", str, &str, pstr, *pstr)

	spew.Println("array")
	spew.Printf("ary = %#+v, &ary = %#+v, pary = %#+v, *pary = %#+v\n\n", ary, &ary, pary, *pary)

	spew.Println("slice")
	spew.Printf("slc = %#+v, &slc = %#+v, pslc = %#+v, *pslc = %#+v\n\n", slc, &slc, pslc, *pslc)

	// 解せぬ。
	spew.Println("string[n]")
	// &str[0]: cannot take the address of str[0] // 文字列の要素をアドレス番地 + 添字で求められないのは仕様である、といった感じであろうか？
	// pstr[0]: invalid operation: pstr[0] (type *string does not support indexing) // 上と同様。
	// *pstr[0]: invalid operation: pstr[0] (type *string does not support indexing) // なぜだ。
	spew.Printf("str[0] = %#+v\n\n", str[0])

	spew.Println("array[n]")
	// *pary[0]: invalid indirect of pary[0] (type int) // なぜだ。
	spew.Printf("ary[0] = %#+v, &ary[0] = %#+v, pary[0] = %#+v\n\n", ary[0], &ary[0], pary[0])

	spew.Println("slice[n]")
	// pslc[0]: invalid operation: pslc[0] (type *[]int does not support indexing) // スライスはそれ自体がすでにどこかのアドレス番地の参照先のはず。スライスのポインタはダブルポインタ的な感じなので、アドレス番地 + 添字で求められないのは仕様である、といった感じだろうか？
	// *pslc[0]: invalid operation: pslc[0] (type *[]int does not support indexing) // なぜだ。
	spew.Printf("slc[0] = %#+v, &slc[0] = %#+v\n\n", slc[0], &slc[0])

	// できるじゃん。
	spew.Println("(*string)[n]")
	spew.Printf("(*pstr)[0] = %#+v\n\n", (*pstr)[0])

	spew.Println("(*array)[n]")
	spew.Printf("(*pary)[0] = %#+v\n\n", (*pary)[0])

	spew.Println("(*pscl)[n]")
	spew.Printf("(*pslc)[0] = %#+v\n\n", (*pslc)[0])
}

func (p *Parser) PrintDistinctCombatLogTypes() {
	for k, v := range p.combatLogParser.distinct {
		spew.Println(k)
		for kk, vv := range v {
			if len(vv) > 1 {
				spew.Println(kk)
				pp(vv)
			}
		}
	}
}

func main() {
	var p Point
	var q Point = Point{10, 10}
	r := Point{x: 100, y: 100}

	spew.Dump(p, q, r)
	spew.Dump(p.x, p.y, q.x, q.y, r.x, r.y)

	spew.Println(distance(p, q))
	spew.Println(distance(p, r))
	spew.Println(distance(q, r))
}

func main() {
	a := []int{5, 8, 4, 6, 3, 7, 2, 9, 1, 0}
	b := []int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
	c := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

	insertSort(a)
	insertSort(b)
	insertSort(c)

	spew.Println(a)
	spew.Println(b)
	spew.Println(c)
}

func main() {
	//* key / varlue ペアを設定するために、'''os.Setenv''' を使います。key から value を取得するために '''os.Getenv''' を使います。環境に key が存在しない場合は空文字が返ります。
	os.Setenv("FOO", "1")
	spew.Printf("FOO: %#+v\n", os.Getenv("FOO"))
	spew.Printf("BAR: %#+v\n", os.Getenv("BAR"))
	spew.Printf("$PGUSER: %#+v\n", os.Getenv("PGUSER"))

	//* '''os.Environ''' を使うと、環境内の全ての key / value ペアがリストされます。これは '''key=value''' という形式の文字列スライスです。ここで私達は全ての key を出力しています。
	spew.Println()
	for _, e := range os.Environ() {
		pair := strings.Split(e, "=") // e: "key=value" --- strings.Split() ---> pair:["key", "value"]
		spew.Println(pair[0])
	}
}

func main() {
	for i := 1; i <= 100; i++ {
		switch i % 15 {
		case 0:
			spew.Println("FizzBuzz")
		case 3, 6, 9:
			spew.Println("Fizz")
		case 5, 10:
			spew.Println("Buzz")
		default:
			spew.Println(i)
		}
	}
}

func main() {
	for i := 1; i <= 100; i++ {
		switch {
		case i%15 == 0:
			spew.Println("FizzBuzz")
		case i%3 == 0:
			spew.Println("Fizz")
		case i%5 == 0:
			spew.Println("Buzz")
		default:
			spew.Println(i)
		}
	}
}

func main() {
	// 構造体のポインタを定義する。
	var p *Point = &Point{}       // var p *Point だけでは当然 nil である。
	var q *Point = &Point{10, 10} // これで初期化した構造体のアドレス番地が返るようだ。
	r := new(Point)               // でも普通は new 使ってゼロ値で初期化済みの構造体のアドレス番地返しますよね。
	r.x, r.y = 100, 100           // new したら値は明示的に代入する。

	spew.Dump(p, q, r)
	spew.Dump(p.x, p.y, q.x, q.y, r.x, r.y)

	spew.Println(distance(p, q))
	spew.Println(distance(p, r))
	spew.Println(distance(q, r))
}

func pppc(pc uintptr, ok bool, args ...interface{}) {
	if ok {
		f := runtime.FuncForPC(pc)
		fParts := strings.Split(f.Name(), ".")
		fun := fParts[len(fParts)-1]
		s := spew.Sprintf("vvvvvvvvvvvvvvv %s vvvvvvvvvvvvvvv\n", fun)
		spew.Print(s)
		spew.Dump(args...)
		spew.Println(strings.Repeat("^", len(s)-1))
	} else {
		spew.Println("vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv")
		spew.Dump(args...)
		spew.Println("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^")
	}
}

func (this *qiubaiCrawler) Visit(Q chan interface{}, L *sync.Mutex) {
	//spew.Dump(this)
	this.CrawlerBase.Visit(Q, L)
	//spew.Dump(CACHEMAP)
	this.doc.Find(".content").Each(func(i int, s *Selection) {
		src, ok := s.Parent().Attr("id")
		if !ok {
			src = this.doc.Url.String()
		} else {
			src = this.Cfg.Host + strings.Replace(src, "qiushi_tag_", "article/", -1)
		}
		cont := strings.TrimSpace(s.Text())
		_, ok = CACHEMAP[src]
		if ok {
			spew.Println("[!] Skip!")
			return
		} else {
			L.Lock()
			CACHEMAP[src] = true
			L.Unlock()
		}

		imgsrc := ""
		if thumb := s.Next(); thumb != nil {
			imgsrc, _ = thumb.Find("img").Eq(0).Attr("src")
		}
		joke := Joke{
			Content: cont,
			Src:     src,
			ImgSrc:  imgsrc,
		}
		Q <- joke
	})
	//spew.Dump(joke)
}

func main() {
	//* '''defer''' は '''os.Exit''' を使うと '''実行されません'''。したがって、この '''fmt.Println''' は決して call されません。
	defer spew.Println("!")

	os.Exit(3)
	//* 例えば C などとは違って、Go は exit ステータスを示すために '''main''' からの整数の戻り値を使いません。非ゼロステータスで exit したい場合は、'''os.Exit''' を使う必要があります。
}

func (p *OuterParser) AnalyzePacket(callback func(*OuterParserBaseItem), fromEvent dota.EDemoCommands, tick int, data []byte) {
	reader := NewBytesReader(data)
	for reader.CanRead() {
		iType := int(reader.ReadVarInt32())
		length := int(reader.ReadVarInt32())
		obj, err := p.AsBaseEventNETSVC(iType)
		if err != nil {
			spew.Println(err)
			reader.Skip(length)
		} else {
			item := &OuterParserItem{
				Sequence: p.Sequence,
				From:     fromEvent,
				Object:   obj,
				Tick:     tick,
				Data:     reader.Read(length),
			}
			p.Sequence++
			switch obj.(type) {
			case *dota.CSVCMsg_UserMessage:
				message := &dota.CSVCMsg_UserMessage{}
				ProtoUnmarshal(item.Data, message)
				um, err := p.AsBaseEventBUMDUM(int(message.GetMsgType()))
				if err == nil {
					item.Object = um
					item.Data = message.GetMsgData()
					callback(parseOne(item))
				}
			default:
				callback(parseOne(item))
			}
		}
	}
}

func main() {
	a := []int{1, 2, 3}
	b := []int{4, 5, 6}

	foo(0, b...)                  // foo(0, b[0], b[1], b[2]) といっしょ。
	spew.Println(append(a, b...)) // append() だって当然できる。
}

func main() {
	if len(os.Args) < 2 {
		spew.Println("Expected a .dem file as argument")
	}

	for _, path := range os.Args[1:] {
		parser := yasha.ParserFromFile(path)
		parser.OnFileInfo = func(fileinfo *dota.CDemoFileInfo) {
			data, err := json.MarshalIndent(fileinfo, "", "  ")
			if err != nil {
				panic(err)
			}
			spew.Println(string(data))
		}
		parser.Parse()
	}
}

func main() {
	for i := 0; i < 10; i++ {
		s := "foo"
		spew.Println(s, i)
	}
	// ブロック外。
	// spew.Println(s, i)
}

func main() {
	lex := newLex()
	lex.Init(os.Stdin)
	for {
		spew.Printf("> ")
		lex.getToken()
		spew.Println(lex.token, lex.TokenText())
	}
}

func main() {
	s := new(scanner.Scanner)
	s.Init(os.Stdin)
	for {
		spew.Printf("> ")
		x := s.Scan()
		spew.Println(x, s.TokenText())
	}
}