#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <map>
#include <deque>

using namespace std;

typedef vector<int> VI;
typedef long long LL;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;

#define FOR(x, b, e) for (int x = b; x <= (e); ++x)
#define FORD(x, b, e) for (int x = b; x >= (e); --x)
#define REP(x, n) for (int x = 0; x < (n); ++x)
#define VAR(v, n) __typeof(n) v = (n)
#define ALL(c) (c).begin(), (c).end()
#define SIZE(x) ((int)(x).size())
#define FOREACH(i, c) for (VAR(i, (c).begin()); i != (c).end(); ++i)
#define PB push_back
#define PF push_front
#define MP make_pair
#define ST first
#define ND second

// Stała INF jest wykorzystywana jako reprezentacja nieskończoności. Ma ona
// wartość 1000000001, a nie 2147483647 (największa wartość typu int) ze
// względu na dwa fakty - prosty zapis, oraz brak przepełnienia wartości zmiennej
// w przypadku dodawania dwóch nieskończoności do siebie
// ((int) 2147483647 + (int) 2147483647 = -2).
const int INF = 1000000001;

// Stała EPS jest używana w wielu algorytmach geometrycznych do porównywania
// wartości bliskich zera (w zadaniach tego typu pojawia się wiele problemów
// związanych z błędami zaokrągleń)

const double EPS = 10e-9;

template <typename Container>
void pprint(const Container &c)
{
    std::cout << "[";
    for (auto it = c.begin(); it != c.end(); /* no increment here */)
    {
        std::cout << *it;
        if (++it != c.end())
            std::cout << ", "; // Increment here
    }
    std::cout << "]"
              << "\n";
}

template <typename K, typename V>
void pprint(const pair<K, V> &c)
{
    cout << "[" << c.ST << ", " << c.ND << "]";
}

struct Box
{
    int lower;
    int greater;
    Box(int _l, int _g) 
    {
        if (_l > _g)
        {
            lower = _g;
            greater = _l;
        }
        else {
            lower = _l;
            greater = _g;
        }
    }
};

ostream& operator<<(ostream& ostr, const Box &box) 
{
    ostr << box.lower << " " << box.greater;
    return ostr;
}

struct Move_line
{
    int used_box;
    int count_boxes;
    int taken;
    int left;
};

const Box empty_box = Box(0, 0);
const deque<Box> no_space_left;
const Move_line move_line_failed = Move_line{-1, -1, -1, -1};

int max_box_to_use(const VI& boxes, int dimmension)
{
    int t = -1;
    for (int i=SIZE(boxes)-1; i>=0; i--)
    {
        if (boxes[i] <= dimmension) {
            t = boxes[i];
            break;
        }
    }
    return t;
}

// used box, how many times to cover dimmension, what left
Move_line hang_partial_line(const VI &boxes, int dimmension, int use_box)
{
    int left = dimmension % use_box;
    int taken = dimmension / use_box;
    int taken_space = dimmension - left;

    return Move_line{
        .used_box = use_box, 
        .count_boxes = taken,
        .taken = taken_space,
        .left = left
    };
}

// used box, how many times to cover dimmension, what left
long long hang(const VI &boxes, const Box &box)
{    
    if (box.lower == 0 || box.greater == 0)
    {
        return 0;
    }

    int box_for_lower = max_box_to_use(boxes, box.lower);
    if (box_for_lower == -1) 
    {
        return -1;
    }

    Move_line move_greater = hang_partial_line(boxes, box.greater, box_for_lower);
    if (move_greater.count_boxes == -1) 
    {
        return -1;
    }
    
    Move_line move_lower = hang_partial_line(boxes, box.lower, box_for_lower);
    if (move_lower.count_boxes == -1) 
    {
        return -1;
    }

    long long big_box_count = 
        static_cast<long long>(move_lower.count_boxes) * 
        static_cast<long long>(move_greater.count_boxes);

    Box big_box = Box{
        move_lower.count_boxes * move_lower.used_box,
        move_greater.count_boxes * move_greater.used_box
    };
    
    Box left_lower(box.greater - big_box.greater, box.lower);
    Box left_greater(box.lower - big_box.lower, big_box.greater);

    long long count_lower_box = hang(boxes, left_lower);
    if (count_lower_box == -1)
    {
        return -1;
    }

    long long count_greater_box = hang(boxes, left_greater);
    if (count_greater_box == -1)
    {
        return -1;
    }

    return big_box_count + count_lower_box + count_greater_box;
}

/**
 * All 2-dimmensions are: lower, greater
 */
int main() 
{
    int lower, greater, n;
    VI boxes;

    cin >> lower;
    cin >> greater;
    cin.ignore();

    if (lower > greater) 
    {
        int t = lower;
        lower = greater;
        greater = t;
    }
    
    cin >> n;
    cin.ignore();

    boxes.reserve(n);
    int t;
    REP(i, n)
    {
        cin >> t;
        boxes.push_back(t);
    }

    cout << hang(boxes, Box(lower, greater));
}