```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n int
	fmt.Fscan(reader, &n)

	// We'll store all (position, string) pairs
	// Then build the result

	// Maximum possible length of s
	maxLen := 0

	type Placement struct {
		pos int
		t   string
	}

	placements := make([]Placement, 0, 1000000)

	for i := 0; i < n; i++ {
		var t string
		var k int
		fmt.Fscan(reader, &t, &k)
		for j := 0; j < k; j++ {
			var x int
			fmt.Fscan(reader, &x)
			// position x is 1-indexed
			end := x - 1 + len(t)
			if end > maxLen {
				maxLen = end
			}
			placements = append(placements, Placement{x - 1, t})
		}
	}

	// Build result array
	result := make([]byte, maxLen)
	// Fill with 'a' initially
	for i := range result {
		result[i] = 'a'
	}

	// For each placement, we need to write t starting at pos
	// But we need to handle overlaps carefully
	// Since input is guaranteed consistent, we can just write
	// but we need to be smart about performance

	// To avoid O(sum of all |t|*k) we need to track which positions are already set
	// and skip already-set characters
	// Use a "next unset" array or union-find approach

	// Use union-find / next pointer approach
	// next[i] = next position >= i that hasn't been set yet
	next := make([]int, maxLen+1)
	for i := range next {
		next[i] = i
	}

	var find func(x int) int
	find = func(x int) int {
		if next[x] == x {
			return x
		}
		next[x] = find(next[x])
		return next[x]
	}

	for _, p := range placements {
		pos := p.pos
		t := p.t
		tLen := len(t)

		// Write characters from t into result, skipping already-set positions
		// We iterate using find to jump over already-set positions
		cur := find(pos)
		for cur < pos+tLen {
			result[cur] = t[cur-pos]
			next[cur] = cur + 1
			// Path compression will happen on next find call
			cur = find(cur + 1)
		}
	}

	writer.Write(result)
	writer.WriteByte('\n')
}
```