/*************************************************************************
 *                                                                       *
 *                       X Olimpiada Informatyczna                       *
 *                                                                       *
 *   Rozwiązanie zadania: Liczby Przesmyków                              *
 *   Plik:                lic.cpp                                        *
 *   Autor:               Krzysztof Onak                                 *
 *************************************************************************/

#include <iostream>
#include <vector>
#include <string>
#include <utility>
using namespace std;

class DuzaLiczba {
// klasa dużych dodatnich liczb całkowitych
public:

  DuzaLiczba(int malaLiczba = 0) : cyfry(0)
  // konstruktor, inicjacja zwykłą liczbą całkowitą
  {
    // dodajemy kolejne cyfry naszej liczby
    while (malaLiczba != 0) {
      cyfry.push_back(malaLiczba % PODSTAWA);
      malaLiczba /= PODSTAWA;
    }
  }
  
  const DuzaLiczba& operator+=(const DuzaLiczba &skladnik)
  // zwiększenie liczby o podaną wartość
  {
    int przeniesienie = 0;
    int stop = max(cyfry.size(), skladnik.cyfry.size()); // większa z długości
    // zwykłe dodawanie kolejnych cyfr w pętli
    for (int i = 0; i < stop; ++i) {
      przeniesienie += cyfra(i) + skladnik.cyfra(i);
      zmienCyfre(i, przeniesienie % PODSTAWA);
      przeniesienie /= PODSTAWA;
    }
    // sprawdzenie czy nie nastąpiło przepełnienie
    if (przeniesienie != 0) zmienCyfre(stop, przeniesienie);
    return *this;
  }

  const DuzaLiczba& operator-=(const DuzaLiczba &odjemnik)
  // zmiejszenie liczby o podaną wartość;
  // zakładamy, że wynik odejmowania jest nieujemny
  {
    int przeniesienie = 0, stop = cyfry.size();
    // w pętli odejmujemy kolejne cyfry
    for (int i = 0; i < stop; ++i) {
      int roznica = przeniesienie + cyfra(i) - odjemnik.cyfra(i);
      if (roznica < 0) {
        przeniesienie = -1;
	roznica += PODSTAWA;
      } else {
        przeniesienie = 0;
      }
      zmienCyfre(i, roznica);
    }
    // jeśli jakieś początkowe cyfry się wyzerowały,
    // to je usuwamy
    while (!cyfry.empty() && cyfry.back() == 0)
      cyfry.pop_back();
    return *this;
  }
  
  bool operator<(const DuzaLiczba& druga) const
  // porównanie dwóch dużych liczb
  {
    // jeśli druga liczba jest dłuższa, to na pewno jest większa
    if (druga.cyfry.size() > cyfry.size()) return true;
    // w pętli porównujemy kolejne cyfry
    for (int i = cyfry.size() - 1; i >= 0; --i) {
      int a = cyfra(i), b = druga.cyfra(i);
      if (a < b) return true;
      if (a > b) return false;
    }
    // liczby są równe
    return false;
  }
  
private:

  // podstawa systemu, w którym wykonujemy działania
  static const int PODSTAWA = 1024*1024*1024; // = 2^30
  
  // kolejne cyfry liczby w systemie o podstawie PODSTAWA;
  // zakładamy, że najbardziej znacząca cyfra (o ile istnieje)
  // jest różna od zera
  vector<int> cyfry;
  
  int cyfra(int pos) const
  // zwraca podaną cyfrę z reprezentacji lub zero,
  // jeśli cyfra wykracza poza reprezentację
  {
    return (pos < (int)cyfry.size()) ? cyfry[pos] : 0;
  }

  void zmienCyfre(int pos, int wart)
  // jeśli istnieje cyfra o numerze pos w reprezentacji,
  // to jest ona zamieniana na wart,
  // wpp. zakładamy, że powstaje nowa cyfra
  // rozszerzająca dotychczasową reprezentację
  {
    if (pos < (int)cyfry.size())
      cyfry[pos] = wart;
    else
      cyfry.push_back(wart);
  }

};

