package main

import (
    "bytes"
    "bufio"
    "errors"
    "fmt"
    "io"
    "math"
    "os"
    "strconv"
    "text/scanner"
)


type stateFifo struct {
  items   []stateIndex
  readPos int
}

func (f *stateFifo) Push(i stateIndex) {
  if f.items == nil {
    f.items = make([]stateIndex, 0, 10)
  }
  f.items = append(f.items, i)
}

func (f stateFifo) Peek() (i stateIndex, ok bool) {
  if f.items == nil {
    return -1, false
  }
  if f.IsEmpty() {
    return -1, false
  }
  return f.items[f.readPos], true
}

func (f *stateFifo) Pop() {
  f.readPos++
  if f.IsEmpty() {
    f.Reset()
  }
}

func (f stateFifo) IsEmpty() bool {
  return f.readPos >= len(f.items)
}


func (f *stateFifo) Reset() {
  f.readPos = 0
  f.items = f.items[0:0]
}
  
type InvalidCharsetError struct {
  Char rune
}

func newInvalidCharsetError(char rune) error {
  return &InvalidCharsetError{
    Char: char,
  }
}

func (e *InvalidCharsetError) Error() string {
  return fmt.Sprintf("encountered rune: '%c' but it is not supported by this machine", e.Char)
}

type stateIndex int64

type vertexer interface {
  nextState(edge int64) stateIndex
  setNextState(edge int64, si stateIndex)
  setInvalidEdgesTo(si stateIndex)
}


type vertex struct {
  failState stateIndex
  output    []int
}

func newVertex() vertex {
  return vertex{
    failState: invalidState,
    output:    nil,
  }
}

func (v *vertex) setFailState(state stateIndex) {
  v.failState = state
}

func (v *vertex) appendOutputIndex(i []int) {
  if v.output == nil {
    v.output = make([]int, 0, 5)
  }
  v.output = append(v.output, i...)
}

func (v *vertex) outputs() []int {
  if v.output == nil {
    return make([]int, 0, 0)
  }
  return v.output
}

func (v vertex) hasOutput() bool {
  return v.output != nil && len(v.output) != 0
}

type vertexDense struct {
  vertex
  edges []stateIndex
}

func newVertexDense(numberOfStates int) vertexDense {
  v := vertexDense{
    vertex: newVertex(),
    edges:  make([]stateIndex, numberOfStates),
  }
  // By default, all denseStates are invalid
  for i := range v.edges {
    v.edges[i] = invalidState
  }
  return v
}

func (v *vertexDense) nextState(edge int64) (next stateIndex, ok bool) {
  next = v.edges[edge]
  return next, next != invalidState
}

func (v *vertexDense) setNextState(edge int64, si stateIndex) {
  v.edges[edge] = si
}

func (v *vertexDense) setInvalidEdgesTo(si stateIndex) {
  for stateIndex, state := range v.edges {
    if state == invalidState {
      v.edges[stateIndex] = si
    }
  }
}

type denseStates []vertexDense

func newDenseStates() denseStates {
  return make([]vertexDense, 0, 10)
}

func (s denseStates) lastStateIndex() stateIndex {
  return stateIndex(len(s))
}

const (
  startState   stateIndex = 0
  invalidState stateIndex = -1
)

type LowerLetters struct {
  states denseStates
}

type LowerLettersBuilder struct {
  states        denseStates
  keywordsSoFar int
}

const (
  letterStates = 26
)

func NewLowerLetters() (m LowerLettersBuilder) {
  m = LowerLettersBuilder{}
  m.states = newDenseStates()
  m.states = append(m.states, newVertexDense(letterStates))
  return
}

func (m *LowerLettersBuilder) AddKeyword(keyword string) (err error) {
  m.states, err = addKeywordToDenseTrie(m.states, m.keywordsSoFar, keyword)
  m.keywordsSoFar++
  return
}

func (m *LowerLettersBuilder) Build() LowerLetters {
  l := LowerLetters{
    states: m.states,
  }
  m.states = nil
  // Set all of the start Tries that don't match back to the start
  l.states[startState].setInvalidEdgesTo(startState)
  l.states = buildDenseFails(l.states)
  return l
}

func addKeywordToDenseTrie(statesIn denseStates, keywordIndex int, keyword string) (states denseStates, err error) {
  states = statesIn
  currentState := startState
  letterIndex := 0
  for ; letterIndex < len(keyword); letterIndex++ {
    letter := keyword[letterIndex]
    if !isLowerAscii(letter) {
      return states, newInvalidCharsetError(rune(letter))
    }
    letterStateIndex := letter - 'a'
    nextState, ok := states[currentState].nextState(int64(letterStateIndex))
    if !ok {
      break
    }
    currentState = nextState
  }
  for ; letterIndex < len(keyword); letterIndex++ {
    letter := keyword[letterIndex]
    letterStateIndex := letter - 'a'
    v := newVertexDense(letterStates)
    states[currentState].setNextState(int64(letterStateIndex), states.lastStateIndex())
    currentState = states.lastStateIndex()
    states = append(states, v)
  }
  states[currentState].appendOutputIndex([]int{keywordIndex})
  return
}

func isLowerAscii(r uint8) bool {
  return 'a' <= r && r <= 'z'
}

