
    xKg                     (
   d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl	m
Z
mZmZ ddlmZmZmZmZmZmZmZmZmZ ddlmZ ddlmZ dd	lmZmZ dd
lmZm Z m!Z! d Z"d Z#dZ$dZ%dZ&dZ'dZ(dZ)d Z*e!d        Z+d Z,d Z-d Z.d Z/ ej`                  dd      Z1 G d de2      Z3 G d de2      Z4 G d d e2      Z5d! Z6 ee7      d"        Z8 ee7e
jr                        d#        Z: ee;e
jx                        d$        Z= eej|                  e
jx                  e
j~                        d%        Z@ ed&e
jx                        d'        ZA ed(e
j                         eej                        d)               ZD ed*e
jx                  e
j~                        d+        ZEe!d,        ZF e e
jx                  d-      d.        ZGe!d/        ZH e e
jx                  d0      d1        ZIe!d2        ZJ e e
jx                  d3      d4        ZKe!d5        ZL e e
jx                  d6      d7        ZMe!d8        ZN e e
jx                  d9      d:        ZOd; ZPe!d<        ZQ e e
jx                  d=      d>        ZRd? ZSe!d@        ZT e e
jx                  dA      dB        ZUdC ZVe!dD        ZW e e
jx                  dE      dF        ZX edGe
jx                  e
jr                        dH        ZYdI ZZej                  eSfej                  eYfej                  ePfej                  eVffD ]  \  Z_Z` eZe_e`         eej                         e e
jx                  dJ      dK               Zb eej                         e e
jx                  dL      dM               Zd eej                         e e
jx                  dN      dO               Zf eej                         e e
jx                  dP      dQ               Zhe!dR        Zi e e
jx                  dS      dT        Zje!dU        Zk eej                         e e
jx                  dV      dW               Zm eej                         e e
jx                  dX      dY               Zoe!dZ        Zp eej                        d[        Zr eej                        d\        Zte!d]        Zu eej                        d^        Zw eej                        d_        Zy eej                  e
jx                  e
jx                        d`        Z{ ee
jx                  e
jx                        da        Z|y)bz&
Support for native homogeneous sets.
    N)cached_property)ir)typestypingcgutils)	lower_builtin
lower_castiternext_implimpl_ret_borrowedimpl_ret_new_refimpl_ret_untrackedfor_itercall_lenRefType)	quicksort)slicing)NumbaValueErrorTypingError)overloadoverload_method	intrinsicc                     t        j                  |      }| j                  |      j                         }|j	                  ||      }| j                  |||      S )zx
    Given a set value and type, get its payload structure (as a
    reference, so that mutations are seen by all).
    ref)r   
SetPayloadget_data_type
as_pointerbitcastmake_data_helper)contextbuilderset_typeptrpayload_typeptrtypayloads          X/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/numba/cpython/setobj.pyget_payload_structr(      sU    
 ##H-L!!,/::<Eooc5)G##G\w#GG    c                 l    | j                  t        j                  |            }| j                  |      S )z7
    Return the entry size for the given set type.
    )r   r   SetEntryget_abi_sizeof)r    r"   lltys      r'   get_entry_sizer.   #   s.       !9:D!!$''r)   i      Fc                 ,   | j                   }|j                  t              }|j                  ||fi       }| j	                  ||      } |||f      }t        | ||      }	t        j                  |j                  t              }
|j                  |	||
      S )z.
    Compute the hash of the given value.
    )typing_contextresolve_value_typehashget_call_typeget_functionis_hash_usedr   ConstanttypeFALLBACKselect)r    r!   typvalue	typingctxfntysigfnhis_okfallbacks              r'   get_hash_valuerG   ;   s     &&I''-D


Y
3C			dC	(B
7UHA'1-E{{1668,H>>%H--r)   c                 h    fd}| j                  t              }|j                  | fi       }||fS )Nc                 &    t        | ||d         S Nr   )rG   )r    r!   r>   argsr?   s       r'   implz'_get_hash_value_intrinsic.<locals>.implL   s    gwtAw??r)   )r5   r6   r7   )r@   r?   rL   rA   rB   s    `   r'   _get_hash_value_intrinsicrM   J   s9    @''-D


Y"
5C9r)   c                 p    t        j                  |j                  t              }|j	                  d||      S )z8
    Whether the hash value denotes an empty entry.
    ==)r   r:   r;   EMPTYicmp_unsigned)r    r!   rD   emptys       r'   is_hash_emptyrS   S   s-     KK&E  q%00r)   c                 p    t        j                  |j                  t              }|j	                  d||      S )z9
    Whether the hash value denotes a deleted entry.
    rO   r   r:   r;   DELETEDrQ   r    r!   rD   deleteds       r'   is_hash_deletedrY   Z   s-     kk!&&'*G  q'22r)   c                 p    t        j                  |j                  t              }|j	                  d||      S )z9
    Whether the hash value denotes an active entry.
    <rU   rW   s       r'   r9   r9   a   s-    
 kk!&&'*G  a11r)   c            	         t        | D cg c]  }t        |t        j                         c}      st	        d|        t        | D cg c]  }| d   j
                  |j
                  k(    c}      st	        d|        y c c}w c c}w )Nz All arguments must be Sets, got r   z'All Sets must be of the same type, got )all
isinstancer   Setr   dtype)rK   r>   ss      r'   check_all_setrb   j   s    d;ds
3		*d;<<TFCDD$7$QQ($78CD6JKK 9 < 8s   !B	#BSetLoopindexentrydo_breakc                      e Zd Zd Zed        Zej                  d        Zed        Zej                  d        Zed        Zej                  d        Zed        Z	e	j                  d	        Z	ed
        Z
e
j                  d        Z
ed        Zed        Zd ZddZej                   dd       Zej                   d        Zy)_SetPayloadc                     t        ||||      }|| _        || _        || _        || _        |j                  d      | _        || _        y )Nentries)r(   _context_builder_ty_payload_get_ptr_by_name_entries_ptr)selfr    r!   r"   r#   r&   s         r'   __init__z_SetPayload.__init__w   sG    $WgxE00;	r)   c                 .    | j                   j                  S Nro   maskrs   s    r'   rx   z_SetPayload.mask       }}!!!r)   c                 &    || j                   _        y rv   rw   rs   r?   s     r'   rx   z_SetPayload.mask   s     #r)   c                 .    | j                   j                  S rv   ro   usedry   s    r'   r   z_SetPayload.used   rz   r)   c                 &    || j                   _        y rv   r~   r|   s     r'   r   z_SetPayload.used       "r)   c                 .    | j                   j                  S rv   ro   fillry   s    r'   r   z_SetPayload.fill   rz   r)   c                 &    || j                   _        y rv   r   r|   s     r'   r   z_SetPayload.fill   r   r)   c                 .    | j                   j                  S rv   ro   fingerry   s    r'   r   z_SetPayload.finger   s    }}###r)   c                 &    || j                   _        y rv   r   r|   s     r'   r   z_SetPayload.finger   s    $r)   c                 .    | j                   j                  S rv   ro   dirtyry   s    r'   r   z_SetPayload.dirty   s    }}"""r)   c                 &    || j                   _        y rv   r   r|   s     r'   r   z_SetPayload.dirty   s    #r)   c                     | j                   S )z>
        A pointer to the start of the entries array.
        )rq   ry   s    r'   rk   z_SetPayload.entries   s    
 }}r)   c                     | j                   S )zC
        A pointer to the start of the NRT-allocated area.
        )rr   ry   s    r'   r#   z_SetPayload.ptr   s    
 yyr)   c                     t        j                  | j                  | j                  |      }| j                  j                  | j                  t        j                  | j                        |      }|S )z)
        Get entry number *idx*.
        r   )	r   geprm   rq   rl   r   r   r+   rn   )rs   idx	entry_ptrrf   s       r'   	get_entryz_SetPayload.get_entry   sW     KKt}}cB	..t}}/4~~dhh/G3< / > r)   c                      j                    j                  j                  } j                  } j                  j
                  }j                  }|j                  t        j                        }|j                  |||fi       }	j                  ||	      t        j                  |d      }
