output_description: Print q lines. The i-th line should contain the response to the i-th query. If
  S_{a_i} S_{{a_i}+1} ... S_{b_i} can be made into T_{c_i} T_{{c_i}+1} ...
  T_{d_i}, print `YES`. Otherwise, print `NO`.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      S
      T
      q
      a_1 b_1 c_1 d_1
      ...
      a_q b_q c_q d_q
attempt: def examC():
      N = I()
      d = defaultdict(int)
      for i in range(N):
          curD = defaultdict(int)
          S = SI()
          for s in S:
              curD[s] += 1
          if i == 0:
              d = curD
              continue
          for s in alphabet:
              d[s] = min(d[s], curD[s])
      d = sorted(d.items())
      ans = ""
      for key, i in d:
          ans += key * i
      print(ans)
      return
  
  
  def examD():
      N, M = LI()
      X = LI()
      Y = LI()
      distX = [0] * N
      distY = [0] * M
      for i in range(N - 1):
          distX[i + 1] = X[i + 1] - X[i]
      for i in range(M - 1):
          distY[i + 1] = Y[i + 1] - Y[i]
      numX = [0] * N
      numY = [0] * M
      for i in range(N):
          numX[i] = i * (N - i)
      for i in range(M):
          numY[i] = i * (M - i)
      LX = 0
      LY = 0
      for i in range(N):
          LX += distX[i] * numX[i]
          LX %= mod
      for i in range(M):
          LY += distY[i] * numY[i]
          LY %= mod
      #    print(numX,distX); print(numY,distY)
      ans = (LX * LY) % mod
      print(ans)
      return
  
  
  def examE():
      S = SI()
      T = SI()
      numaS = [0] * (len(S) + 1)
      numaT = [0] * (len(T) + 1)
      for i, s in enumerate(S):
          numaS[i + 1] = numaS[i]
          if s == "A":
              numaS[i + 1] += 1
      for i, s in enumerate(T):
          numaT[i + 1] = numaT[i]
          if s == "A":
              numaT[i + 1] += 1
      #    print(numaS); print(numaT)
      Q = I()
      ans = ["YES"] * Q
      for i in range(Q):
          a, b, c, d = LI()
          curaS = numaS[b] - numaS[a - 1]
          curbS = (b - a) - curaS + 1
          curaT = numaT[d] - numaT[c - 1]
          curbT = (d - c) - curaT + 1
          print(curaS, curbS, curaT, curbT)
          if (curaS % 3 + (curaS + curbS) % 3) % 3 != (
              curaT % 3 + (curaT + curbT) % 3
          ) % 3:
              #            if (curbS % 3 + (curaS + curbS) % 3) % 3 != (curbT % 3 + (curaT + curbT) % 3) % 3:
              ans[i] = "NO"
      for v in ans:
          print(v)
      return
  
  
  import sys, copy, bisect, itertools, heapq, math
  from heapq import heappop, heappush, heapify
  from collections import Counter, defaultdict, deque
  
  
  def I():
      return int(sys.stdin.readline())
  
  
  def LI():
      return list(map(int, sys.stdin.readline().split()))
  
  
  def LSI():
      return list(map(str, sys.stdin.readline().split()))
  
  
  def LS():
      return sys.stdin.readline().split()
  
  
  def SI():
      return sys.stdin.readline().strip()
  
  
  global mod, mod2, inf, alphabet
  mod = 10**9 + 7
  mod2 = 998244353
  inf = 10**18
  alphabet = [chr(ord("a") + i) for i in range(26)]
  
  if __name__ == "__main__":
      examE()
  
problem_description: Statement
  
  Let us consider the following operations on a string consisting of `A` and
  `B`:
  
    1. Select a character in a string. If it is `A`, replace it with `BB`. If it is `B`, replace with `AA`.
    2. Select a substring that is equal to either `AAA` or `BBB`, and delete it from the string.
  
  For example, if the first operation is performed on `ABA` and the first
  character is selected, the string becomes `BBBA`. If the second operation is
  performed on `BBBAAAA` and the fourth through sixth characters are selected,
  the string becomes `BBBA`.
  
  These operations can be performed any number of times, in any order.
  
  You are given two string S and T, and q queries a_i, b_i, c_i, d_i. For each
  query, determine whether S_{a_i} S_{{a_i}+1} ... S_{b_i}, a substring of S,
  can be made into T_{c_i} T_{{c_i}+1} ... T_{d_i}, a substring of T.
samples: [{"input": "BBBAAAABA\n    BBBBA\n    4\n    7 9 2 5\n    7 9 1 4\n    1 7 2 5\n    1 7 2 4", "output": "YES\n    NO\n    YES\n    NO\n    \n\nThe first query asks whether the string `ABA` can be made into `BBBA`. As\nexplained in the problem statement, it can be done by the first operation.\n\nThe second query asks whether `ABA` can be made into `BBBB`, and the fourth\nquery asks whether `BBBAAAA` can be made into `BBB`. Neither is possible.\n\nThe third query asks whether the string `BBBAAAA` can be made into `BBBA`. As\nexplained in the problem statement, it can be done by the second operation.\n\n* * *"}, {"input": "AAAAABBBBAAABBBBAAAA\n    BBBBAAABBBBBBAAAAABB\n    10\n    2 15 2 13\n    2 13 6 16\n    1 13 2 20\n    4 20 3 20\n    1 18 9 19\n    2 14 1 11\n    3 20 3 15\n    6 16 1 17\n    4 18 8 20\n    7 20 3 14", "output": "YES\n    YES\n    YES\n    YES\n    YES\n    YES\n    NO\n    NO\n    NO\n    NO"}]