#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXN 8000
#define QUEUE_SIZE 20000

struct State {
    int pos, canGoBack, jumps;
};

int forbidden_arr[MAXN];
int visited[MAXN][2];

int minimumJumps(int* forbidden, int forbiddenSize, int a, int b, int x) {
    memset(forbidden_arr, 0, sizeof(forbidden_arr));
    memset(visited, 0, sizeof(visited));
    
    int maxForbidden = 0;
    for (int i = 0; i < forbiddenSize; i++) {
        if (forbidden[i] < MAXN) {
            forbidden_arr[forbidden[i]] = 1;
        }
        if (forbidden[i] > maxForbidden) {
            maxForbidden = forbidden[i];
        }
    }
    
    struct State queue[QUEUE_SIZE];
    int front = 0, rear = 0;
    
    queue[rear++] = (struct State){0, 1, 0};
    visited[0][1] = 1;
    
    int maxPos = (x + b > maxForbidden ? x + b : maxForbidden) + a + b;
    if (maxPos >= MAXN) maxPos = MAXN - 1;
    
    while (front < rear) {
        struct State curr = queue[front++];
        
        if (curr.pos == x) return curr.jumps;
        
        // Forward jump
        int nextPos = curr.pos + a;
        if (nextPos <= maxPos && !forbidden_arr[nextPos] && !visited[nextPos][1]) {
            visited[nextPos][1] = 1;
            queue[rear++] = (struct State){nextPos, 1, curr.jumps + 1};
        }
        
        // Backward jump
        if (curr.canGoBack) {
            nextPos = curr.pos - b;
            if (nextPos >= 0 && !forbidden_arr[nextPos] && !visited[nextPos][0]) {
                visited[nextPos][0] = 1;
                queue[rear++] = (struct State){nextPos, 0, curr.jumps + 1};
            }
        }
    }
    
    return -1;
}