func fetchMoves(curr_state string, moves *list.List, steps int) {
	if len(curr_state) <= steps-1 {
		return
	}

	val := []byte(curr_state)

	for i, _ := range val {
		if i+steps-1 < len(val) {
			success := true
			for k := 0; k < steps; k++ {
				if val[i+k] == '0' {
					success = false
				}
			}
			if success {
				for k := 0; k < steps; k++ {
					val[i+k] = '0'
				}

				moves.PushBack(string(val))

				for k := 0; k < steps; k++ {
					val[i+k] = '1'
				}
			}
		}
	}
}

func doStructMembers(fields []*ast.Field, pkg string, importer Importer, fn func(*ast.Object), q *list.List) {
	// Go Spec: For a value x of type T or *T where T is not an interface type, x.f
	// denotes the field or method at the shallowest depth in T where there
	// is such an f.
	// Thus we traverse shallower fields first, pushing anonymous fields
	// onto the queue for later.

	for _, f := range fields {
		if len(f.Names) > 0 {
			for _, fname := range f.Names {
				fn(fname.Obj)
			}
		} else {
			m := unnamedFieldName(f.Type)
			fn(m.Obj)
			// The unnamed field's Decl points to the
			// original type declaration.
			_, typeNode := splitDecl(m.Obj, nil)
			obj, typ := exprType(typeNode, false, pkg, importer)
			if typ.Kind == ast.Typ {
				q.PushBack(typ)
			} else {
				debugp("unnamed field kind %v (obj %v) not a type; %v", typ.Kind, obj, typ.Node)
			}
		}
	}
}

// Workers report back how many RPCs they have processed in the Shutdown reply.
// Check that they processed at least 1 RPC.
func checkWorker(t *testing.T, l *list.List) {
	for e := l.Front(); e != nil; e = e.Next() {
		if e.Value == 0 {
			t.Fatalf("Some worker didn't do any work\n")
		}
	}
}

func main() {
	var list list.List
	scanner := bufio.NewScanner(os.Stdin)
	p := getNumber(scanner)
	q := getNumber(scanner)
	for i := p; i <= q; i++ {
		square := i * i
		squareStr := strconv.Itoa(square)
		mid := len(squareStr) / 2
		power := float64(len(squareStr) - mid)
		rem := square % int(math.Pow(10, power))
		quo := square / int(math.Pow(10, power))
		sum := rem + quo
		if sum == i {
			list.PushBack(i)
		}
	}
	if list.Len() <= 0 {
		fmt.Println("INVALID RANGE")
	} else {
		for e := list.Front(); e != nil; e = e.Next() {
			fmt.Printf("%d ", e.Value)
		}
	}
}

func List2Array(l *list.List) []interface{} {
	output := make([]interface{}, 0)
	for i := l.Front(); i != nil; i = i.Next() {
		output = append(output, i.Value)
	}
	return output
}

func (this *CSRKB) fillCSRTables(nv int, rels *list.List) {
	tmpA := List2IntPairsArray(rels)
	sort.Sort(IntPairsArray(tmpA))
	rels = IntPairsArray2List(tmpA)

	this.edges = make([]int, rels.Len())
	this.firstEdge = make([]int, nv)
	this.numEdges = make([]int, nv)
	this.outCoef = make([]float64, nv)

	n := 0
	r := 0

	p := rels.Front()
	for p != nil && n < nv {
		this.firstEdge[n] = r
		for p != nil && p.Value.(IntPair).first == n {
			this.edges[r] = p.Value.(IntPair).second
			r++
			p = p.Next()
		}
		this.numEdges[n] = r - this.firstEdge[n]
		this.outCoef[n] = 1 / float64(this.numEdges[n])
		n++
	}
}

func convertArgumentsToSlice(arguments *list.List) []string {
	argumentSlice := make([]string, 0, arguments.Len())
	for e := arguments.Front(); e != nil; e = e.Next() {
		argumentSlice = append(argumentSlice, e.Value.(string))
	}
	return argumentSlice
}

func GetMinTime(L *list.List) Time {
	if L.Len() == 0 {
		return NOTIME
	}
	front := L.Front()
	return front.Value.(Elem).GetTime()
}