t        j                  |d      }t        j                        }t        j                  j!                  |            }r'|j                  d      t        j                        j#                  d      }j#                  d      j#                  d      j#                  d      } fd}t        j$                  t        j                  |t&                    5  j)                  |      } ||       j+                  ||
      }j!                  ||      }j-                  ||       d	d	d	       j/                  |       j1                  |      5  j)                  |      } ||       j)                  |      }j3                  ||      }j+                  |
j5                  ||            }j!                  |j+                  ||            }j-                  ||       j-                  ||       j/                  |       d	d	d	       j1                        5  rXj)                  |      }j)                        }j7                  j9                  d
|      ||      }j-                  ||       j/                  |       d	d	d	       j1                        5  j/                  |       d	d	d	       j;                  |       j=                  t        j>                  d      d      }|jA                  t        jB                         |jA                  t        jD                         |j)                  |      fS # 1 sw Y   #xY w# 1 sw Y   PxY w# 1 sw Y   xY w# 1 sw Y   xY w)ag  
        Lookup the *item* with the given hash values in the entries.

        Return a (found, entry index) tuple:
        - If found is true, <entry index> points to the entry containing
          the item.
        - If found is false, <entry index> points to the empty entry that
          the item can be written to (only if *for_insert* is true)
              r/   zlookup.bodyzlookup.foundzlookup.not_foundz
lookup.endc                    j                  |       }|j                  }j                  j                  d|            5   	|j                  f      }j                  |      5  j                         ddd       ddd       j                  t        |            5  j                         ddd       
rmj                  t        |            5  j                        }j                  j                  d|      | |      }j                  |       ddd       yy# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   yxY w)zO
            Check entry *i* against the value being searched for.
            rO   N)r   r6   if_thenrQ   keybranchrS   rY   loadr=   store)irf   
entry_hasheqjbb_foundbb_not_foundr!   r    eqfn
for_insert
free_indexfree_index_sentinelrD   itemrs   s        r'   check_entryz(_SetPayload._lookup.<locals>.check_entry   s*    NN1%EJ!6!6tQ
!KL 'D%))#45__R(NN8, )	 M w!LM|, N ___Wgz%RSZ0Aw'<'<T1FY'Z'(!-AMM!Z0	 TS  )(	 ML NM
 TSs=   'D<(D0:D<&EAE0D9	5D<<EEENrO   found)#rl   rm   r;   rx   rn   r`   r4   r5   operatorr   r7   r8   r   r:   r   alloca_once_valueand_append_basic_block	for_rangeLINEAR_PROBESr   addr   r   
goto_blocklshrmulr=   rQ   position_at_endphiIntTypeadd_incomingtrue_bit	false_bit)rs   r   rD   r   intp_trx   r`   tyctxrA   rB   onefiveperturbre   bb_bodybb_endr   r   pr   r   r   r   r!   r    r   r   r   s   ````                 @@@@@@@r'   _lookupz_SetPayload._lookup   s    ----yy&&''4  ;##D#.kk&!${{61% ++GQ7))'*1,,q$*?A"&))B- 227<OPJ,,];--n=112DE++L9	1 	18 wFM(JKU#ANAs#AQ%AMM!U# L 	w(U#AN
 W%AQ%ACQ!56AT7;;q!#45AMM!U#MM!W%NN7# )  - LL'LL,NN7#8#8qBU#V#$a)a'NN6" . )NN6" * 	'BJJqM737++X67,,l;gll5)))a LK )(  .- *)s3   6AP'0B6P4?A,QQ'P14P>Q
QNc              #   4  K   | j                   }| j                  }|j                  t        j                        }t        j                  |d      }|j                  | j                  |      }t        j                  |||      5 }| j                  |j                        }t        |||j                        }	|j                  |	      5  t!        |j                  ||j"                        }
|
 ddd       ddd       y# 1 sw Y   xY w# 1 sw Y   yxY ww)zG
        Iterate over the payload's entries.  Yield a SetLoop.
        r   startrd   N)rl   rm   get_value_typer   intpr   r:   r   rx   r   r   r   re   r9   r6   r   rc   rg   )rs   r   r    r!   r   r   size
range_looprf   is_usedloops              r'   _iteratez_SetPayload._iterate7  s     
 ----''

3kk&!${{499c*wE:jNN:#3#34E"7GUZZ@G)Z%5%5U(2(;(;=
 * ;: *) ;:s7   BDAD'D /D7	D D		DDDc              #   T  K   | j                   }| j                  }|j                  t        j                        }t        j                  |d      }t        j                  |d      }| j                  }|j                  d      }|j                  d      }t        j                  || j                        }	|j                  |       |j                  |      5  |j                  |	      }
|j                  ||j!                  |
|            }
|j#                  |
|	       | j%                  |
      }t'        |||j(                        }|j+                  |||       ddd       |j-                  |       |j                  |	      }
|
| _        | j%                  |
       y# 1 sw Y   FxY ww)z
        Yield a random entry from the payload.  Caller must ensure the
        set isn't empty, otherwise the function won't end.
        r   r   next_entry_bodynext_entry_endN)rl   rm   r   r   r   r   r:   rx   r   r   r   r   r   r   r   r   r   r   r   r9   r6   cbranchr   )rs   r    r!   r   zeror   rx   r   r   re   r   rf   r   s                r'   _next_entryz_SetPayload._next_entryK  sU     ----''

3{{61%kk&!$yy
 ,,->?++,<=))'4;;?w(U#AT7;;q##67AMM!U#NN1%E"7GUZZ@GOOGVW5 ) 	' LLnnQ )(s    CF(BFAF(F%!F(Frv   )__name__
__module____qualname__rt   propertyrx   setterr   r   r   r   rk   r#   r   r   
contextlibcontextmanagerr   r    r)   r'   ri   ri   u   sK    " " 
[[# # " " 
[[# # " " 
[[# # $ $ ]]% % # # \\$ $    t*l  & %  % r)   ri   c                      e Zd Zd Zed        Zed        Zed        Zed        Zed        Z	e	j                  d        Z	d Zd	 Zd+d
Zd,dZd,dZd+dZd+dZd+dZd Zd Zd Zd Zd Zd Zd Zd Zd Zd-dZd Zd Zed.d       Z ed.d       Z!ed        Z"ed         Z#d! Z$d" Z%d# Z&d$ Z'd-d%Z(d& Z)d' Z*d( Z+d) Z,d* Z-y)/SetInstancec                     || _         || _        || _        t        ||      | _        |j                  |||      | _        y rv   )rl   rm   rn   r.   
_entrysizemake_helper_set)rs   r    r!   r"   set_vals        r'   rt   zSetInstance.__init__v  s;    ((;''7C	r)   c                 .    | j                   j                  S rv   )rn   r`   ry   s    r'   r`   zSetInstance.dtype}  s    xx~~r)   c                     | j                   }| j                  }| j                   j                  j                  || j                        }t        ||| j                  |      S )z/
        The _SetPayload for this set.
        )rl   rm   nrtmeminfo_datameminfori   rn   )rs   r    r!   r#   s       r'   r&   zSetInstance.payload  sK     ----mm,,WdllC7GTXXs;;r)   c                 6    | j                   j                         S rv   )r   	_getvaluery   s    r'   r?   zSetInstance.value  s    yy""$$r)   c                 .    | j                   j                  S rv   )r   r   ry   s    r'   r   zSetInstance.meminfo  s    yy   r)   c                 .    | j                   j                  S rv   r   parentry   s    r'   r   zSetInstance.parent  s    yyr)   c                 &    || j                   _        y rv   r   r|   s     r'   r   zSetInstance.parent  s     		r)   c                 .    | j                   j                  S )z<
        Return the number of elements in the size.
        )r&   r   ry   s    r'   get_sizezSetInstance.get_size  s     ||   r)   c                     | j                   j                  r2|rt        j                  nt        j                  | j
                  _        y y rv   )rn   	reflectedr   r   r   r&   r   rs   vals     r'   	set_dirtyzSetInstance.set_dirty  s0    8858!1!1g>O>ODLL r)   c                    | j                   }| j                  }|j                  }||_        | j                  |       ||_        |j
                  }	t        j                  |	j                  d      }
