// Complete the freqQuery function below.
    static List<Integer> freqQuery(List<List<Integer>> queries) {
        HashMap<Integer, Integer> valueCount = new HashMap<>();
        HashMap<Integer, Integer> freqCount = new HashMap<>();
        List<Integer> results = new ArrayList<>();
        
        int operation = 0;
        int value = 0;

        for (List<Integer> query : queries) {
            operation = query.get(0);
            value = query.get(1);

            if (operation == 1) {
                // Addding an element
                int currentCount = valueCount.getOrDefault(value, 0);
                int newCount = currentCount + 1;
                
                // Update the count for the value
                valueCount.put(value, newCount);
                // Update the frequency of the new count
                freqCount.put(newCount, 
                    freqCount.getOrDefault(newCount, 0) + 1);
                // Update the frequency of the previous count
                if(currentCount > 0){
                    freqCount.put(currentCount, freqCount.get(currentCount) - 1);
                }
            } else if (operation == 2) {
                // Removing an element
                if (valueCount.containsKey(value) && valueCount.get(value) > 0) {
                    int currentCount = valueCount.get(value);
                    // Decrease the count for the value
                    valueCount.put(value, currentCount - 1);
                    // Update the frequency of the current count
                    freqCount.put(currentCount, freqCount.get(currentCount) - 1);
                    // Update the frequency of the previous count
                    if(currentCount > 1){
                        freqCount.put(currentCount - 1, freqCount.getOrDefault(currentCount - 1, 0) + 1);
                    }
                }
            } else if (operation == 3) {
                // Check if the freqCount contains the value
                if (freqCount.getOrDefault(value, 0) > 0) {
                    results.add(1);
                } else {
                    results.add(0);
                }
            }
        }
    return results;
}

function freqQuery(queries) {
  let map = new Map()
  const result = []
  for (let [op, num] of queries) {
    switch (op) {
      case 1: { map.set(num, map.has(num) ? map.get(num) + 1 : 1) } break
      case 2: {
        if (map.has(num)) {
          if (map.get(num) > 1) map.set(num, map.get(num) - 1)
          else map.delete(num)
        }
      } break
      case 3: { result.push(Array.from(map.values()).includes(num) ? 1 : 0) }
    }
  }
  return result
}

function freqQuery(queries) {
    const results = [];
    const counterMap = new Map();
    for (const q of queries) {
        const op = q[0];
        const val = q[1];
        const curCount = counterMap.get(val) || 0;
        switch (op) {
            case 1:
                counterMap.set(val, curCount + 1);
                break;
            case 2:
                if (curCount > 0) {
                    counterMap.set(val, curCount - 1);
                }
                break;
            case 3:
                const isPresent = Array.from(counterMap.values()).some(v => v === val);
                const retVal = isPresent ? 1 : 0;
                results.push(retVal);
                console.log(retVal);
                break;
        }
    }
    return results;
}

function freqQuery(queries) {
  let res = []
  let m = new Map()
  for (const [op,el] of queries) {
    const curEl = m.get(el)
    switch (op) {
      case 1:
        m.set(el, (curEl||0)+1)
        break;
        case 2:
          curEl?m.set(el,curEl-1):null
          if(curEl-1 === 0) m.delete(el)
        break;
        case 3:
        const newEl = [...m.values()].includes(el)?1:0
        res.push(newEl)
        break;
    }
  }
  return res
}