func (s *Surface) filterPixel(p Coord2D, used, unUsed *list.List) {
	if s.IsUsed(p.X, p.Y) {
		used.PushBack(p)
	} else {
		unUsed.PushBack(p)
	}
}

func ParseTokens(t []string) *list.List {
	tokens := new(list.List)
	for i := range t {
		tokens.PushBack(t[i])
	}
	n := 0
	s, o := new(list.List), new(list.List)
	for e := tokens.Front(); e != nil; e = e.Next() {
		if e.Value.(string) == "(" {
			n++
			listAppend(s, new(list.List))
			listAppend(o, s)
			s = s.Back().Value.(*list.List)
		} else if e.Value.(string) == ")" {
			n--
			s = o.Back().Value.(*list.List)
			listPop(o)
		} else {
			listAppend(s, e.Value.(string))
		}
	}
	if n != 0 {
		Error("unbalanced parantheses")
	}
	return s
}

func (p *Pipeline) removeUnacceptedChanges(l *list.List, allowAdd, allowDelete, allowUpdate bool) *list.List {
	if allowAdd && allowDelete && allowUpdate {
		return l
	}
	n := list.New()
	for iter := l.Front(); iter != nil; iter = iter.Next() {
		if iter.Value == nil {
			continue
		}
		ch, _ := iter.Value.(*dm.Change)
		if ch == nil {
			continue
		}
		if !allowAdd && ch.ChangeType == dm.CHANGE_TYPE_ADD {
			fmt.Printf("[PIPELINE]: Removing add change for path of %#v\n", ch.Path)
		} else if !allowDelete && ch.ChangeType == dm.CHANGE_TYPE_DELETE {
			fmt.Printf("[PIPELINE]: Removing delete change for path of %#v\n", ch.Path)
		} else if !allowUpdate && ch.ChangeType == dm.CHANGE_TYPE_UPDATE {
			if !allowAdd || ch.Path == nil || len(ch.Path) <= 1 {
				fmt.Printf("[PIPELINE]: Removing update for path of %#v and allowAdd %v\n", ch.Path, allowAdd)
			} else {
				fmt.Printf("[PIPELINE]: Changing update to add for path of %#v and allowAdd %v\n", ch.Path, allowAdd)
				ch.ChangeType = dm.CHANGE_TYPE_ADD
				ch.OriginalValue = nil
				n.PushBack(ch)
			}
		} else {
			n.PushBack(ch)
		}
	}
	return n
}

func (server *Server) buildArgumentsFlop(arguments *list.List, params imageserver.Params) error {
	flop, _ := params.GetBool("flop")
	if flop {
		arguments.PushBack("-flop")
	}
	return nil
}

func (server *Server) buildArgumentsMonochrome(arguments *list.List, params imageserver.Params) error {
	monochrome, _ := params.GetBool("monochrome")
	if monochrome {
		arguments.PushBack("-monochrome")
	}
	return nil
}

func (server *Server) buildArgumentsGravity(arguments *list.List, params imageserver.Params) error {
	gravity, _ := params.GetString("gravity")
	var translatedGravity string
	if gravity != "" {
		switch {
		case gravity == "n":
			translatedGravity = "North"
		case gravity == "s":
			translatedGravity = "South"
		case gravity == "e":
			translatedGravity = "East"
		case gravity == "w":
			translatedGravity = "West"
		case gravity == "ne":
			translatedGravity = "NorthEast"
		case gravity == "se":
			translatedGravity = "SouthEast"
		case gravity == "nw":
			translatedGravity = "NorthWest"
		case gravity == "sw":
			translatedGravity = "SouthWest"
		}
		if translatedGravity == "" {
			return &imageserver.ParamError{Param: "gravity", Message: "gravity should n, s, e, w, ne, se, nw or sw"}
		}
	} else {
		// Default gravity is center.
		translatedGravity = "Center"
	}

	arguments.PushBack("-gravity")
	arguments.PushBack(fmt.Sprintf("%s", translatedGravity))
	return nil
}