|j                  |	|
      x}	|_        |j                  t        |||      d      5  |j                  |j                  |
      |_        d d d        |r| j                  |	       | j                  d       y # 1 sw Y   .xY w)Nr   Tlikely)rl   rm   r6   incref_valuer   r   r   r:   r;   r   r   rS   r   upsizer   )rs   r&   rf   r   rD   	do_resizer    r!   old_hashr   r   s              r'   
_add_entryzSetInstance._add_entry  s    ----::
$	||kk$))Q'%kk$44w|__]7GXF$(  *";;w||S9GL* KKt* *s   '"C66C?c                    | j                   }| j                  }|j                  ||d      \  }}	|j                  |      }
|j	                  |
      5  |j                  |	      }|j                  }||_        |r| j                  |       ||_        |j                  }t        j                  |j                  d      }|j                  ||      x}|_	        |j	                  t        |||      d      5  |j                  |j                  |      |_        d d d        |r| j!                  |       | j#                  d       d d d        y # 1 sw Y   6xY w# 1 sw Y   y xY w)NTr   r   r   )rl   rm   r   not_r   r   r6   r   r   r   r   r:   r;   r   rS   r   r   r   )rs   r&   r   rD   r   	do_increfr    r!   r   r   	not_foundrf   r   r   r   s                  r'   _add_keyzSetInstance._add_key  s%   ----??4t?<qLL'	__Y'%%a(EzzHEJ!!$'EI<<D++dii+C")++dC"88D7<w!J(, ! .&{{7<<=. D!NN4 ' ('. . ('s%   B"E4"E,EE	EE c                    t        j                  |j                  j                  t              |_        |r| j                  |j                         |j                  }t        j                  |j                  d      }| j                  j                  ||      x}|_        |r| j                  |       | j                  d       y )Nr   T)r   r:   r6   r;   rV   decref_valuer   r   rm   subdownsizer   )rs   r&   rf   r   	do_decrefr   r   s          r'   _remove_entryzSetInstance._remove_entry  s    [[':
eii(||kk$))Q'"mm//c::w|MM$tr)   c                     | j                   }| j                  }|j                  ||      \  }}|j                  |      5  |j	                  |      }	| j                  ||	|       d d d        |S # 1 sw Y   |S xY wrv   )rl   rm   r   r   r   r
  )
rs   r&   r   rD   r   r    r!   r   r   rf   s
             r'   _remove_keyzSetInstance._remove_key  so    ----??4+q__U#%%a(Ewy9 $ 	 $ s   %A..A8c                     | j                   }| j                  }| j                  }t        ||| j                  j
                  |      }| j                  ||||       y rv   )rl   rm   r&   rG   rn   r`   r  )rs   r   r   r    r!   r&   rD   s          r'   r   zSetInstance.add  sG    ----,,7GTXX^^TBgtQ	2r)   c                     | j                   }| j                  }| j                  }| j                  ||||      }| j	                  ||||       y)z`A version of .add for use inside functions following Python calling
        convention.
        N)rl   rm   r&   _pyapi_get_hash_valuer  )rs   pyapir   r   r    r!   r&   rD   s           r'   	add_pyapizSetInstance.add_pyapi  sG     ----,,&&ugwEgtQ	2r)   c                 H   | j                   j                  g}t        j                  }d }|g}t	        j
                  |g| }	|j                  ||	|      \  }
}|j                  |
d      5  |j                  |j                                ddd       |S # 1 sw Y   |S xY w)z=Python API compatible version of `get_hash_value()`.
        c                     t        |       S rv   )rM   )r   s    r'   wrapperz2SetInstance._pyapi_get_hash_value.<locals>.wrapper  s    ,S11r)   Fr   N)
rn   r`   r   r   r   	signaturecall_jit_coder   retget_null_object)rs   r  r    r!   r   argtypesrestyr  rK   rB   is_errorretvals               r'   r  z!SetInstance._pyapi_get_hash_value  s     HHNN#

	2 vu0x0 ..wTB&__Xe_4KK--/0 5  5 s   - BB!c                     | j                   }| j                  }| j                  }t        ||| j                  j
                  |      }|j                  ||      \  }}|S rv   )rl   rm   r&   rG   rn   r`   r   )rs   r   r    r!   r&   rD   r   r   s           r'   containszSetInstance.contains  sN    ----,,7GTXX^^TB??4+qr)   c                     | j                   }| j                  }| j                  }t        ||| j                  j
                  |      }| j                  |||      }|S rv   )rl   rm   r&   rG   rn   r`   r  )rs   r   r    r!   r&   rD   r   s          r'   discardzSetInstance.discard   sN    ----,,7GTXX^^TB  $2r)   c                    | j                   }| j                  }|j                  | j                  j                        }t        j                  ||      }| j                  }|j                         5 }|j                  |j                  |       | j                  ||d       d d d        |j                  |      S # 1 sw Y   xY w)NF)r	  )rl   rm   r   rn   r`   r   alloca_oncer&   r   r   r   r
  r   )rs   r    r!   ltyr   r&   rf   s          r'   popzSetInstance.pop)  s    ----$$TXX^^4!!'3/,,  "eMM%))S)w? #
 ||C   #"s   01B::Cc                     | j                   }| j                  }|j                  t        j                        }t        j                  |t              }| j                  |       | j                  d       y )NT)
rl   rm   r   r   r   r   r:   MINSIZE_replace_payloadr   )rs   r    r!   r   minsizes        r'   clearzSetInstance.clear8  sR    ----''

3++fg.g&tr)   c           	      *   | j                   }| j                  }| j                  }|j                  }|j                  } t        |       ||| j                  d      }|j                  d||      }|j                  |d      5 \  }}	|5  |j                  |      }
|j                  |j                  |
      d      5  |j                  j                  |t        d       ddd       ddd       |	5  | j                  |||      }|j!                  |      }
|j                  |j                  |
      d      5  |j                  j                  |t        d       ddd       |j                  }|j#                         5 }|j$                  }|j'                  ||j(                  |j*                  d       ddd       ddd       ddd       |S # 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   ?xY w# 1 sw Y   CxY w# 1 sw Y   |S xY w)z,
        Return a copy of this set.
        NrO   Tr   F)zcannot copy setr   )rl   rm   r&   r   r   r;   rn   rQ   if_else_copy_payloadr   r  	call_convreturn_user_excMemoryErrorchoose_alloc_size_allocate_payloadr   rf   r  r   r6   )rs   r    r!   r&   r   r   otherno_deleted_entriesif_no_deleted
if_deletedoknentriesother_payloadr   rf   s                  r'   copyzSetInstance.copyA  s    ----,,||||T
7GTXXt<$224tD__/_=*z((1__W\\"%5e_D%%55g{6JL E  11'7DI,,X6__W\\"%5e_D%%55g{6JL E !&%%'4 JJENN=%))UZZ-2 # 4 (  >. % ED  ED
 ('  >. s   H4G;"GG%
H/AG<6"G$$G<<6G02G<:HGGG!	H$G-)G<0G95G<<H	HHc                    | j                   }| j                  }| j                  }|j                  }|j                         5 }|j                  }|j                  |j                  |j                        \  }}	|j                  |j                  |            5  | j                  ||d       ddd       ddd       | j                  |j                         y# 1 sw Y   -xY w# 1 sw Y   1xY w)z9
        In-place intersection with *other* set.
        Fr+  N)rl   rm   r&   r   rf   r   r   r6   r   r  r
  r  r   )
rs   r3  r    r!   r&   r9  r   rf   r   _s
             r'   	intersectzSetInstance.intersecth  s     ----,,4JJE$,,UYY

CHE1e!45""7EU"C 6   	gll#	 65  s%   AC$C,C$C!	C$$C-c                 N   | j                   }| j                  }| j                  }|j                  }|j                         5 }|j                  }| j                  ||j                  |j                  d       ddd       | j                  |j                         y# 1 sw Y   %xY w)z7
        In-place difference with *other* set.
        Fr+  N)
rl   rm   r&   r   rf   r  r   r6   r  r   )rs   r3  r    r!   r&   r9  r   rf   s           r'   
differencezSetInstance.differencez  s~     ----,,##%JJEWeiiuM &
 	gll# &%s   6BB$c           	         | j                   }| j                  }|j                  }|j                         5 }|j                  j
                  }|j                  j                  }| j                  }|j                  ||d      \  }	}