func buildDenseFails(statesIn denseStates) (states denseStates) {
  states = statesIn
  start := states[startState]
  q := stateFifo{}
  // initialize the denseStates at depth 1
  for _, state := range start.edges {
    if state != startState {
      // All failure denseStates at depth 1 go back to the start state
      states[state].failState = startState
      q.Push(state)
    }
  }

  for !q.IsEmpty() {
    statePreviousDepth, _ := q.Peek()
    q.Pop()
    for letterIndex, s := range states[statePreviousDepth].edges {
      if s != invalidState {
        q.Push(s)
        state := states[statePreviousDepth].failState
        _, ok := states[state].nextState(int64(letterIndex))
        for !ok {
          state = states[state].failState
          _, ok = states[state].nextState(int64(letterIndex))
        }
        // Found a failState that is not invalid
        // set the nextState fail state to the entry for this letter
        states[s].failState, _ = states[state].nextState(int64(letterIndex))
        states[s].appendOutputIndex(states[states[s].failState].output)
      }
    }
  }
  return
}


type Output struct {
  KeywordIndex    int
  CharacterOffset uint64
  ByteOffset      uint64
}

type Writer interface {
  Emit(out Output)
  io.Closer
}

type Reader interface {
  Next() (out Output, ok bool)
}

type ReadWriter interface {
  Reader
  Writer
}

func (m LowerLetters) Search(input io.Reader, results *sync) (err error) {
  var bytesReadSoFar uint64
  currentState := startState
  letter := []byte{0}
  defer func() {
    _ = results.Close()
  }()
  for {
    _, err = input.Read(letter)
    if err != nil {
      if isEOFOrClosed(err) {
        err = nil
      }
      return
    }
    bytesReadSoFar++
    letterIndex := letter[0] - 'a'
    _, ok := m.states[currentState].nextState(int64(letterIndex))
    for !ok {
      currentState = m.states[currentState].failState
      _, ok = m.states[currentState].nextState(int64(letterIndex))
    }
    currentState, _ = m.states[currentState].nextState(int64(letterIndex))
    if m.states[currentState].hasOutput() {
      outputs := m.states[currentState].outputs()
      for i, _ := range outputs {
        results.outputs[results.currentWriteIndex] = Output{
          KeywordIndex:    outputs[i],
          ByteOffset:      bytesReadSoFar,
          CharacterOffset: bytesReadSoFar,
        }
        results.currentWriteIndex++
      }
    }
  }
}

func isEOFOrClosed(err error) bool {
  if errors.Is(err, io.EOF) ||
    errors.Is(err, io.ErrClosedPipe) {
    return true
  }
  if pathErr, ok := err.(*os.PathError); ok {
    if pathErr.Err.Error() == "file already closed" {
      return true
    }
  }
  return false
}


// sync
// A result bucket built without Search running in a go routine
// This is not thread-safe and is intended for small, test jobs.
type sync struct {
  outputs          []Output
  currentReadIndex int
  currentWriteIndex int
}

func NewSync(bufferSize int) ReadWriter {
  return &sync{
    outputs: make([]Output, bufferSize),
  }
}

func (r *sync) Reset() {
  r.currentReadIndex = 0
  r.currentWriteIndex = 0
}

func (r *sync) Next() (out Output, ok bool) {
  if r.currentReadIndex >= len(r.outputs) {
    return out, false
  }
  out = r.outputs[r.currentReadIndex]
  r.currentReadIndex++
  return out, true
}

func (r *sync) Emit(out Output) {
  r.outputs[r.currentWriteIndex] = out
  r.currentWriteIndex++
}

func (r *sync) Close() error {
  return nil
}

func main() {
  var reader *bufio.Reader
    reader = bufio.NewReaderSize(os.Stdin, 1024*1024)

  sc := scanner.Scanner{}
  sc.Init(reader)

  sc.Scan()
  nTemp, err := strconv.ParseInt(sc.TokenText(), 10, 64)
  checkError(err)
  n := int32(nTemp)

  sb := NewLowerLetters()
  genes := make([]string, n)
  for i := 0; i < int(n); i++ {
    sc.Scan()
    genes[i] = sc.TokenText()
    _ = sb.AddKeyword(genes[i])
  }

  health := make([]int32, n)
  for i := 0; i < int(n); i++ {
    sc.Scan()
    healthItemTemp, err := strconv.ParseInt(sc.TokenText(), 10, 64)
    checkError(err)
    health[i] = int32(healthItemTemp)
  }

  sc.Scan()
  sTemp, err := strconv.ParseInt(sc.TokenText(), 10, 64)
  checkError(err)
  s := int32(sTemp)

  m := sb.Build()
  var res *sync
  res = NewSync(1000000).(*sync)

  var min int64
  min = math.MaxInt64
  var max int64
  var score int64
  var match Output
  for sItr := 0; sItr < int(s); sItr++ {
    score = 0
    sc.Scan()
    firstTemp, err := strconv.ParseInt(sc.TokenText(), 10, 64)
    checkError(err)
    first := int32(firstTemp)

    sc.Scan()
    lastTemp, err := strconv.ParseInt(sc.TokenText(), 10, 64)
    checkError(err)
    last := int32(lastTemp)

    sc.Scan()
    d := sc.TokenText()

    res.Reset()
    _ = m.Search(bytes.NewBufferString(d), res)
    for i := 0; i < res.currentWriteIndex; i++ {
      match = res.outputs[i]
      if first <= int32(match.KeywordIndex) && int32(match.KeywordIndex) <= last {
        score += int64(health[int32(match.KeywordIndex)])
      }
    }
    if score > max {
      max = score
    }
    if score < min {
      min = score
    }
  }

  fmt.Printf("%d %d", min, max)
}

func checkError(err error) {
    if err != nil {
        panic(err)
    }
}