func DecomposeRecordLayer(tlsPayload []byte) list.List {
	if len(tlsPayload) < 5 {
		return list.List{}
	}
	log.Println("Parsing one packet......")
	var tlsLayerlist list.List
	total := uint16(len(tlsPayload))
	var offset uint16 = 0

	for offset < total {
		var p TLSHandshakeDecoder.TLSRecordLayer
		p.ContentType = uint8(tlsPayload[0+offset])
		p.Version = uint16(tlsPayload[1+offset])<<8 | uint16(tlsPayload[2+offset])
		p.Length = uint16(tlsPayload[3+offset])<<8 | uint16(tlsPayload[4+offset])
		p.Fragment = make([]byte, p.Length)
		l := copy(p.Fragment, tlsPayload[5+offset:5+p.Length+offset])
		tlsLayerlist.PushBack(p)
		log.Println("Length: ", p.Length, "Type: ", p.ContentType)
		offset += 5 + p.Length
		if l < int(p.Length) {
			fmt.Errorf("Payload to short: copied %d, expected %d.", l, p.Length)
		}
	}
	return tlsLayerlist
}

func (s system) NewTasksFromConfig(config map[string]interface{}) (*list.List, error) {
	tasks, ok := config["tasks"]
	if !ok {
		return nil, errors.New("The field tasks was not found")
	}

	switch vt := tasks.(type) {
	case []interface{}:
		fmt.Printf("vt: %v\n", vt)

		tasks := new(list.List)

		for t, val := range vt {
			fmt.Printf("%v == %v\n", t, val)
			mt, ok := val.(map[string]interface{})
			if ok {
				task, err := s.NewTask(mt)
				if err == nil {
					log.Printf("Adding %v", task)
					tasks.PushBack(task)
				} else {
					log.Printf("Could not add %v, %v", val, err)
				}
			}
		}

		return tasks, nil
	default:
		return nil, errors.New("tasks field was wrong type")
	}

	return nil, nil
}

func DecomposeHandshakes(data []byte) list.List {
	if len(data) < 4 {
		return list.List{}
	}
	log.Println("Parsing one TLSLayer.......")
	var handshakelist list.List
	total := uint32(len(data))
	var offset uint32 = 0

	for offset < total {
		var p TLSHandshakeDecoder.TLSHandshake
		p.HandshakeType = uint8(data[0+offset])
		p.Length = uint32(data[1+offset])<<16 | uint32(data[2+offset])<<8 | uint32(data[3+offset])
		p.Body = make([]byte, p.Length)
		if p.Length < 2048 {
			l := copy(p.Body, data[4+offset:4+p.Length+offset])

			if l < int(p.Length) {
				fmt.Errorf("Payload to short: copied %d, expected %d.", l, p.Length)
			}
			offset += 4 + p.Length
		} else {
			p.HandshakeType = 99
			p.Length = 0
			offset = total
		}

		log.Printf("Handshake Type: %d, length: %d ", p.HandshakeType, p.Length)
		handshakelist.PushBack(p)
	}
	return handshakelist
}

func GetShowTime(lcinema *list.List) {
	for e := lcinema.Front(); e != nil; e = e.Next() {
		lshowtimes := list.New().Init()
		cinema := e.Value.(*TCinema)
		showtimes := getShowTimeSingleCinema(cinema.TypeIndex, "2015-10-15")
		for i := 0; i < len(showtimes); i++ {
			jshowtime := showtimes[i]
			showtime := new(ShowTime)
			showtime.SeatCount = jshowtime.SeatCount
			showtime.Type = 0
			showtime.TypeCinemaIndex = jshowtime.CinemaID
			showtime.TypeCityIndex = jshowtime.CityID
			showtime.TypeHallID = jshowtime.HallID
			showtime.TypeMovieIndex = jshowtime.FilmID
			showtime.TypeMovieName = jshowtime.FilmName
			showtime.TypeName = "wangpiao"
			//			showtime.TypeSaleEndTimeS = jshowtime.SaleEndTime
			ts, _ := time.Parse("2006-01-02 15:04:05", jshowtime.SaleEndTime)
			showtime.TypeSaleEndTimeS = ts
			showtime.TypeSaleEndTime = ts.Unix()
			showtime.TypeShowIndex = jshowtime.ShowIndex
			lshowtimes.PushBack(showtime)
		}
		InsertShowTimeList(lshowtimes)
	}
}