|j                  |
      }|j                  |	      5 \  }}|5  | j                  ||d       ddd       |5  | j                  ||||       ddd       ddd       ddd       | j                  | j                  j                         y# 1 sw Y   ^xY w# 1 sw Y   KxY w# 1 sw Y   OxY w# 1 sw Y   SxY w)zA
        In-place symmetric difference with *other* set.
        Tr   Fr+  N)rl   rm   r&   r   rf   r   r6   r   r   r,  r
  r   r  r   )rs   r3  r    r!   r9  r   r   rD   r&   r   r   rf   	if_commonif_not_commons                 r'   symmetric_differencez SetInstance.symmetric_difference  s    ----##%**..C

AllGsA$?HE1%%a(E'+EI}&&w&G "OOGUC; # ( & 	dll''( Y"] (' &%sT   A2E'D7-D
D7D+!D7)ED($D7+D40D77E 	<EEc           	         | j                   }| j                  }| j                  }|j                  }|rdnd}t        j                  |t        j
                        }|j                  |j                  ||j                  |j                              5 \  }	}
|
5  |j                  t        j                  |       d d d        |	5  |j                         5 }|j                  }|j                  |j                  |j                        \  }}|j!                  |j#                  |            5  |j                  t        j                  |       |j%                          d d d        d d d        d d d        d d d        |j'                  |      S # 1 sw Y   xY w# 1 sw Y   >xY w# 1 sw Y   BxY w# 1 sw Y   FxY w# 1 sw Y   JxY w)Nr[   <=)rl   rm   r&   r   r   r   r,  rQ   r   r   r   r   rf   r   r   r6   r   r  rg   r   )rs   r3  strictr    r!   r&   r9  cmp_opres
if_smaller	if_largerr   rf   r   r<  s                  r'   issubsetzSetInstance.issubset  sP   ----,,D''1A1AB__!!&',,8J8JK(*ig//5  %%'4 JJE,44UYY

KHE1 e)<=g&7&7= > (  ||C    >= ('  sm   F;!F8
F;F/AF#)1F	F#"F/*F;F	F;F F##F,(F//F8	4F;;Gc                   	 | j                   }| j                  | j                  }|j                  }t        j                  t        j
                        		fd}j                  j                  d|j                  |j                              5 \  }}|5   |||       d d d        |5   |||       d d d        d d d        j                  	      S # 1 sw Y   6xY w# 1 sw Y   .xY w# 1 sw Y   2xY w)Nc                 f   | j                         5 }|j                  }|j                  |j                  |j                        \  }}j                  |      5  j                  t        j                         |j                          d d d        d d d        y # 1 sw Y   xY w# 1 sw Y   y xY wrv   )
r   rf   r   r   r6   r   r   r   r   rg   )smallerlargerr   rf   r   r<  r!   rH  s         r'   checkz%SetInstance.isdisjoint.<locals>.check  s~    !!#t

!>>%))UZZ@q__U+MM'"3"3S9MMO , $# ,+ $#s$   AB'1B
B'B$	 B''B0>)
rl   rm   r&   r   r   r   r,  rQ   r   r   )
rs   r3  r    r&   r9  rP  rJ  	otherwiser!   rH  s
           @@r'   
isdisjointzSetInstance.isdisjoint  s    ----,,''1A1AB	$ __!!#w||]5G5GH')YmW-  g}-  ||C     s<   C0
C#
C0-
C$7C0C!	C0$C-	)C00C9c           	         | j                   }| j                  }| j                  }|j                  }t        j                  |t        j
                        }|j                  |j                  d|j                  |j                              5 \  }}|5  |j                         5 }	|	j                  }
|j                  |
j                  |
j                        \  }}|j                  |j                  |            5  |j!                  t        j"                  |       |	j%                          d d d        d d d        d d d        |5  |j!                  t        j"                  |       d d d        d d d        |j'                  |      S # 1 sw Y   ]xY w# 1 sw Y   axY w# 1 sw Y   exY w# 1 sw Y   FxY w# 1 sw Y   JxY w)NrO   )rl   rm   r&   r   r   r   r,  rQ   r   r   rf   r   r   r6   r   r  r   r   rg   r   )rs   r3  r    r!   r&   r9  rH  if_same_sizerR  r   rf   r   r<  s                r'   equalszSetInstance.equals  sG   ----,,''1A1AB__!!$m6H6HI*,	%%'4 JJE,44UYY

KHE1 e)<=g&7&7= > (  g//5  ||C   >= ('   sm   F5F"AF81F	)F1F9
F5!F)$F5F
FFFF&	"F5)F2	.F55F>Nc                 ,   |j                  t        j                        }|t        j                  |t
              }n9t        |t              rt        j                  ||      }| j                  |||      } | |||d      }|j                  |      }||fS )z
        Allocate a SetInstance with its storage.
        Return a (ok, instance) tuple where *ok* is a LLVM boolean and
        *instance* is a SetInstance object (the object's contents are
        only valid when *ok* is true).
        N)
r   r   r   r   r:   r&  r^   intr1  r2  )	clsr    r!   r"   nitemsr   r8  rs   r7  s	            r'   allocate_exzSetInstance.allocate_ex  s     ''

3>{{673H&#&VV4,,WgvFH7GXt4##H-4xr)   c                     | j                  ||||      \  }}|j                  |j                  |      d      5  |j                  j	                  |t
        d       ddd       |S # 1 sw Y   |S xY w)z
        Allocate a SetInstance with its storage.  Same as allocate_ex(),
        but return an initialized *instance*.  If allocation failed,
        control is transferred to the caller using the target's current
        call convention.
        Fr   )zcannot allocate setN)r[  r   r  r.  r/  r0  )rY  r    r!   r"   rZ  r7  rs   s          r'   allocatezSetInstance.allocate  sj     ??7GXvFD__W\\"-e_<--g{.FH =  = s   "A&&A0c                      | |||d      }||j                   _        |j                  t        j                        |j                   _        |j                  j                  |||j                         |S )z
        Allocate a new set instance pointing to an existing payload
        (a meminfo pointer).
        Note the parent field has to be filled by the caller.
        N)	r   r   get_constant_nullr   pyobjectr   r   increfr?   )rY  r    r!   r"   r   rs   s         r'   from_meminfozSetInstance.from_meminfo  sZ     7GXt4#		"44U^^D		7Hdjj9r)   c                    |j                   }t        j                  |d      }t        j                  |t              }|j	                  ||      }t        j                  ||      }|j                  d      }	|j                  d      }
|j                  |	       |j                  |	      5  |j                  |      }|j                  d||      }|j                  |d      5  |j                  |
       ddd       |j	                  ||      }|j                  ||       |j                  |	       ddd       |j                  |
       |j                  |      S # 1 sw Y   hxY w# 1 sw Y   7xY w)zT
        Choose a suitable number of entries for the given number of items.
        r   calcsize.bodycalcsize.end>=Fr   N)r;   r   r:   r&  shlr   r   r   r   r   r   rQ   r   r   r   )rY  r    r!   rZ  r   r   r(  min_entriessize_pr   r   r   is_large_enough	next_sizes                 r'   r1  zSetInstance.choose_alloc_size$  s0   
 kk&!$++fg. kk&#.**7G<,,_=++N;w(<<'D%33D$LO?v& @D#.IMM)V,NN7# ) 	'||F## @? )(s$   )8E&!E3=E&E#	E&&E/c           	         | j                   }| j                  }|j                  }t        j                  |d      }t        j                  |d      }| j
                  }|j                  ||      }|j                  |j                  |      }	|j                  d||	      }
