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

#define HASH_SIZE 100000

typedef struct HashNode {
    int mask;
    struct HashNode* next;
} HashNode;

typedef struct {
    HashNode* buckets[HASH_SIZE];
} HashSet;

int hash(int mask) {
    return mask % HASH_SIZE;
}

void insertHash(HashSet* set, int mask) {
    int idx = hash(mask);
    HashNode* node = malloc(sizeof(HashNode));
    node->mask = mask;
    node->next = set->buckets[idx];
    set->buckets[idx] = node;
}

bool containsHash(HashSet* set, int mask) {
    int idx = hash(mask);
    HashNode* curr = set->buckets[idx];
    while (curr) {
        if (curr->mask == mask) return true;
        curr = curr->next;
    }
    return false;
}

int wordToBitmask(const char* word) {
    int mask = 0;
    for (int i = 0; word[i]; i++) {
        mask |= 1 << (word[i] - 'a');
    }
    return mask;
}

int wordCount(char** startWords, int startWordsSize, char** targetWords, int targetWordsSize) {
    HashSet startMasks = {0};
    
    // Convert all start words to bitmasks
    for (int i = 0; i < startWordsSize; i++) {
        insertHash(&startMasks, wordToBitmask(startWords[i]));
    }
    
    int count = 0;
    for (int i = 0; i < targetWordsSize; i++) {
        int targetMask = wordToBitmask(targetWords[i]);
        
        // Try removing each letter from target
        bool found = false;
        for (int j = 0; j < 26; j++) {
            if (targetMask & (1 << j)) { // If this letter exists in target
                // Remove this letter to get potential start word mask
                int startCandidate = targetMask & ~(1 << j);
                if (containsHash(&startMasks, startCandidate)) {
                    found = true;
                    break;
                }
            }
        }
        if (found) count++;
    }
    
    return count;
}