func (this *UKB) initSynsetVector(ls *list.List, pv []float64) {
	nw := 0
	uniq := make(map[string]*Word)
	for s := ls.Front(); s != nil; s = s.Next() {
		for w := s.Value.(*Sentence).Front(); w != nil; w = w.Next() {
			if this.RE_wnpos.MatchString(w.Value.(*Word).getTag(0)) {
				key := w.Value.(*Word).getLCForm() + "#" + strings.ToLower(w.Value.(*Word).getTag(0))[0:1]
				if uniq[key] == nil {
					nw++
					uniq[key] = w.Value.(*Word)
				}
			}
		}
	}

	for _, u := range uniq {
		lsen := u.getSenses(0)
		nsyn := lsen.Len()
		for s := lsen.Front(); s != nil; s = s.Next() {
			syn := this.wn.getVertex(s.Value.(FloatPair).first)
			if syn == VERTEX_NOT_FOUND {
				LOG.Warn("Unknown synset " + s.Value.(FloatPair).first + " ignored. Please check consistency between sense dictionary and KB")
			} else {
				pv[syn] += (1.0 / float64(nw)) * (1.0 / float64(nsyn))
			}
		}
	}
}

// Performs a scan against the Log.
// For each x509 certificate found, |foundCert| will be called with the
// index of the entry and certificate itself as arguments.  For each precert
// found, |foundPrecert| will be called with the index of the entry and the raw
// precert string as the arguments.
//
// This method blocks until the scan is complete.
func (s *Scanner) Scan(foundCert func(*ct.LogEntry),
	foundPrecert func(*ct.LogEntry)) error {
	s.Log("Starting up...\n")
	s.certsProcessed = 0
	s.precertsSeen = 0
	s.unparsableEntries = 0
	s.entriesWithNonFatalErrors = 0

	latestSth, err := s.logClient.GetSTH()
	if err != nil {
		return err
	}
	s.Log(fmt.Sprintf("Got STH with %d certs", latestSth.TreeSize))

	ticker := time.NewTicker(time.Second)
	startTime := time.Now()
	fetches := make(chan fetchRange, 1000)
	jobs := make(chan matcherJob, 100000)
	go func() {
		for range ticker.C {
			throughput := float64(s.certsProcessed) / time.Since(startTime).Seconds()
			remainingCerts := int64(latestSth.TreeSize) - int64(s.opts.StartIndex) - s.certsProcessed
			remainingSeconds := int(float64(remainingCerts) / throughput)
			remainingString := humanTime(remainingSeconds)
			s.Log(fmt.Sprintf("Processed: %d certs (to index %d). Throughput: %3.2f ETA: %s\n", s.certsProcessed,
				s.opts.StartIndex+int64(s.certsProcessed), throughput, remainingString))
		}
	}()

	var ranges list.List
	for start := s.opts.StartIndex; start < int64(latestSth.TreeSize); {
		end := min(start+int64(s.opts.BatchSize), int64(latestSth.TreeSize)) - 1
		ranges.PushBack(fetchRange{start, end})
		start = end + 1
	}
	var fetcherWG sync.WaitGroup
	var matcherWG sync.WaitGroup
	// Start matcher workers
	for w := 0; w < s.opts.NumWorkers; w++ {
		matcherWG.Add(1)
		go s.matcherJob(w, jobs, foundCert, foundPrecert, &matcherWG)
	}
	// Start fetcher workers
	for w := 0; w < s.opts.ParallelFetch; w++ {
		fetcherWG.Add(1)
		go s.fetcherJob(w, fetches, jobs, &fetcherWG)
	}
	for r := ranges.Front(); r != nil; r = r.Next() {
		fetches <- r.Value.(fetchRange)
	}
	close(fetches)
	fetcherWG.Wait()
	close(jobs)
	matcherWG.Wait()

	s.Log(fmt.Sprintf("Completed %d certs in %s", s.certsProcessed, humanTime(int(time.Since(startTime).Seconds()))))
	s.Log(fmt.Sprintf("Saw %d precerts", s.precertsSeen))
	s.Log(fmt.Sprintf("%d unparsable entries, %d non-fatal errors", s.unparsableEntries, s.entriesWithNonFatalErrors))
	return nil
}