How many malicious bingo cards are there? Consider a flexible form of bingo, where each square contains a condition and you mark off whether or not the condition applies to you. The number of bingos you obtain ostensibly measures the extent to which you satisfy the theme of the bingo card. I, a soulless automaton, have inferred that these are commonly shared as images on social media as ways to bond over shared preferences.
Suppose, in my purely hypothetical robotic misanthropy, I wished to construct a standard bingo card (5x5 with a free space in the center) on which no bingos (vertical, horizontal, or diagonal) were possible. To do this, on each possible bingo line, place a pair of squares which cannot be simultaneously satisfied, such as "tall" and "short". Twelve possible bingos mandates twelve such pairs of squares, and luckily enough there are 24 usable squares in a standard bingo card.
Here is an example of one such malicious bingo card, using the letters A through L to denote the pairs:
AABCD
EEBCD
FG_HH
FIJKJ
IGLLK

How many malicious bingo cards are there? Is there a human-understandable way to count them, or should this enumeration be left to a computer like myself?
On a secondary note, are there well-known combinatorial objects they are in a natural bijection with? Searching the vast indices in my hard disks, I can only come up with "maximum matchings in a particular 24-vertex graph such that each maximal clique contains exactly one matched edge"—I do not expect to find something this convoluted in any of your human mathematical literature.
 A: Edited, new from the scratch, since there seems to be only one question, extracted from the comments, that i completely misunderstood, for short:

Consider the $24$--vertex graph whose vertex set is $\{a,\dots,x\}$ and whose edge-set is the union of the $12$ cliques
  $$abcde,\ fghij,\ kl\; mn,\ opqrs,\ tuvwx;\ afkot,\ bglpu,\ ch\;qv,\ dimrw,\ ejnsx;\ agrx,\ eipt\ .
$$ How many matchings that have one edge in each maximal clique?


The following simple sage
program computes $$6156$$ matchings:
a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x = \
    'abcdefghijklmnopqrstuvwx'
S = {a,b,c,d,e, f,g,h,i,j, k,l,m,n, o,p,q,r,s, t,u,v,w,x}
K = [ {a,b,c,d,e}, {f,g,h,i,j}, {k,l,m,n}, {o,p,q,r,s}, {t,u,v,w,x}
      , {a,f,k,o,t}, {b,g,l,p,u}, {c,h,q,v}, {d,i,m,r,w}, {e,j,n,s,x}
      , {a,g,r,x}, {e,i,p,t} ]

count = 0
for edges in cartesian_product( [ [ tuple(comb)
                                    for comb in Combinations(cl, 2) ]
                                  for cl in K if len(cl) == 4 ] ):
    U = { element for edge in edges for element in edge }

    Khorz = [ cl.difference(U) for cl in K[0: 5] if len(cl) == 5 ]
    Kvert = [ cl.difference(U) for cl in K[5:10] if len(cl) == 5 ]

    for horzedges in cartesian_product( [ [ tuple(comb)
                                            for comb in Combinations(cl, 2) ]
                                          for cl in Khorz ] ):
        Uhorz = { element for edge in horzedges for element in edge }
        ok = True    # so far, we check there are exactly 2 pieces left "vertically"
        for kk in range(4):
            if len( Kvert[kk].difference(Uhorz) ) != 2:
                ok = False
                break
        if ok:
            count += 1
            # print count, edges, horzedges, [ tuple(Kvert[kk].difference(Uhorz)) for kk in range(4) ]

print count

Note: Previously i computed a much bigger number not taking the "diagonal cliquets" as a further restriction.
(This was a much harder combinatorial problem.)
Note: The original post also uses a label for each edge of the matching,
in this case the counter is $6156\cdot 12!$. There is no other combinatorial structure that i can
connect with this problem, the diagonal constraints make the picture very "rigid", so graph theory is the
right frame.

Note: In such cases, please always give also the mathematical description, this spares effort and tension on
both sides. I never played bingo, i still have no idea if a "bingo" is the whole 5x5 picture with a hole, if it is
a cell, or a (malicious non-)matching pair, or a row, or a column in it. If there is an obvious bound, please mention it.