|j                  |
d      5  t        j                  ||	      }|j                  d      }|j                  d      }|j                  |       |j                  |      5  |j!                  |      }|j                  ||      }|j#                  ||       |j                  d||      }|j%                  |||       ddd       |j'                  |       |j!                  |      }t(        r|j+                  |d	||	||       | j-                  ||d
       ddd       y# 1 sw Y   cxY w# 1 sw Y   yxY w)zs
        When adding to the set, ensure it is properly sized for the given
        number of used entries.
        r      rf  Fr   rd  re  NzKupsize to %zd items: current size = %zd, min entries = %zd, new size = %zd
zcannot grow set)rl   rm   r;   r   r:   r&   rg  r   rx   rQ   r   r   r   r   r   r   r   r   r   r   DEBUG_ALLOCSprintf_resize)rs   rZ  r    r!   r   r   twor&   rh  r   need_resize
new_size_pr   r   new_sizeis_too_smalls                   r'   r   zSetInstance.upsizeC  s   
 ----kk&!$kk&!$,, kk&#.{{7<<-++D+tD__[_7 227DAJ00AG//?FNN7###G,"<<
3";;x5h
3&44T;Qgv> - ##F+||J/Hw E%t[(D LL(,=>3 87 -, 87s'   1AGAG
(AG
G	GGc           	         | j                   }| j                  }|j                  }t        j                  |d      }t        j                  |d      }t        j                  |t
              }| j                  }|j                  ||      }	|j                  |j                  d|	|      |	|      }	|j                  |	|      }
|j                  |j                  |      }|j                  |j                  d|
|      |j                  d||            }|j                  |d      5  t        j                  ||      }|j!                  d      }|j!                  d	      }|j#                  |       |j%                  |      5  |j'                  |      }|j)                  ||      }|j                  d
|	|      }|j                  |      5  |j#                  |       ddd       |j+                  ||       |j#                  |       ddd       |j-                  |       |j'                  |      }t.        r|j1                  |d|||	|       | j3                  ||d       ddd       y# 1 sw Y   xY w# 1 sw Y   oxY w# 1 sw Y   yxY w)zw
        When removing from the set, ensure it is properly sized for the given
        number of used entries.
        r   rm  rf  rE  r[   Fr   rd  re  rQ  NzMdownsize to %zd items: current size = %zd, min entries = %zd, new size = %zd
zcannot shrink set)rl   rm   r;   r   r:   r&  r&   rg  r=   rQ   r   rx   r   r   r   r   r   r   r   r   r   r   r   rn  ro  rp  )rs   rZ  r    r!   r   r   rq  r(  r&   rh  max_sizer   rr  rs  r   r   rt  ru  s                     r'   r  zSetInstance.downsizeq  s,   
 ----kk&!$kk&!$++fg.,, kk&#.nnW%:%:4g%V%0'; ;;{C0{{7<<-ll!!$$7!!#w57 __[_7 227DAJ00AG//?FNN7###G,"<<
3"<<#6&44S+xP__\2NN6* 3h
3w' - ##F+ ||J/H w E%t[(D LL(,?@A 87 32 -, 87s?   "AI<=AI0I$+I0AI<$I-)I00I9	5I<<Jc                    | j                   }| j                  }|}| j                  |d      }|j                  |j	                  |      d      5  |j
                  j                  |t        |f       ddd       | j                  }|j                         5 }|j                  }	| j                  ||	j                  |	j                  dd       ddd       | j                  |j                         y# 1 sw Y   xY w# 1 sw Y   1xY w)zw
        Resize the payload to the given number of entries.

        CAUTION: *nentries* must be a power of 2!
        TreallocFr   N)r   r  )rl   rm   r2  r   r  r.  r/  r0  r&   r   rf   r  r   r6   _free_payloadr#   )
rs   r&   r8  errmsgr    r!   old_payloadr7  r   rf   s
             r'   rp  zSetInstance._resize  s     ---- ##Hd#;__W\\"-e_<--g{/5i9 = ,,!!#tJJEMM'599ejj$)U  < $
 	;??+ =< $#s   #C27C>2C;>Dc                     | j                   }| j                  }| j                  j                         5 }|j                  }| j                  |j                         ddd       | j                  | j                  j                         | j                  |d      }|j                  |j                  |      d      5  |j                  j                  |t        d       ddd       y# 1 sw Y   xY w# 1 sw Y   yxY w)z
        Replace the payload with a new empty payload with the given number
        of entries.

        CAUTION: *nentries* must be a power of 2!
        NTry  Fr   )zcannot reallocate set)rl   rm   r&   r   rf   r  r   r{  r#   r2  r   r  r.  r/  r0  )rs   r8  r    r!   r   rf   r7  s          r'   r'  zSetInstance._replace_payload  s     ---- \\""$JJEeii( %
 	4<<++,##Hd#;__W\\"-e_<--g{.HJ =< %$ =<s   (C(="C4(C14C=c           
      D   | j                   }| j                  }t        j                  |t        j                        }|j                  t        j                        }t        j                  |d      }t        j                  |d      }|j                  t        j                  | j                              }	|j                  |	      }
| j                  }|
|z  }
t        j                  ||t        j                  ||      t        j                  ||
            \  }}|j!                  |d      5  |j#                  t        j$                  |       ddd       |j!                  |j'                  |      d      5  |rK| j(                  j*                  }|j,                  j/                  |||      }t        j0                  ||      }nm| j3                  ||j4                        }|j,                  j7                  |||j9                  |t        j:                              }t        j0                  ||      }|j=                  |d      5 \  }}|5  |j#                  t        j$                  |       ddd       |5  |s?|| j(                  _        |j?                  t        j@                        | j(                  _!        | jD                  }t        jF                  ||jH                  |d       ||_%        ||_&        ||_'        |jQ                  ||      }||_)        tT        r|jW                  |d	||jH                  |       ddd       ddd       ddd       |j'                  |      S # 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   DxY w# 1 sw Y   HxY w# 1 sw Y   LxY w)
z
        Allocate and initialize payload for the given number of entries.
        If *realloc* is True, the existing meminfo is reused.

        CAUTION: *nentries* must be a power of 2!
        r   r   Fr   NT)r      .allocated %zd bytes for set at %p: mask = %zd
),rl   rm   r   r   r   r   r   r   r   r:   r   r   rn   r,   r   muladd_with_overflowr   r   r   r   r   r   r   meminfo_varsize_alloc_uncheckedis_null	_imp_dtormodule"meminfo_new_varsize_dtor_uncheckedr   	voidptr_tr,  r_  r`  r   r&   memsetr#   r   r   r   r  rx   rn  ro  )rs   r8  rz  r    r!   r7  r   r   r   r$   payload_size
entry_size	allocsizeovfr   r#   alloc_okdtorif_errorif_okr&   new_masks                         r'   r2  zSetInstance._allocate_payload  s    ----&&w0@0@A''

3{{61%kk&!$,,U-=-=dhh-GH--l;__

" !55gx68kk&*6U68kk&,6WY	3 __S_/MM'++R0 0 __W\\"-d_;))++kkAA'BI=F B H #??7C8 ~~gw~~>!++HHYg>O>O(PR"??7G<(- ! /2C8UMM'"3"3R8 ",3		)+2+D+DU^^+T		("llGNN7GKKDI#'GL#'GL%)GN&{{8S9H#+GL#w'X'0'++xI 	/ <H ||BO 0/& XU	/ / <;sb   .!M$9CNN
!M1.
N
8CM>;N
N$M.1M;6N
>NN

N	NNc                 z    | j                   j                  j                  | j                  | j                  |       y)z9
        Free an allocated old payload at *ptr*.
        N)rl   r   meminfo_varsize_freerm   r   )rs   r#   s     r'   r{  zSetInstance._free_payload"  s(     	..t}}dllCPr)   c           
         | j                   }| j                  }t        j                  |t        j                        }|j                  t        j                        }t        j                  |d      }t        j                  |d      }|j                  t        j                  | j                              }|j                  |      }	| j                  }