// przydatne stałe
const DuzaLiczba ZERO(0);
const DuzaLiczba JEDEN(1);

class LiczbyCiagow {
// podaje liczby ciągów o zadanej długości przy ustalonej
// wartości m (maksymalna liczba minusów pod rząd)
public:

  // inicjacja wartością m
  LiczbyCiagow(int mm) : m(mm) {liczby.push_back(JEDEN);}
  
  const DuzaLiczba& operator[](int indeks) const
  // zwraca liczbę ciągów o długości indeks
  {
    // wartości wynikające z umowy
    if (indeks < -1) return ZERO;
    if (indeks == -1) return JEDEN;
    // ewentualne doliczenie brakujących wartości
    for (int i = liczby.size(); i <= indeks; ++i) {
      liczby.push_back(liczby[i - 1]);
      liczby[i] += liczby[i - 1];
      liczby[i] -= (*this)[i - m - 2];
    }
    return liczby[indeks];
  }
  
  // zwraca wartość m
  int podajM() const {return m;}
  
private:
  // liczba m - ograniczenie na liczbę minusów pod rząd
  int m;
  // wektor dotychczas obliczonych wartości
  mutable vector<DuzaLiczba> liczby;
};

void odkoduj(const string &zakodowana, DuzaLiczba &odkodowana,
             const LiczbyCiagow &L)
// odkodowuje ciąg plusów i minusów zakodowana,
// wynik zapisuje w odkodowana,
// korzysta ze struktury podającej liczby ciągów L
{
  int rozmiar = zakodowana.size(), m = L.podajM();
  odkodowana = ZERO;
  // uwzględniamy krótsze ciągi
  for (int i = 1; i < rozmiar; ++i)
    odkodowana += L[i];
  for (int i = 0; i < rozmiar; ++i) {
    // niezmiennik: wynik = odkodowana + (numer ciągu zakodowana[i..rozmiar-1]
    //                                    wśród ciągów tej samej długości)
    int rozmiarPodciagu = rozmiar - i;
    odkodowana -= L[rozmiarPodciagu - m - 2];
    if (zakodowana[i] == '+') odkodowana += L[rozmiarPodciagu - 1];
  }
}

void wypiszZakodowana(const DuzaLiczba &odkodowana, ostream &strumien,
                      const LiczbyCiagow &L)
// koduje liczbe odkodowana,
// wynik zapisuje bezpośrednio w strumieniu strumien,
// korzysta ze struktury podającej liczby ciągów L
{
  DuzaLiczba liczba = odkodowana;
  int m = L.podajM();
  int rozmiar;
  // ustalamy długość ciągu
  for (rozmiar = 1; !(liczba < L[rozmiar]); ++rozmiar)
    liczba -= L[rozmiar];
  // wypisujemy kolejne cyfry
  for (int i = rozmiar; i > 0; --i) {
    // w tej chwili pozostaje wypisać ciąg długości i
    // o numerze liczba wśród ciągów tej długości
    liczba += L[i - m - 2]; // krótsze ciągi psute przez początkowy minus
    // decyzja '+' czy '-'
    if (liczba < L[i - 1]) {
      strumien << '-';
    } else {
      strumien << '+';
      liczba -= L[i - 1];
    }
  }
}

int main()
// główny program
{
  int m1, m2, n;
  cin >> m1 >> m2 >> n;
  LiczbyCiagow ciagiWejsciowe(m1), ciagiWyjsciowe(m2);
  // w pętli przetwarzamy kolejne ciągi wejściowe
  for (int i = 0; i < n; ++i) {
    string staraLiczba;
    // wczytanie ciągu
    cin >> staraLiczba;
    DuzaLiczba odkodowana;
    // odkodowanie
    odkoduj(staraLiczba, odkodowana, ciagiWejsciowe);
    // zakodowanie i zapisanie
    wypiszZakodowana(odkodowana, cout, ciagiWyjsciowe);
    cout << '\n';
  }
}
