func freqQuery(queries: [[Int]]) -> [Int] {
    var numbers = [Int: Int]()
    var freq = [Int: Int]()
    var result = [Int]()
    for query in queries {
        let command = query[0]
        let value = query[1]
        
        if command == 1 {
            if let oldCount = numbers[value] {
                let newCount = oldCount + 1
                freq[oldCount] = (freq[oldCount] ?? 0) - 1
                freq[newCount] = (freq[newCount] ?? 0) + 1
                numbers[value] = newCount
            } else {
                freq[1] = (freq[1] ?? 0) + 1
                numbers[value] = 1
            }
            
        } else if command == 2 {
            if let oldCount = numbers[value] {
                let newCount = oldCount - 1
                freq[oldCount] = (freq[oldCount] ?? 0) - 1    
                freq[newCount] = (freq[newCount] ?? 0) + 1
                if newCount == 0 {
                    numbers[value] = nil
                } else {
                    numbers[value] = newCount
                }
            }
        } else if command == 3 {
            if let check = freq[value], check > 0 {
                result.append(1)
            } else {
                result.append(0)
            }
        }
    }
    return result
}

vector<int> freqQuery(vector<vector<int>> queries) {
    vector<int> resultFreq;
    unordered_map<int,int> subFinal;

    bool check;

    // Open the vector
    for(const auto& q: queries){
        //insert
        if(q[0] == 1)
            subFinal[q[1]]++;
	
        // decrement
        if(q[0] == 2){
            if(q[q[1]] > 0)
                subFinal[q[1]]--;
            if(q[q[1]] == 0)
                subFinal.erase(q[1]);
            
        }
        // find
        if(q[0] == 3){
            check = true;
            for(const auto& [key, val] : subFinal){
                if(val == q[1]){
                    check = false;
                    break;
                }
            }
            if(check == false)
                resultFreq.push_back(1);
            else
                resultFreq.push_back(0);
        }
    }

    return resultFreq;
}

def freqQuery(queries):
    num_freq = defaultdict(int)
    freq_freq = defaultdict(int)
    
    ans = []
    for query in queries:
        if query[0] == 1:
            # the freq of this number plus 1
            # the freq of this freq also plus 1
            # remove the old frequency since the freq of this number has increased
            if query[1] in num_freq:
                old_freq = num_freq[query[1]]
                freq_freq[old_freq] -= 1
                if freq_freq[old_freq] == 0:
                    freq_freq.pop(old_freq)
                
            num_freq[query[1]] += 1
            freq_freq[num_freq[query[1]]] += 1
            
        elif query[0] == 2:
            if query[1] in num_freq:
                cur_freq = num_freq[query[1]]
                num_freq[query[1]] -= 1
                if num_freq[query[1]] == 0:
                    num_freq.pop(query[1])
                    
                # there is no 0 freq in the freq_freq dict
                freq_freq[cur_freq] -= 1
                if freq_freq[cur_freq] == 0:
                    freq_freq.pop(cur_freq)
                    
                if cur_freq > 1:
                    freq_freq[cur_freq-1] += 1
                    
        elif query[0] == 3:
            if query[1] in freq_freq:
                ans.append(1)
            else:
                ans.append(0)
    return ans

# Complete the freqQuery function below.
def freqQuery(queries):
    freq_count={}
    output=[]
    for q in queries:
        command = q[0]
        value = q[1]
        if command == 1: #insert
            if value not in freq_count.keys():
                freq_count[value] = 1
            else:
                freq_count[value] += 1
        if command == 2: #remove
            if value in freq_count.keys():
                if freq_count[value] > 0:
                   freq_count[value] -= 1
        if command == 3: # check freq
            has_freq=0
            if value in freq_count.values():
                has_freq=1
            output.append(has_freq)
            
    return output

function freqQuery(queries) {
    const count = []
    const resultMap = new Map()

    queries.forEach(([operation, value]) => {
        switch (operation) {
            case 1: {
                return resultMap.set(value, (resultMap.get(value) || 0) + 1)
            }
            case 2: {
                return resultMap.get(value) && resultMap.set(value, resultMap.get(value) - 1) 
            }
            case 3: {
                const values = [...resultMap.values()];
                    if (values.indexOf(value) > -1) {
                        count.push(1);
                    } else {
                        count.push(0);
                    }
                }
        }
    })

    return count
}