|	|
z  }	|j                  }|j!                  ||      }|j!                  t        j                  ||	      |j#                  t        j                  ||
      |            }|j%                  |j'                  |      d      5  | j)                  ||j*                        }|j,                  j/                  |||j1                  |t        j2                              }t        j4                  ||      }|j7                  |d      5 \  }}|5  |j9                  t        j:                  |       ddd       |5  || j<                  _        | j@                  }|jB                  |_!        |jD                  |_"        ||_#        ||_        t        jH                  ||jJ                  |jJ                  ||
       |jM                         5 }| jO                  |jP                  jR                         ddd       tT        r|jW                  |d||jX                  |       ddd       ddd       ddd       |j'                  |      S # 1 sw Y   xY w# 1 sw Y   dxY w# 1 sw Y   CxY w# 1 sw Y   GxY w# 1 sw Y   KxY w)z7
        Raw-copy the given payload into self.
        r   r   Tr   FNr  )-rl   rm   r   r   r   r   r   r   r   r:   r   r   rn   r,   r   rx   r   r   r   r   r  r  r   r  r   r  r  r,  r   r   r   r   r&   r   r   r   
raw_memcpyrk   r   r   rf   r   rn  ro  r#   )rs   src_payloadr    r!   r7  r   r   r   r$   r  r  rx   r8  r  r  r   r  r  r  r&   r   s                        r'   r-  zSetInstance._copy_payload(  s    ----&&w0@0@A''

3{{61%kk&!$,,U-=-=dhh-GH--l;__

";;sD)
 KKFL A 'BKK
,K,4!67	 __W\\"-d_;>>'7>>:DkkDDGOOD':K:K$LNGw8H%8<MXuMM'"3"3R8 (/DII%"llG#.#3#3GL#.#3#3GL%)GN#'GL
 &&w'2':':H'13
 %--/4))$**..9 0 $w'X'0'++tE)  9 <D ||B5 X$ 0/! U 98 <;sn   "BM#M )!L

M BL4&L(	-L42M :ML% M (L1-L44L=9M  M		MMc                    t         j                  }|j                  t        j                        }t        j                  t        j                         |||g      }d| j                  j                   }t        j                  |||      }|j                  rd|_        t        j                  |j                               }t        ||| j                  |j                   d         }	|	j#                         5 }
|
j$                  }|j&                  j)                  || j                  j                  |j*                         ddd       |j-                          |S # 1 sw Y   xY w)z Define the dtor for set
        z
.dtor.set.)namelinkonce_odrr   N)r   r  r   r   size_tr   FunctionTypeVoidTypern   r`   get_or_insert_functionis_declarationlinkage	IRBuilderr   ri   rK   r   rf   r   decrefr   ret_void)rs   r    r  	llvoidptrllsize_trA   fnamerC   r!   r&   r   rf   s               r'   r  zSetInstance._imp_dtori  s    %%	((6KKM),

 TXX^^,-++FDuE'BJll2#8#8#:;G!'7DHHbggajIG!!#t

""7DHHNNEIIF $ 	 $#s   7AEE"c                     | j                   j                  j                  | j                  | j                  j
                  |       y)z Incref an element value
        N)rl   r   ra  rm   rn   r`   r   s     r'   r   zSetInstance.incref_value  ,     	  Dr)   c                     | j                   j                  j                  | j                  | j                  j
                  |       y)z Decref an element value
        N)rl   r   r  rm   rn   r`   r   s     r'   r  zSetInstance.decref_value  r  r)   )T)TTr   rv   ).r   r   r   rt   r   r`   r&   r?   r   r   r   r   r   r   r  r
  r  r   r  r  r  r   r$  r)  r:  r=  r?  rC  rK  rS  rV  classmethodr[  r]  rb  r1  r   r  rp  r'  r2  r{  r-  r  r   r  r   r)   r'   r   r   t  sv   D   	< 	< % % ! !     ]]! !!P*!8
3	3$!%N$$$ )0!4!>!0  (     $ $<,?\:Ax,6J.A FQ? B8E
Er)   r   c                   |    e Zd Zd Zed        Zed        Zed        Zed        Z	e	j                  d        Z	d Zy)	SetIterInstancec                    || _         || _        || _        |j                  |||      | _        | j                   j
                  j                  || j                        }t        ||| j                  j                  |      | _
        y rv   )rl   rm   rn   r   _iterr   r   r   ri   	containerro   )rs   r    r!   	iter_typeiter_valr#   s         r'   rt   zSetIterInstance.__init__  si    (()XF
mm,,WdllC#GWdhh6H6H#Nr)   c                    t        |||j                  |      } | |||d       }|j                  t        j                  d      }t        j                  ||      |j                  _        |j                  |j                  _	        |S rJ   )
r   r  get_constantr   r   r   r   r  re   r   )rY  r    r!   r  r   set_instrs   re   s           r'   from_setzSetIterInstance.from_set  sn    w1D1DgN7GY5$$UZZ3"44WeD

%--

r)   c                 6    | j                   j                         S rv   )r  r   ry   s    r'   r?   zSetIterInstance.value  s    zz##%%r)   c                 .    | j                   j                  S rv   )r  r   ry   s    r'   r   zSetIterInstance.meminfo  s    zz!!!r)   c                 `    | j                   j                  | j                  j                        S rv   )rm   r   r  re   ry   s    r'   re   zSetIterInstance.index  s!    }}!!$**"2"233r)   c                 d    | j                   j                  || j                  j                         y rv   )rm   r   r  re   r|   s     r'   re   zSetIterInstance.index  s     E4::#3#34r)   c                    | j                   }| j                  }t        j                  |j                  d      }|j                          |j                  |      5 }|j                  }|j                          |j                  |j                         | j                  j                  |j                   |      | _         |j                          d d d        y # 1 sw Y   y xY w)Nr   r   )re   ro   r   r:   r;   set_exhaustedr   rf   	set_validyield_r   rm   r   rg   )rs   resultre   r&   r   r   rf   s          r'   iternextzSetIterInstance.iternext  s    

--kk%**a(E*dJJEMM%))$**4::s;DJMMO +**s   A3CC N)r   r   r   rt   r  r  r   r?   r   re   r   r  r   r)   r'   r  r    su    O   & & " " 4 4 \\5 5r)   r  c           	         t        |      }t        j                  | |||      }|dkD  rt        j                  ||      }t        j
                  ||      }| j                  t        j                  |      }t        j                  ||      5 }	|j                  t        j                  ||d|	j                              }
|j                  |
       ddd       t        | |||j                        S # 1 sw Y   !xY w)zD
    Build a set of the given type, containing the given items.
    r   N)lenr   r]  r   
pack_arrayr   r  r   r   r   r   r   re   r   r   r?   )r    r!   r"   itemsrZ  instarray	array_ptrcountr   r   s              r'   	build_setr    s     ZF(FCDz ""7E2--gu=	$$UZZ8w.$<<GY4:: NODHHTN / GWh

CC	 /.s   AC..C7c                 x    |j                   }t        j                  | ||      }t        | |||j                        S rv   )return_typer   r]  r   r?   )r    r!   rB   rK   r"   r  s         r'   set_empty_constructorr    s4    H(;DGWh

CCr)   c                    |j                   }|j                  \  }|\  }t        | |||      }t        j	                  | |||      }t        | |||      5 }	|j                  |	j                         | j                  j                  ||j                  |	j                         d d d        t        | |||j                        S # 1 sw Y   !xY wrv   )r  rK   r   r   r]  r   r   r?   r   r  r`   r   )
r    r!   rB   rK   r"   
items_typer  nr  r   s
             r'   set_constructorr    s    H((KJFE 	':u5A(A>D	'7J	6$7HNNDJJ? 
7 GWh

CC	 
7	6s   AC  C	c                 ^    t        | ||j                  d   |d         }|j                         S rJ   )r   rK   r   r    r!   rB   rK   r  s        r'   set_lenr    s*    w!d1g>D==?r)   c                 f    t        | ||j                  d   |d         }|j                  |d         S Nr   r   )r   rK   r  r  s        r'   in_setr    s1    w!d1g>D==a!!r)   getiterc                     t         j                  | ||j                  |d         }t        | ||j                  |j                        S rJ   )r  r  r  r   r?   r  s        r'   getiter_setr    s9    ##GWcootAwODWgs

