package main

import(
	"fmt"
	"os"
	"io"
	"bufio"
	"bytes"
	"sort"
	"math"
)

//  長い入力を読む
func ReadLongLines(times int) ([]string, error) {
	result := make([]string, times)
	reader := bufio.NewReader(os.Stdin)
	buffer := bytes.NewBuffer(make([]byte, 0))
	readBytes := int64(2)
	for i := 0; i < times; i++ {
		for {
			readBuf, isPrefix, err := reader.ReadLine()
			// fmt.Printf("Reader.Read: %d\n", len(readBuf))
			readBytes += int64(len(readBuf) + 1)
			if err != nil {
				if err == io.EOF {
					fmt.Println("EOF")
					break
				} else {
					return result, err
				}
			}
			_, err = buffer.Write(readBuf)
			if err != nil {
				return result, err
			}
			// end of line
			if !isPrefix {
				result[i] = buffer.String()
				buffer.Reset()
				// reader = bufio.NewReader(os.Stdin)
				break
			}
		}
	}
	// 先読みしてしまうようなので、戻しておく
	os.Stdin.Seek(-int64(reader.Buffered()), os.SEEK_CUR)
	return result, nil
}




type SuffixArray struct {
	array []int
	text *string
}

// とりあえず最初に見つけたものだけ返してみるか
func (this *SuffixArray) Search(pattern *string) int {
	// return -1
	// Binary Search すればいいんだよね？
	begin := 0
	end := len(*this.text) -1
	cur := int((end - begin) / 2)
	
	for {
		// fmt.Printf("b:%d, c: %d, end: %d\n", begin, cur, end)
		index := this.array[cur]
		// fmt.Printf("index: %d\n", index)
		// mutch
		if StartsWith((*this.text)[index:], *pattern) {
			return index
		}
		// if begin == cur || cur == end {
		// 	return -1
		// }
		if end <= begin {
			return -1
		}
		// to right or left
		if (*this.text)[index:] < *pattern {
			// fmt.Println("--->>>")
			newCur := cur + int(math.Ceil(float64(end - cur) / 2.0))
			begin = cur + 1
			cur = newCur
		} else {
			// fmt.Println("<<<---")
			newCur := begin + (cur - begin) / 2
			end = cur - 1
			cur = newCur
		}
	}
}

func StartsWith(text string, pattern string) bool {
	// fmt.Printf("%s ? %s\n", text, pattern)
	if len(text) < len(pattern) {
		return false
	}
	for i := 0; i < len(pattern); i++ {
		if text[i] != pattern[i] {
			return false
		}
	}
	return true
}

func Compare(rank *[]int, sa *[]int, lhs, rhs, k int ) bool {
	l := len(*rank)
	// if k == 1 {
	// 	fmt.Printf("sa: %v\n", *sa)
	// 	fmt.Printf("%d, %d\n", lhs, rhs)
	// }
	if (*rank)[(*sa)[lhs]] != (*rank)[(*sa)[rhs]] {
		// if k == 1 {
		// 	fmt.Printf("not same %d ? %d\n", (*rank)[(*sa)[lhs]], (*rank)[(*sa)[rhs]])
		// }
		return (*rank)[(*sa)[lhs]] < (*rank)[(*sa)[rhs]]
	} else {
		li := -1
		if (*sa)[lhs] + k < l {
			li = (*rank)[(*sa)[lhs] + k]
		}
		ri := -1
		if (*sa)[rhs] + k < l {
			ri = (*rank)[(*sa)[rhs] + k]
		}
		// if k == 1 {
		// 	fmt.Printf("same     %d ? %d\n", li, ri)
		// }
		return li < ri
	}
}
// constructor
func NewSuffixArray(text *string) SuffixArray {
	t := (*text) + "$"
	l := len(t)
	sa := make([]int, l)
	rank := make([]int, l)
	temp := make([]int, l)
	
	// * はじめに1文字分の rank を作る
	for i := 0; i < l; i++ {
		sa[i] = i
		rank[i] = int(t[i]) // これで順序は成立する
	}

    // * array を i ... i + k の範囲に伸ばして、
	for k := 1; k < l; k *= 2 {
		// fmt.Printf("k:%d\n", k)
		sort.SliceStable(sa, func(lhs, rhs int) bool {
			if rank[sa[lhs]] != rank[sa[rhs]] {
				return rank[sa[lhs]] < rank[sa[rhs]]
			} else {
				li := -1
				if sa[lhs] + k < l {
					li = rank[sa[lhs] + k]
				}
				ri := -1
				if sa[rhs] + k < l {
					ri = rank[sa[rhs] + k]
				}
				// fmt.Printf("%d < %d\n", li, ri)
				return li < ri
			}
		})

		// * array から rank を作成
		temp[sa[0]] = 0
		for i := 1; i < l; i++ {
			// fmt.Printf("i:%d\n", i)
			if Compare(&rank, &sa, i - 1, i, k) {
				// fmt.Printf("sa[i]: %d\n", sa[i])
				temp[sa[i]] = temp[sa[i-1]] + 1
			} else {
				temp[sa[i]] = temp[sa[i-1]] 
			}
		}
		for i := 0; i < l; i++ {
			rank[i] = temp[i]
		}
		// fmt.Printf("k:%d %v\n", k, rank)
	}
	// fmt.Println(sa)
	// fmt.Println("result:")
	// for i := 0; i < l; i++ {
	// 	fmt.Printf("%s\n", t[sa[i]:])
	// }
	// * 要は自身のrankと i+k のrankでsort ( 最初の倍の長さにできる )
	return SuffixArray{sa, &t}
}

var sa SuffixArray
func IsExists(text *string, pattern *string) bool {
	return sa.Search(pattern) != -1
}

func main() {
	lines, err := ReadLongLines(1)
	if err != nil {
		fmt.Println(err)
		return
	}
	t := lines[0]
	sa = NewSuffixArray(&t)
	var q int
	fmt.Scanf("%d", &q)

	lines, err = ReadLongLines(q)
	if err != nil {
		fmt.Println(err)
		return
	}
	for _, p := range lines {
		if IsExists(&t, &p) {
			fmt.Println("1")
		} else {
			fmt.Println("0")
		}
	}
	// for i := 0; i < q; i++ {
	// 	var p string
	// 	fmt.Scanf("%s", &p)
	// 	if IsExists(&t, &p) {
	// 		fmt.Println("1")
	// 	} else {
	// 		fmt.Println("0")
	// 	}
	// }
}



Measured memory_bytes: 36984