KKr)   r  c                 b    t        | ||j                  d   |d         }|j                  |       y rJ   )r  rK   r  )r    r!   rB   rK   r  r  s         r'   iternext_listiterr  	  s,     7GSXXa[$q'BDMM&r)   zset.addc                     t        | ||j                  d   |d         }|d   }|j                  |       | j                         S r  )r   rK   r   get_dummy_valuer    r!   rB   rK   r  r   s         r'   set_addr    sA    w!d1g>D7DHHTN""$$r)   c                 <    t        j                  ||      }d }||fS )Nc                     t        | ||j                  d   |d         }|d   }|j                  |       | j                         S r  )r   rK   r   r  r  s         r'   set_discardz!_set_discard.<locals>.set_discard"  sB    7GSXXa[$q'BAwT&&((r)   r   none)r@   ra   r   rB   r  s        r'   _set_discardr    s$    
**Q
C) r)   r   c                     d S )Nc                     t        | |      S rv   )r  ra   r   s     r'   <lambda>z ol_set_discard.<locals>.<lambda>.  s    <40r)   r   r  s     r'   ol_set_discardr  ,  s    00r)   c                 2    |j                  |      }d }||fS )Nc                 b   t        | ||j                  d   |d         }|j                  j                  }|j	                  t        j                  ||      d      5  | j                  j                  |t        d       d d d        |j                         S # 1 sw Y   |j                         S xY w)Nr   Fr   )zset.pop(): empty set)r   rK   r&   r   r   r   r  r.  r/  KeyErrorr$  )r    r!   rB   rK   r  r   s         r'   set_popz_set_pop.<locals>.set_pop5  s    7GSXXa[$q'B||  __W__Wd;E_J--gx,EG K xxz	 K xxzs   "BB.r`   )r@   ra   rB   r  s       r'   _set_popr  1  s     
''!*C <r)   r$  c                     d S )Nc                     t        |       S rv   )r  ra   s    r'   r  zol_set_pop.<locals>.<lambda>C  s    Xa[r)   r   r  s    r'   
ol_set_popr  A  s      r)   c                 <    t        j                  ||      }d }||fS )Nc                 X   t        | ||j                  d   |d         }|d   }|j                  |      }|j                  |j	                  |      d      5  | j
                  j                  |t        d       d d d        | j                         S # 1 sw Y   | j                         S xY w)Nr   r   Fr   )zset.remove(): key not in set)	r   rK   r   r   r  r.  r/  r  r  )r    r!   rB   rK   r  r   r   s          r'   
set_removez_set_remove.<locals>.set_removeJ  s    7GSXXa[$q'BAwT"__W\\%0_?--gx,MO @ &&((	 @ &&((s   "BB)r  )r@   ra   r   rB   r  s        r'   _set_remover  F  s#    
**Q
C) 
?r)   removec                 (    | j                   |k(  rd S y )Nc                     t        | |      S rv   )r  r  s     r'   r  zol_set_remove.<locals>.<lambda>Z  s    {1d3r)   r  r  s     r'   ol_set_remover  W  s    ww$33 r)   c                 :    t        j                  |      }d }||fS )Nc                 ~    t        | ||j                  d   |d         }|j                          | j                         S rJ   )r   rK   r)  r  r  s        r'   	set_clearz_set_clear.<locals>.set_clearc  s6    7GSXXa[$q'B

&&((r)   r  )r@   ra   rB   r  s       r'   
_set_clearr  _  s     
**Q-C)
 	>r)   r)  c                     d S )Nc                     t        |       S rv   )r  r  s    r'   r  zol_set_clear.<locals>.<lambda>m  s    Z]r)   r   r  s    r'   ol_set_clearr  k  s    ""r)   c                       ||      }d }||fS )Nc                     t        | ||j                  d   |d         }|j                         }t        | ||j                  |j
                        S rJ   )r   rK   r:  r   r  r?   r    r!   rB   rK   r  r3  s         r'   set_copyz_set_copy.<locals>.set_copyt  sB    7GSXXa[$q'B		#//5;;OOr)   r   )r@   ra   rB   r  s       r'   	_set_copyr  p  s    
A$CP
 =r)   r:  c                     d S )Nc                     t        |       S rv   )r  r  s    r'   r  zol_set_copy.<locals>.<lambda>~  s    Yq\r)   r   r  s    r'   ol_set_copyr
  |  s    !!r)   c                     t        | ||j                  d   |d         }t        | ||j                  d   |d         }|j                  |       | j                         S r  )r   rK   r?  r  r  s         r'   set_difference_updater    sU    w!d1g>D#((1+tAw?EOOE""$$r)   c                 >    t        j                  ||      }|t        fS rv   )r   r  r  r@   abrB   s       r'   _set_difference_updater    s    
**Q
C%%%r)   difference_updatec                      t        | |       d S )Nc                     t        | |      S rv   )r  r  r  s     r'   r  z,set_difference_update_impl.<locals>.<lambda>  s    .q!4r)   rb   r  s     r'   set_difference_update_implr    s    !Q44r)   c                     t        | ||j                  d   |d         }t        | ||j                  d   |d         }|j                  |       | j                         S r  )r   rK   r=  r  r  s         r'   set_intersection_updater    sU    w!d1g>D#((1+tAw?ENN5""$$r)   c                 >    t        j                  ||      }|t        fS rv   )r   r  r  r  s       r'   _set_intersection_updater    s    
**Q
C'''r)   intersection_updatec                      t        | |       d S )Nc                     t        | |      S rv   )r  r  s     r'   r  z.set_intersection_update_impl.<locals>.<lambda>  s    0A6r)   r  r  s     r'   set_intersection_update_implr    s    !Q66r)   c                     t        | ||j                  d   |d         }t        | ||j                  d   |d         }|j                  |       | j                         S r  )r   rK   rC  r  r  s         r'   set_symmetric_difference_updater!    sW    w!d1g>D#((1+tAw?Ee$""$$r)   c                 >    t        j                  ||      }|t        fS rv   )r   r  r!  r  s       r'    _set_symmetric_difference_updater#    s    
**Q
C///r)   symmetric_difference_updatec                      t        | |       d S )Nc                     t        | |      S rv   )r#  r  s     r'   r  z6set_symmetric_difference_update_impl.<locals>.<lambda>  s    8A>r)   r  r  s     r'   $set_symmetric_difference_update_implr'    s    !Q>>r)   z
set.updatec                    t        | ||j                  d   |d         }|j                  d   }|d   }t        | |||      }|7|j                  |j                  j
                  |      }|j                  |       t        | |||      5 }	| j                  ||	j                  |j                  |j                        }
|j                  |
       | j                  j                  ||j                  |	j                         d d d        |%|j                  |j                  j
                         | j                         S # 1 sw Y   @xY wr  )r   rK   r   r   r&   r   r   r   castr?   r`   r   r  r  r  )r    r!   rB   rK   r  r  r  r  rt  r   casteds              r'   
set_updater+    s   w!d1g>D!JGE 	':u5A};;t||00!4H	'7J	6$ gtzz:3C3CTZZP
 	7J$4$4djjA 
7 	}dll''(""$$ 
7	6s   A5D<<Ec                 J    t         fd       t        |       fd       }y )Nc                 (     |||      }fd}||fS )Nc                     |j                   |j                  d   k(  sJ  | |||       t        | ||j                  d   |d         S rJ   )r  rK   r   )r    r!   rB   rK   rL   s       r'   codegenz>gen_operator_impl.<locals>._set_operator_intr.<locals>.codegen  sH    ??chhqk111'3-$Wgsxx{DGLLr)   r   )r@   r  r  rB   r/  rL   s        r'   _set_operator_intrz-gen_operator_impl.<locals>._set_operator_intr  s     1g	M G|r)   c                 &    t        | |       fdS )Nc                      | |      S rv   r   r  r  r0  s     r'   r  z=gen_operator_impl.<locals>._ol_set_operator.<locals>.<lambda>  s    .q!4r)   r  r3  s     r'   _ol_set_operatorz+gen_operator_impl.<locals>._ol_set_operator  s    a44r)   )r   r   )oprL   r4  r0  s    ` @r'   gen_operator_implr6    s-      b\5 5r)   r?  c                 $    t        | |       d }|S )Nc                 H    | j                         }|j                  |       |S rv   )r:  r  r  r  ra   s      r'   difference_implz,impl_set_difference.<locals>.difference_impl  s     FFH	Ar)   r  )r  r  r:  s      r'   impl_set_differencer;    s     !Q
 r)   intersectionc                 $    t        | |       d }|S )Nc                     t        |       t        |      k  r#| j                         }|j                  |       |S |j                         }|j                  |        |S rv   )r  r:  r  r9  s      r'   intersection_implz+set_intersection.<locals>.intersection_impl  sM    q6CF?A!!!$HA!!!$Hr)   r  )r  r  r?  s      r'   set_intersectionr@    s     !Q r)   rC  c                 $    t        | |       d }|S )Nc                     t        |       t        |      kD  r#| j                         }|j                  |       |S |j                         }|j                  |        |S rv   )r  r:  r$  r9  s      r'   symmetric_difference_implz;set_symmetric_difference.<locals>.symmetric_difference_impl  sM    q6CF?A))!,HA))!,Hr)   r  )r  r  rC  s      r'   set_symmetric_differencerD    s     !Q %$r)   unionc                 $    t        | |       d }|S )Nc                     t        |       t        |      kD  r#| j                         }|j                  |       |S |j                         }|j                  |        |S rv   )r  r:  updater9  s      r'   
union_implzset_union.<locals>.union_impl(  sG    q6CF?AHHQKHAHHQKHr)   r  )r  r  rI  s      r'   	set_unionrJ  #  s     !Q r)   c                 <    t        j                  ||      }d }||fS )Nc                     t        | ||j                  d   |d         }t        | ||j                  d   |d         }|j                  |      S r  )r   rK   rS  r  s         r'   r/  z _set_isdisjoint.<locals>.codegen;  sI    7GSXXa[$q'BGWchhqk47Cu%%r)   r   booleanr@   r  r  rB   r/  s        r'   _set_isdisjointrP  7  s#    
--1
C& <r)   rS  c                      t        | |       d S )Nc                     t        | |      S rv   )rP  r  s     r'   r  z set_isdisjoint.<locals>.<lambda>H  s    1-r)   r  r  s     r'   set_isdisjointrS  D  s    !Q--r)   c                 <    t        j                  ||      }d }||fS )Nc                     t        | ||j                  d   |d         }t        | ||j                  d   |d         }|j                  |      S r  r   rK   rK  r  s         r'   r/  z_set_issubset.<locals>.codegenO  sI    7GSXXa[$q'BGWchhqk47C}}U##r)   rM  rO  s        r'   _set_issubsetrW  K  s#    
--1
C$ <r)   rK  c                      t        | |       d S )Nc                     t        | |      S rv   )rW  r  s     r'   r  zset_issubset.<locals>.<lambda>\  s    a+r)   r  r  s     r'   set_issubsetrZ  W  s     !Q++r)   
issupersetc                 $    t        | |       d }|S )Nc                 $    |j                  |       S rv   )rK  r  s     r'   superset_implz%set_issuperset.<locals>.superset_impld  s    zz!}r)   r  )r  r  r^  s      r'   set_issupersetr_  _  s     !Q r)   c                 <    t        j                  ||      }d }||fS )Nc                     t        | ||j                  d   |d         }t        | ||j                  d   |d         }|j                  |      S r  )r   rK   rV  r  s         r'   r/  z_set_eq.<locals>.codegenm  sI    7GSXXa[$q'BGWchhqk47C{{5!!r)   rM  rO  s        r'   _set_eqrb  i  s#    
--1
C" <r)   c                      t        | |       d S )Nc                     t        | |      S rv   )rb  r  s     r'   r  zset_eq.<locals>.<lambda>y  
    1r)   r  r  s     r'   set_eqrf  u      !Q%%r)   c                 $    t        | |       d }|S )Nc                     | |k(   S rv   r   r  s     r'   ne_implzset_ne.<locals>.ne_impl  s    6zr)   r  )r  r  rj  s      r'   set_nerk  {  s    !Q Nr)   c                 <    t        j                  ||      }d }||fS )Nc                     t        | ||j                  d   |d         }t        | ||j                  d   |d         }|j                  |d      S )Nr   r   T)rF  rV  r  s         r'   r/  z_set_lt.<locals>.codegen  sM    7GSXXa[$q'BGWchhqk47C}}U4}00r)   rM  rO  s        r'   _set_ltrn    s#    
--1
C1 <r)   c                      t        | |       d S )Nc                     t        | |      S rv   )rn  r  s     r'   r  zset_lt.<locals>.<lambda>  re  r)   r  r  s     r'   set_ltrq    rg  r)   c                 $    t        | |       d }|S )Nc                     || k  S rv   r   r  s     r'   gt_implzset_gt.<locals>.gt_impl  s    1ur)   r  )r  r  rt  s      r'   set_gtru    s    !Q Nr)   c                 H   t        | ||j                  d   |d         }t        | ||j                  d   |d         }|j                  |j                  t        j
                        }|j                  |j                  t        j
                        }|j                  d||      S )Nr   r   rO   )r   rK   ptrtointr   r   r   icmp_signed)r    r!   rB   rK   r  r  mambs           r'   set_isr{    s    GWchhqk47;AGWchhqk47;A			!))W^^	4B			!))W^^	4BtR,,r)   c                 <    |j                   |j                   k(  sJ |S rv   r  )r    r!   fromtytotyr   s        r'   
set_to_setr    s     <<4::%%%Jr)   )}__doc__collectionsr   mathr   	functoolsr   llvmliter   
numba.corer   r   r   numba.core.imputilsr   r	   r
   r   r   r   r   r   r   
numba.miscr   numba.cpythonr   numba.core.errorsr   r   numba.core.extendingr   r   r   r(   r.   rP   rV   r<   r&  r   rn  rG   rM   rS   rY   r9   rb   
namedtuplerc   objectri   r   r  r  setr  IterableTyper  r  r_   r  r  Anyr  r  SetIterBORROWEDr  r  r  r  r  r  r  r  r  r  r  r
  r  r  r  r  r  r  r!  r#  r'  r+  r6  iandiorisubixorop_op_implr  r;  r   r@  xorrD  or_rJ  rP  rS  rW  lerZ  ger_  rb  r   rf  nerk  rn  ltrq  gtru  is_r{  r  r   r)   r'   <module>r     se  
     %  - -A A A ! ! : E EH( 	
  .  132L !+
 
 ,J
K| & | ~YE& YEx0f 0lD, sD D
 sE&&'D (D. sEII  x  %))UYY7" 8" y%))$L %L z5==)w  ! * y%))UYY/% 0% 
 
 I&1 '1   E"! #!    H%4 &4   G$# %#   F#" $"% & &
 /05 15
% ( (
 127 37
% 0 0
 9:? ;?
 |UYY(:(:;% <%:5" ]]+,\\:]])*]]34	LC c7# 
(,,L) *  
(--N+ ,  
(,,23% 4 % 
(,,G$ % $ 	 	 L). *. 	 	 
(++J', ( , 
(++L) *  	 	 
(++& &
 
(++  	 	 
(++& &
 
(++  x||UYY		2- 3- EIIuyy! "r)   