text:
1326 starting hold'em combos
The goal is to get all combinations of hold'em starting hands (every two card combination) in the shortest amount of code.
A hold'em hand is two distinct cards dealt from a standard deck of 52 cards, with deal-order being irrelevant, as such there are 52*51/2 = 1326, hands.
There is also a commonly used notation for the cards and hands:
A standard deck consists of 52 cards; each card has a rank and a suit. There are 4 suits which we shall label cdhs, these are not ordered. There are 13 ranks, these are ordered - from the highest rank, A, to lowest rank, 2 - which we shall label AKQJT98765432.
The full deck of 52 cards may be represented as:
Ac Ad Ah As Kc Kd Kh Ks Qc Qd Qh Qs Jc Jd Jh Js Tc Td Th Ts 9c 9d 9h 9s 8c 8d 8h 8s 7c 7d 7h 7s 6c 6d 6h 6s 5c 5d 5h 5s 4c 4d 4h 4s 3c 3d 3h 3s 2c 2d 2h 2s

A hold'em hand consists of two of these cards, and the hand may be represented as the two representations from the above list adjoined (e.g. JdJc or JsTs)
Given no input the output should be all such "combinations" (with any clear delimitation) - that is all 52*51/2 = 1326 (not "all" 52*51 = 2652):

For every (rank-wise) "pair" such as 7d7h there is an equivalent representation (here 7h7d) only one of these two should appear (it may be either).
For every other combination such as Qc8s there is an equivalent reprentation (here 8sQc) only the former should appear (the one with the left card being the higher ranked one)

Example valid outputs:
['AcAs', 'AhAs', 'AdAs', 'AhAc', 'AdAc', 'AdAh', 'AsKs', 'AcKs', 'AhKs', 'AdKs', 'KcKs', 'KhKs', 'KdKs', 'AsKc', 'AcKc', 'AhKc', 'AdKc', 'KhKc', 'KdKc', 'AsKh', 'AcKh', 'AhKh', 'AdKh', 'KdKh', 'AsKd', 'AcKd', 'AhKd', 'AdKd', 'AsQs', 'AcQs', 'AhQs', 'AdQs', 'KsQs', 'KcQs', 'KhQs', 'KdQs', 'QcQs', 'QhQs', 'QdQs', 'AsQc', 'AcQc', 'AhQc', 'AdQc', 'KsQc', 'KcQc', 'KhQc', 'KdQc', 'QhQc', 'QdQc', 'AsQh', 'AcQh', 'AhQh', 'AdQh', 'KsQh', 'KcQh', 'KhQh', 'KdQh', 'QdQh', 'AsQd', 'AcQd', 'AhQd', 'AdQd', 'KsQd', 'KcQd', 'KhQd', 'KdQd', 'AsJs', 'AcJs', 'AhJs', 'AdJs', 'KsJs', 'KcJs', 'KhJs', 'KdJs', 'QsJs', 'QcJs', 'QhJs', 'QdJs', 'JcJs', 'JhJs', 'JdJs', 'AsJc', 'AcJc', 'AhJc', 'AdJc', 'KsJc', 'KcJc', 'KhJc', 'KdJc', 'QsJc', 'QcJc', 'QhJc', 'QdJc', 'JhJc', 'JdJc', 'AsJh', 'AcJh', 'AhJh', 'AdJh', 'KsJh', 'KcJh', 'KhJh', 'KdJh', 'QsJh', 'QcJh', 'QhJh', 'QdJh', 'JdJh', 'AsJd', 'AcJd', 'AhJd', 'AdJd', 'KsJd', 'KcJd', 'KhJd', 'KdJd', 'QsJd', 'QcJd', 'QhJd', 'QdJd', 'AsTs', 'AcTs', 'AhTs', 'AdTs', 'KsTs', 'KcTs', 'KhTs', 'KdTs', 'QsTs', 'QcTs', 'QhTs', 'QdTs', 'JsTs', 'JcTs', 'JhTs', 'JdTs', 'TcTs', 'ThTs', 'TdTs', 'AsTc', 'AcTc', 'AhTc', 'AdTc', 'KsTc', 'KcTc', 'KhTc', 'KdTc', 'QsTc', 'QcTc', 'QhTc', 'QdTc', 'JsTc', 'JcTc', 'JhTc', 'JdTc', 'ThTc', 'TdTc', 'AsTh', 'AcTh', 'AhTh', 'AdTh', 'KsTh', 'KcTh', 'KhTh', 'KdTh', 'QsTh', 'QcTh', 'QhTh', 'QdTh', 'JsTh', 'JcTh', 'JhTh', 'JdTh', 'TdTh', 'AsTd', 'AcTd', 'AhTd', 'AdTd', 'KsTd', 'KcTd', 'KhTd', 'KdTd', 'QsTd', 'QcTd', 'QhTd', 'QdTd', 'JsTd', 'JcTd', 'JhTd', 'JdTd', 'As9s', 'Ac9s', 'Ah9s', 'Ad9s', 'Ks9s', 'Kc9s', 'Kh9s', 'Kd9s', 'Qs9s', 'Qc9s', 'Qh9s', 'Qd9s', 'Js9s', 'Jc9s', 'Jh9s', 'Jd9s', 'Ts9s', 'Tc9s', 'Th9s', 'Td9s', '9c9s', '9h9s', '9d9s', 'As9c', 'Ac9c', 'Ah9c', 'Ad9c', 'Ks9c', 'Kc9c', 'Kh9c', 'Kd9c', 'Qs9c', 'Qc9c', 'Qh9c', 'Qd9c', 'Js9c', 'Jc9c', 'Jh9c', 'Jd9c', 'Ts9c', 'Tc9c', 'Th9c', 'Td9c', '9h9c', '9d9c', 'As9h', 'Ac9h', 'Ah9h', 'Ad9h', 'Ks9h', 'Kc9h', 'Kh9h', 'Kd9h', 'Qs9h', 'Qc9h', 'Qh9h', 'Qd9h', 'Js9h', 'Jc9h', 'Jh9h', 'Jd9h', 'Ts9h', 'Tc9h', 'Th9h', 'Td9h', '9d9h', 'As9d', 'Ac9d', 'Ah9d', 'Ad9d', 'Ks9d', 'Kc9d', 'Kh9d', 'Kd9d', 'Qs9d', 'Qc9d', 'Qh9d', 'Qd9d', 'Js9d', 'Jc9d', 'Jh9d', 'Jd9d', 'Ts9d', 'Tc9d', 'Th9d', 'Td9d', 'As8s', 'Ac8s', 'Ah8s', 'Ad8s', 'Ks8s', 'Kc8s', 'Kh8s', 'Kd8s', 'Qs8s', 'Qc8s', 'Qh8s', 'Qd8s', 'Js8s', 'Jc8s', 'Jh8s', 'Jd8s', 'Ts8s', 'Tc8s', 'Th8s', 'Td8s', '9s8s', '9c8s', '9h8s', '9d8s', '8c8s', '8h8s', '8d8s', 'As8c', 'Ac8c', 'Ah8c', 'Ad8c', 'Ks8c', 'Kc8c', 'Kh8c', 'Kd8c', 'Qs8c', 'Qc8c', 'Qh8c', 'Qd8c', 'Js8c', 'Jc8c', 'Jh8c', 'Jd8c', 'Ts8c', 'Tc8c', 'Th8c', 'Td8c', '9s8c', '9c8c', '9h8c', '9d8c', '8h8c', '8d8c', 'As8h', 'Ac8h', 'Ah8h', 'Ad8h', 'Ks8h', 'Kc8h', 'Kh8h', 'Kd8h', 'Qs8h', 'Qc8h', 'Qh8h', 'Qd8h', 'Js8h', 'Jc8h', 'Jh8h', 'Jd8h', 'Ts8h', 'Tc8h', 'Th8h', 'Td8h', '9s8h', '9c8h', '9h8h', '9d8h', '8d8h', 'As8d', 'Ac8d', 'Ah8d', 'Ad8d', 'Ks8d', 'Kc8d', 'Kh8d', 'Kd8d', 'Qs8d', 'Qc8d', 'Qh8d', 'Qd8d', 'Js8d', 'Jc8d', 'Jh8d', 'Jd8d', 'Ts8d', 'Tc8d', 'Th8d', 'Td8d', '9s8d', '9c8d', '9h8d', '9d8d', 'As7s', 'Ac7s', 'Ah7s', 'Ad7s', 'Ks7s', 'Kc7s', 'Kh7s', 'Kd7s', 'Qs7s', 'Qc7s', 'Qh7s', 'Qd7s', 'Js7s', 'Jc7s', 'Jh7s', 'Jd7s', 'Ts7s', 'Tc7s', 'Th7s', 'Td7s', '9s7s', '9c7s', '9h7s', '9d7s', '8s7s', '8c7s', '8h7s', '8d7s', '7c7s', '7h7s', '7d7s', 'As7c', 'Ac7c', 'Ah7c', 'Ad7c', 'Ks7c', 'Kc7c', 'Kh7c', 'Kd7c', 'Qs7c', 'Qc7c', 'Qh7c', 'Qd7c', 'Js7c', 'Jc7c', 'Jh7c', 'Jd7c', 'Ts7c', 'Tc7c', 'Th7c', 'Td7c', '9s7c', '9c7c', '9h7c', '9d7c', '8s7c', '8c7c', '8h7c', '8d7c', '7h7c', '7d7c', 'As7h', 'Ac7h', 'Ah7h', 'Ad7h', 'Ks7h', 'Kc7h', 'Kh7h', 'Kd7h', 'Qs7h', 'Qc7h', 'Qh7h', 'Qd7h', 'Js7h', 'Jc7h', 'Jh7h', 'Jd7h', 'Ts7h', 'Tc7h', 'Th7h', 'Td7h', '9s7h', '9c7h', '9h7h', '9d7h', '8s7h', '8c7h', '8h7h', '8d7h', '7d7h', 'As7d', 'Ac7d', 'Ah7d', 'Ad7d', 'Ks7d', 'Kc7d', 'Kh7d', 'Kd7d', 'Qs7d', 'Qc7d', 'Qh7d', 'Qd7d', 'Js7d', 'Jc7d', 'Jh7d', 'Jd7d', 'Ts7d', 'Tc7d', 'Th7d', 'Td7d', '9s7d', '9c7d', '9h7d', '9d7d', '8s7d', '8c7d', '8h7d', '8d7d', 'As6s', 'Ac6s', 'Ah6s', 'Ad6s', 'Ks6s', 'Kc6s', 'Kh6s', 'Kd6s', 'Qs6s', 'Qc6s', 'Qh6s', 'Qd6s', 'Js6s', 'Jc6s', 'Jh6s', 'Jd6s', 'Ts6s', 'Tc6s', 'Th6s', 'Td6s', '9s6s', '9c6s', '9h6s', '9d6s', '8s6s', '8c6s', '8h6s', '8d6s', '7s6s', '7c6s', '7h6s', '7d6s', '6c6s', '6h6s', '6d6s', 'As6c', 'Ac6c', 'Ah6c', 'Ad6c', 'Ks6c', 'Kc6c', 'Kh6c', 'Kd6c', 'Qs6c', 'Qc6c', 'Qh6c', 'Qd6c', 'Js6c', 'Jc6c', 'Jh6c', 'Jd6c', 'Ts6c', 'Tc6c', 'Th6c', 'Td6c', '9s6c', '9c6c', '9h6c', '9d6c', '8s6c', '8c6c', '8h6c', '8d6c', '7s6c', '7c6c', '7h6c', '7d6c', '6h6c', '6d6c', 'As6h', 'Ac6h', 'Ah6h', 'Ad6h', 'Ks6h', 'Kc6h', 'Kh6h', 'Kd6h', 'Qs6h', 'Qc6h', 'Qh6h', 'Qd6h', 'Js6h', 'Jc6h', 'Jh6h', 'Jd6h', 'Ts6h', 'Tc6h', 'Th6h', 'Td6h', '9s6h', '9c6h', '9h6h', '9d6h', '8s6h', '8c6h', '8h6h', '8d6h', '7s6h', '7c6h', '7h6h', '7d6h', '6d6h', 'As6d', 'Ac6d', 'Ah6d', 'Ad6d', 'Ks6d', 'Kc6d', 'Kh6d', 'Kd6d', 'Qs6d', 'Qc6d', 'Qh6d', 'Qd6d', 'Js6d', 'Jc6d', 'Jh6d', 'Jd6d', 'Ts6d', 'Tc6d', 'Th6d', 'Td6d', '9s6d', '9c6d', '9h6d', '9d6d', '8s6d', '8c6d', '8h6d', '8d6d', '7s6d', '7c6d', '7h6d', '7d6d', 'As5s', 'Ac5s', 'Ah5s', 'Ad5s', 'Ks5s', 'Kc5s', 'Kh5s', 'Kd5s', 'Qs5s', 'Qc5s', 'Qh5s', 'Qd5s', 'Js5s', 'Jc5s', 'Jh5s', 'Jd5s', 'Ts5s', 'Tc5s', 'Th5s', 'Td5s', '9s5s', '9c5s', '9h5s', '9d5s', '8s5s', '8c5s', '8h5s', '8d5s', '7s5s', '7c5s', '7h5s', '7d5s', '6s5s', '6c5s', '6h5s', '6d5s', '5c5s', '5h5s', '5d5s', 'As5c', 'Ac5c', 'Ah5c', 'Ad5c', 'Ks5c', 'Kc5c', 'Kh5c', 'Kd5c', 'Qs5c', 'Qc5c', 'Qh5c', 'Qd5c', 'Js5c', 'Jc5c', 'Jh5c', 'Jd5c', 'Ts5c', 'Tc5c', 'Th5c', 'Td5c', '9s5c', '9c5c', '9h5c', '9d5c', '8s5c', '8c5c', '8h5c', '8d5c', '7s5c', '7c5c', '7h5c', '7d5c', '6s5c', '6c5c', '6h5c', '6d5c', '5h5c', '5d5c', 'As5h', 'Ac5h', 'Ah5h', 'Ad5h', 'Ks5h', 'Kc5h', 'Kh5h', 'Kd5h', 'Qs5h', 'Qc5h', 'Qh5h', 'Qd5h', 'Js5h', 'Jc5h', 'Jh5h', 'Jd5h', 'Ts5h', 'Tc5h', 'Th5h', 'Td5h', '9s5h', '9c5h', '9h5h', '9d5h', '8s5h', '8c5h', '8h5h', '8d5h', '7s5h', '7c5h', '7h5h', '7d5h', '6s5h', '6c5h', '6h5h', '6d5h', '5d5h', 'As5d', 'Ac5d', 'Ah5d', 'Ad5d', 'Ks5d', 'Kc5d', 'Kh5d', 'Kd5d', 'Qs5d', 'Qc5d', 'Qh5d', 'Qd5d', 'Js5d', 'Jc5d', 'Jh5d', 'Jd5d', 'Ts5d', 'Tc5d', 'Th5d', 'Td5d', '9s5d', '9c5d', '9h5d', '9d5d', '8s5d', '8c5d', '8h5d', '8d5d', '7s5d', '7c5d', '7h5d', '7d5d', '6s5d', '6c5d', '6h5d', '6d5d', 'As4s', 'Ac4s', 'Ah4s', 'Ad4s', 'Ks4s', 'Kc4s', 'Kh4s', 'Kd4s', 'Qs4s', 'Qc4s', 'Qh4s', 'Qd4s', 'Js4s', 'Jc4s', 'Jh4s', 'Jd4s', 'Ts4s', 'Tc4s', 'Th4s', 'Td4s', '9s4s', '9c4s', '9h4s', '9d4s', '8s4s', '8c4s', '8h4s', '8d4s', '7s4s', '7c4s', '7h4s', '7d4s', '6s4s', '6c4s', '6h4s', '6d4s', '5s4s', '5c4s', '5h4s', '5d4s', '4c4s', '4h4s', '4d4s', 'As4c', 'Ac4c', 'Ah4c', 'Ad4c', 'Ks4c', 'Kc4c', 'Kh4c', 'Kd4c', 'Qs4c', 'Qc4c', 'Qh4c', 'Qd4c', 'Js4c', 'Jc4c', 'Jh4c', 'Jd4c', 'Ts4c', 'Tc4c', 'Th4c', 'Td4c', '9s4c', '9c4c', '9h4c', '9d4c', '8s4c', '8c4c', '8h4c', '8d4c', '7s4c', '7c4c', '7h4c', '7d4c', '6s4c', '6c4c', '6h4c', '6d4c', '5s4c', '5c4c', '5h4c', '5d4c', '4h4c', '4d4c', 'As4h', 'Ac4h', 'Ah4h', 'Ad4h', 'Ks4h', 'Kc4h', 'Kh4h', 'Kd4h', 'Qs4h', 'Qc4h', 'Qh4h', 'Qd4h', 'Js4h', 'Jc4h', 'Jh4h', 'Jd4h', 'Ts4h', 'Tc4h', 'Th4h', 'Td4h', '9s4h', '9c4h', '9h4h', '9d4h', '8s4h', '8c4h', '8h4h', '8d4h', '7s4h', '7c4h', '7h4h', '7d4h', '6s4h', '6c4h', '6h4h', '6d4h', '5s4h', '5c4h', '5h4h', '5d4h', '4d4h', 'As4d', 'Ac4d', 'Ah4d', 'Ad4d', 'Ks4d', 'Kc4d', 'Kh4d', 'Kd4d', 'Qs4d', 'Qc4d', 'Qh4d', 'Qd4d', 'Js4d', 'Jc4d', 'Jh4d', 'Jd4d', 'Ts4d', 'Tc4d', 'Th4d', 'Td4d', '9s4d', '9c4d', '9h4d', '9d4d', '8s4d', '8c4d', '8h4d', '8d4d', '7s4d', '7c4d', '7h4d', '7d4d', '6s4d', '6c4d', '6h4d', '6d4d', '5s4d', '5c4d', '5h4d', '5d4d', 'As3s', 'Ac3s', 'Ah3s', 'Ad3s', 'Ks3s', 'Kc3s', 'Kh3s', 'Kd3s', 'Qs3s', 'Qc3s', 'Qh3s', 'Qd3s', 'Js3s', 'Jc3s', 'Jh3s', 'Jd3s', 'Ts3s', 'Tc3s', 'Th3s', 'Td3s', '9s3s', '9c3s', '9h3s', '9d3s', '8s3s', '8c3s', '8h3s', '8d3s', '7s3s', '7c3s', '7h3s', '7d3s', '6s3s', '6c3s', '6h3s', '6d3s', '5s3s', '5c3s', '5h3s', '5d3s', '4s3s', '4c3s', '4h3s', '4d3s', '3c3s', '3h3s', '3d3s', 'As3c', 'Ac3c', 'Ah3c', 'Ad3c', 'Ks3c', 'Kc3c', 'Kh3c', 'Kd3c', 'Qs3c', 'Qc3c', 'Qh3c', 'Qd3c', 'Js3c', 'Jc3c', 'Jh3c', 'Jd3c', 'Ts3c', 'Tc3c', 'Th3c', 'Td3c', '9s3c', '9c3c', '9h3c', '9d3c', '8s3c', '8c3c', '8h3c', '8d3c', '7s3c', '7c3c', '7h3c', '7d3c', '6s3c', '6c3c', '6h3c', '6d3c', '5s3c', '5c3c', '5h3c', '5d3c', '4s3c', '4c3c', '4h3c', '4d3c', '3h3c', '3d3c', 'As3h', 'Ac3h', 'Ah3h', 'Ad3h', 'Ks3h', 'Kc3h', 'Kh3h', 'Kd3h', 'Qs3h', 'Qc3h', 'Qh3h', 'Qd3h', 'Js3h', 'Jc3h', 'Jh3h', 'Jd3h', 'Ts3h', 'Tc3h', 'Th3h', 'Td3h', '9s3h', '9c3h', '9h3h', '9d3h', '8s3h', '8c3h', '8h3h', '8d3h', '7s3h', '7c3h', '7h3h', '7d3h', '6s3h', '6c3h', '6h3h', '6d3h', '5s3h', '5c3h', '5h3h', '5d3h', '4s3h', '4c3h', '4h3h', '4d3h', '3d3h', 'As3d', 'Ac3d', 'Ah3d', 'Ad3d', 'Ks3d', 'Kc3d', 'Kh3d', 'Kd3d', 'Qs3d', 'Qc3d', 'Qh3d', 'Qd3d', 'Js3d', 'Jc3d', 'Jh3d', 'Jd3d', 'Ts3d', 'Tc3d', 'Th3d', 'Td3d', '9s3d', '9c3d', '9h3d', '9d3d', '8s3d', '8c3d', '8h3d', '8d3d', '7s3d', '7c3d', '7h3d', '7d3d', '6s3d', '6c3d', '6h3d', '6d3d', '5s3d', '5c3d', '5h3d', '5d3d', '4s3d', '4c3d', '4h3d', '4d3d', 'As2s', 'Ac2s', 'Ah2s', 'Ad2s', 'Ks2s', 'Kc2s', 'Kh2s', 'Kd2s', 'Qs2s', 'Qc2s', 'Qh2s', 'Qd2s', 'Js2s', 'Jc2s', 'Jh2s', 'Jd2s', 'Ts2s', 'Tc2s', 'Th2s', 'Td2s', '9s2s', '9c2s', '9h2s', '9d2s', '8s2s', '8c2s', '8h2s', '8d2s', '7s2s', '7c2s', '7h2s', '7d2s', '6s2s', '6c2s', '6h2s', '6d2s', '5s2s', '5c2s', '5h2s', '5d2s', '4s2s', '4c2s', '4h2s', '4d2s', '3s2s', '3c2s', '3h2s', '3d2s', '2c2s', '2h2s', '2d2s', 'As2c', 'Ac2c', 'Ah2c', 'Ad2c', 'Ks2c', 'Kc2c', 'Kh2c', 'Kd2c', 'Qs2c', 'Qc2c', 'Qh2c', 'Qd2c', 'Js2c', 'Jc2c', 'Jh2c', 'Jd2c', 'Ts2c', 'Tc2c', 'Th2c', 'Td2c', '9s2c', '9c2c', '9h2c', '9d2c', '8s2c', '8c2c', '8h2c', '8d2c', '7s2c', '7c2c', '7h2c', '7d2c', '6s2c', '6c2c', '6h2c', '6d2c', '5s2c', '5c2c', '5h2c', '5d2c', '4s2c', '4c2c', '4h2c', '4d2c', '3s2c', '3c2c', '3h2c', '3d2c', '2h2c', '2d2c', 'As2h', 'Ac2h', 'Ah2h', 'Ad2h', 'Ks2h', 'Kc2h', 'Kh2h', 'Kd2h', 'Qs2h', 'Qc2h', 'Qh2h', 'Qd2h', 'Js2h', 'Jc2h', 'Jh2h', 'Jd2h', 'Ts2h', 'Tc2h', 'Th2h', 'Td2h', '9s2h', '9c2h', '9h2h', '9d2h', '8s2h', '8c2h', '8h2h', '8d2h', '7s2h', '7c2h', '7h2h', '7d2h', '6s2h', '6c2h', '6h2h', '6d2h', '5s2h', '5c2h', '5h2h', '5d2h', '4s2h', '4c2h', '4h2h', '4d2h', '3s2h', '3c2h', '3h2h', '3d2h', '2d2h', 'As2d', 'Ac2d', 'Ah2d', 'Ad2d', 'Ks2d', 'Kc2d', 'Kh2d', 'Kd2d', 'Qs2d', 'Qc2d', 'Qh2d', 'Qd2d', 'Js2d', 'Jc2d', 'Jh2d', 'Jd2d', 'Ts2d', 'Tc2d', 'Th2d', 'Td2d', '9s2d', '9c2d', '9h2d', '9d2d', '8s2d', '8c2d', '8h2d', '8d2d', '7s2d', '7c2d', '7h2d', '7d2d', '6s2d', '6c2d', '6h2d', '6d2d', '5s2d', '5c2d', '5h2d', '5d2d', '4s2d', '4c2d', '4h2d', '4d2d', '3s2d', '3c2d', '3h2d', '3d2d']

['AhAs', 'AsAd', 'AcAs', 'AdAh', 'AcAh', 'AdAc', 'AsKs', 'AhKs', 'AdKs', 'AcKs', 'KsKh', 'KdKs', 'KsKc', 'AsKh', 'AhKh', 'AdKh', 'AcKh', 'KdKh', 'KcKh', 'AsKd', 'AhKd', 'AdKd', 'AcKd', 'KcKd', 'AsKc', 'AhKc', 'AdKc', 'AcKc', 'AsQs', 'AhQs', 'AdQs', 'AcQs', 'KsQs', 'KhQs', 'KdQs', 'KcQs', 'QsQh', 'QdQs', 'QcQs', 'AsQh', 'AhQh', 'AdQh', 'AcQh', 'KsQh', 'KhQh', 'KdQh', 'KcQh', 'QhQd', 'QhQc', 'AsQd', 'AhQd', 'AdQd', 'AcQd', 'KsQd', 'KhQd', 'KdQd', 'KcQd', 'QdQc', 'AsQc', 'AhQc', 'AdQc', 'AcQc', 'KsQc', 'KhQc', 'KdQc', 'KcQc', 'AsJs', 'AhJs', 'AdJs', 'AcJs', 'KsJs', 'KhJs', 'KdJs', 'KcJs', 'QsJs', 'QhJs', 'QdJs', 'QcJs', 'JsJh', 'JsJd', 'JcJs', 'AsJh', 'AhJh', 'AdJh', 'AcJh', 'KsJh', 'KhJh', 'KdJh', 'KcJh', 'QsJh', 'QhJh', 'QdJh', 'QcJh', 'JdJh', 'JcJh', 'AsJd', 'AhJd', 'AdJd', 'AcJd', 'KsJd', 'KhJd', 'KdJd', 'KcJd', 'QsJd', 'QhJd', 'QdJd', 'QcJd', 'JdJc', 'AsJc', 'AhJc', 'AdJc', 'AcJc', 'KsJc', 'KhJc', 'KdJc', 'KcJc', 'QsJc', 'QhJc', 'QdJc', 'QcJc', 'AsTs', 'AhTs', 'AdTs', 'AcTs', 'KsTs', 'KhTs', 'KdTs', 'KcTs', 'QsTs', 'QhTs', 'QdTs', 'QcTs', 'JsTs', 'JhTs', 'JdTs', 'JcTs', 'ThTs', 'TsTd', 'TsTc', 'AsTh', 'AhTh', 'AdTh', 'AcTh', 'KsTh', 'KhTh', 'KdTh', 'KcTh', 'QsTh', 'QhTh', 'QdTh', 'QcTh', 'JsTh', 'JhTh', 'JdTh', 'JcTh', 'TdTh', 'ThTc', 'AsTd', 'AhTd', 'AdTd', 'AcTd', 'KsTd', 'KhTd', 'KdTd', 'KcTd', 'QsTd', 'QhTd', 'QdTd', 'QcTd', 'JsTd', 'JhTd', 'JdTd', 'JcTd', 'TdTc', 'AsTc', 'AhTc', 'AdTc', 'AcTc', 'KsTc', 'KhTc', 'KdTc', 'KcTc', 'QsTc', 'QhTc', 'QdTc', 'QcTc', 'JsTc', 'JhTc', 'JdTc', 'JcTc', 'As9s', 'Ah9s', 'Ad9s', 'Ac9s', 'Ks9s', 'Kh9s', 'Kd9s', 'Kc9s', 'Qs9s', 'Qh9s', 'Qd9s', 'Qc9s', 'Js9s', 'Jh9s', 'Jd9s', 'Jc9s', 'Ts9s', 'Th9s', 'Td9s', 'Tc9s', '9s9h', '9d9s', '9s9c', 'As9h', 'Ah9h', 'Ad9h', 'Ac9h', 'Ks9h', 'Kh9h', 'Kd9h', 'Kc9h', 'Qs9h', 'Qh9h', 'Qd9h', 'Qc9h', 'Js9h', 'Jh9h', 'Jd9h', 'Jc9h', 'Ts9h', 'Th9h', 'Td9h', 'Tc9h', '9h9d', '9h9c', 'As9d', 'Ah9d', 'Ad9d', 'Ac9d', 'Ks9d', 'Kh9d', 'Kd9d', 'Kc9d', 'Qs9d', 'Qh9d', 'Qd9d', 'Qc9d', 'Js9d', 'Jh9d', 'Jd9d', 'Jc9d', 'Ts9d', 'Th9d', 'Td9d', 'Tc9d', '9c9d', 'As9c', 'Ah9c', 'Ad9c', 'Ac9c', 'Ks9c', 'Kh9c', 'Kd9c', 'Kc9c', 'Qs9c', 'Qh9c', 'Qd9c', 'Qc9c', 'Js9c', 'Jh9c', 'Jd9c', 'Jc9c', 'Ts9c', 'Th9c', 'Td9c', 'Tc9c', 'As8s', 'Ah8s', 'Ad8s', 'Ac8s', 'Ks8s', 'Kh8s', 'Kd8s', 'Kc8s', 'Qs8s', 'Qh8s', 'Qd8s', 'Qc8s', 'Js8s', 'Jh8s', 'Jd8s', 'Jc8s', 'Ts8s', 'Th8s', 'Td8s', 'Tc8s', '9s8s', '9h8s', '9d8s', '9c8s', '8h8s', '8s8d', '8s8c', 'As8h', 'Ah8h', 'Ad8h', 'Ac8h', 'Ks8h', 'Kh8h', 'Kd8h', 'Kc8h', 'Qs8h', 'Qh8h', 'Qd8h', 'Qc8h', 'Js8h', 'Jh8h', 'Jd8h', 'Jc8h', 'Ts8h', 'Th8h', 'Td8h', 'Tc8h', '9s8h', '9h8h', '9d8h', '9c8h', '8d8h', '8h8c', 'As8d', 'Ah8d', 'Ad8d', 'Ac8d', 'Ks8d', 'Kh8d', 'Kd8d', 'Kc8d', 'Qs8d', 'Qh8d', 'Qd8d', 'Qc8d', 'Js8d', 'Jh8d', 'Jd8d', 'Jc8d', 'Ts8d', 'Th8d', 'Td8d', 'Tc8d', '9s8d', '9h8d', '9d8d', '9c8d', '8c8d', 'As8c', 'Ah8c', 'Ad8c', 'Ac8c', 'Ks8c', 'Kh8c', 'Kd8c', 'Kc8c', 'Qs8c', 'Qh8c', 'Qd8c', 'Qc8c', 'Js8c', 'Jh8c', 'Jd8c', 'Jc8c', 'Ts8c', 'Th8c', 'Td8c', 'Tc8c', '9s8c', '9h8c', '9d8c', '9c8c', 'As7s', 'Ah7s', 'Ad7s', 'Ac7s', 'Ks7s', 'Kh7s', 'Kd7s', 'Kc7s', 'Qs7s', 'Qh7s', 'Qd7s', 'Qc7s', 'Js7s', 'Jh7s', 'Jd7s', 'Jc7s', 'Ts7s', 'Th7s', 'Td7s', 'Tc7s', '9s7s', '9h7s', '9d7s', '9c7s', '8s7s', '8h7s', '8d7s', '8c7s', '7s7h', '7s7d', '7s7c', 'As7h', 'Ah7h', 'Ad7h', 'Ac7h', 'Ks7h', 'Kh7h', 'Kd7h', 'Kc7h', 'Qs7h', 'Qh7h', 'Qd7h', 'Qc7h', 'Js7h', 'Jh7h', 'Jd7h', 'Jc7h', 'Ts7h', 'Th7h', 'Td7h', 'Tc7h', '9s7h', '9h7h', '9d7h', '9c7h', '8s7h', '8h7h', '8d7h', '8c7h', '7d7h', '7c7h', 'As7d', 'Ah7d', 'Ad7d', 'Ac7d', 'Ks7d', 'Kh7d', 'Kd7d', 'Kc7d', 'Qs7d', 'Qh7d', 'Qd7d', 'Qc7d', 'Js7d', 'Jh7d', 'Jd7d', 'Jc7d', 'Ts7d', 'Th7d', 'Td7d', 'Tc7d', '9s7d', '9h7d', '9d7d', '9c7d', '8s7d', '8h7d', '8d7d', '8c7d', '7d7c', 'As7c', 'Ah7c', 'Ad7c', 'Ac7c', 'Ks7c', 'Kh7c', 'Kd7c', 'Kc7c', 'Qs7c', 'Qh7c', 'Qd7c', 'Qc7c', 'Js7c', 'Jh7c', 'Jd7c', 'Jc7c', 'Ts7c', 'Th7c', 'Td7c', 'Tc7c', '9s7c', '9h7c', '9d7c', '9c7c', '8s7c', '8h7c', '8d7c', '8c7c', 'As6s', 'Ah6s', 'Ad6s', 'Ac6s', 'Ks6s', 'Kh6s', 'Kd6s', 'Kc6s', 'Qs6s', 'Qh6s', 'Qd6s', 'Qc6s', 'Js6s', 'Jh6s', 'Jd6s', 'Jc6s', 'Ts6s', 'Th6s', 'Td6s', 'Tc6s', '9s6s', '9h6s', '9d6s', '9c6s', '8s6s', '8h6s', '8d6s', '8c6s', '7s6s', '7h6s', '7d6s', '7c6s', '6s6h', '6s6d', '6c6s', 'As6h', 'Ah6h', 'Ad6h', 'Ac6h', 'Ks6h', 'Kh6h', 'Kd6h', 'Kc6h', 'Qs6h', 'Qh6h', 'Qd6h', 'Qc6h', 'Js6h', 'Jh6h', 'Jd6h', 'Jc6h', 'Ts6h', 'Th6h', 'Td6h', 'Tc6h', '9s6h', '9h6h', '9d6h', '9c6h', '8s6h', '8h6h', '8d6h', '8c6h', '7s6h', '7h6h', '7d6h', '7c6h', '6d6h', '6c6h', 'As6d', 'Ah6d', 'Ad6d', 'Ac6d', 'Ks6d', 'Kh6d', 'Kd6d', 'Kc6d', 'Qs6d', 'Qh6d', 'Qd6d', 'Qc6d', 'Js6d', 'Jh6d', 'Jd6d', 'Jc6d', 'Ts6d', 'Th6d', 'Td6d', 'Tc6d', '9s6d', '9h6d', '9d6d', '9c6d', '8s6d', '8h6d', '8d6d', '8c6d', '7s6d', '7h6d', '7d6d', '7c6d', '6d6c', 'As6c', 'Ah6c', 'Ad6c', 'Ac6c', 'Ks6c', 'Kh6c', 'Kd6c', 'Kc6c', 'Qs6c', 'Qh6c', 'Qd6c', 'Qc6c', 'Js6c', 'Jh6c', 'Jd6c', 'Jc6c', 'Ts6c', 'Th6c', 'Td6c', 'Tc6c', '9s6c', '9h6c', '9d6c', '9c6c', '8s6c', '8h6c', '8d6c', '8c6c', '7s6c', '7h6c', '7d6c', '7c6c', 'As5s', 'Ah5s', 'Ad5s', 'Ac5s', 'Ks5s', 'Kh5s', 'Kd5s', 'Kc5s', 'Qs5s', 'Qh5s', 'Qd5s', 'Qc5s', 'Js5s', 'Jh5s', 'Jd5s', 'Jc5s', 'Ts5s', 'Th5s', 'Td5s', 'Tc5s', '9s5s', '9h5s', '9d5s', '9c5s', '8s5s', '8h5s', '8d5s', '8c5s', '7s5s', '7h5s', '7d5s', '7c5s', '6s5s', '6h5s', '6d5s', '6c5s', '5s5h', '5s5d', '5c5s', 'As5h', 'Ah5h', 'Ad5h', 'Ac5h', 'Ks5h', 'Kh5h', 'Kd5h', 'Kc5h', 'Qs5h', 'Qh5h', 'Qd5h', 'Qc5h', 'Js5h', 'Jh5h', 'Jd5h', 'Jc5h', 'Ts5h', 'Th5h', 'Td5h', 'Tc5h', '9s5h', '9h5h', '9d5h', '9c5h', '8s5h', '8h5h', '8d5h', '8c5h', '7s5h', '7h5h', '7d5h', '7c5h', '6s5h', '6h5h', '6d5h', '6c5h', '5d5h', '5h5c', 'As5d', 'Ah5d', 'Ad5d', 'Ac5d', 'Ks5d', 'Kh5d', 'Kd5d', 'Kc5d', 'Qs5d', 'Qh5d', 'Qd5d', 'Qc5d', 'Js5d', 'Jh5d', 'Jd5d', 'Jc5d', 'Ts5d', 'Th5d', 'Td5d', 'Tc5d', '9s5d', '9h5d', '9d5d', '9c5d', '8s5d', '8h5d', '8d5d', '8c5d', '7s5d', '7h5d', '7d5d', '7c5d', '6s5d', '6h5d', '6d5d', '6c5d', '5d5c', 'As5c', 'Ah5c', 'Ad5c', 'Ac5c', 'Ks5c', 'Kh5c', 'Kd5c', 'Kc5c', 'Qs5c', 'Qh5c', 'Qd5c', 'Qc5c', 'Js5c', 'Jh5c', 'Jd5c', 'Jc5c', 'Ts5c', 'Th5c', 'Td5c', 'Tc5c', '9s5c', '9h5c', '9d5c', '9c5c', '8s5c', '8h5c', '8d5c', '8c5c', '7s5c', '7h5c', '7d5c', '7c5c', '6s5c', '6h5c', '6d5c', '6c5c', 'As4s', 'Ah4s', 'Ad4s', 'Ac4s', 'Ks4s', 'Kh4s', 'Kd4s', 'Kc4s', 'Qs4s', 'Qh4s', 'Qd4s', 'Qc4s', 'Js4s', 'Jh4s', 'Jd4s', 'Jc4s', 'Ts4s', 'Th4s', 'Td4s', 'Tc4s', '9s4s', '9h4s', '9d4s', '9c4s', '8s4s', '8h4s', '8d4s', '8c4s', '7s4s', '7h4s', '7d4s', '7c4s', '6s4s', '6h4s', '6d4s', '6c4s', '5s4s', '5h4s', '5d4s', '5c4s', '4s4h', '4s4d', '4s4c', 'As4h', 'Ah4h', 'Ad4h', 'Ac4h', 'Ks4h', 'Kh4h', 'Kd4h', 'Kc4h', 'Qs4h', 'Qh4h', 'Qd4h', 'Qc4h', 'Js4h', 'Jh4h', 'Jd4h', 'Jc4h', 'Ts4h', 'Th4h', 'Td4h', 'Tc4h', '9s4h', '9h4h', '9d4h', '9c4h', '8s4h', '8h4h', '8d4h', '8c4h', '7s4h', '7h4h', '7d4h', '7c4h', '6s4h', '6h4h', '6d4h', '6c4h', '5s4h', '5h4h', '5d4h', '5c4h', '4h4d', '4c4h', 'As4d', 'Ah4d', 'Ad4d', 'Ac4d', 'Ks4d', 'Kh4d', 'Kd4d', 'Kc4d', 'Qs4d', 'Qh4d', 'Qd4d', 'Qc4d', 'Js4d', 'Jh4d', 'Jd4d', 'Jc4d', 'Ts4d', 'Th4d', 'Td4d', 'Tc4d', '9s4d', '9h4d', '9d4d', '9c4d', '8s4d', '8h4d', '8d4d', '8c4d', '7s4d', '7h4d', '7d4d', '7c4d', '6s4d', '6h4d', '6d4d', '6c4d', '5s4d', '5h4d', '5d4d', '5c4d', '4d4c', 'As4c', 'Ah4c', 'Ad4c', 'Ac4c', 'Ks4c', 'Kh4c', 'Kd4c', 'Kc4c', 'Qs4c', 'Qh4c', 'Qd4c', 'Qc4c', 'Js4c', 'Jh4c', 'Jd4c', 'Jc4c', 'Ts4c', 'Th4c', 'Td4c', 'Tc4c', '9s4c', '9h4c', '9d4c', '9c4c', '8s4c', '8h4c', '8d4c', '8c4c', '7s4c', '7h4c', '7d4c', '7c4c', '6s4c', '6h4c', '6d4c', '6c4c', '5s4c', '5h4c', '5d4c', '5c4c', 'As3s', 'Ah3s', 'Ad3s', 'Ac3s', 'Ks3s', 'Kh3s', 'Kd3s', 'Kc3s', 'Qs3s', 'Qh3s', 'Qd3s', 'Qc3s', 'Js3s', 'Jh3s', 'Jd3s', 'Jc3s', 'Ts3s', 'Th3s', 'Td3s', 'Tc3s', '9s3s', '9h3s', '9d3s', '9c3s', '8s3s', '8h3s', '8d3s', '8c3s', '7s3s', '7h3s', '7d3s', '7c3s', '6s3s', '6h3s', '6d3s', '6c3s', '5s3s', '5h3s', '5d3s', '5c3s', '4s3s', '4h3s', '4d3s', '4c3s', '3s3h', '3s3d', '3s3c', 'As3h', 'Ah3h', 'Ad3h', 'Ac3h', 'Ks3h', 'Kh3h', 'Kd3h', 'Kc3h', 'Qs3h', 'Qh3h', 'Qd3h', 'Qc3h', 'Js3h', 'Jh3h', 'Jd3h', 'Jc3h', 'Ts3h', 'Th3h', 'Td3h', 'Tc3h', '9s3h', '9h3h', '9d3h', '9c3h', '8s3h', '8h3h', '8d3h', '8c3h', '7s3h', '7h3h', '7d3h', '7c3h', '6s3h', '6h3h', '6d3h', '6c3h', '5s3h', '5h3h', '5d3h', '5c3h', '4s3h', '4h3h', '4d3h', '4c3h', '3h3d', '3h3c', 'As3d', 'Ah3d', 'Ad3d', 'Ac3d', 'Ks3d', 'Kh3d', 'Kd3d', 'Kc3d', 'Qs3d', 'Qh3d', 'Qd3d', 'Qc3d', 'Js3d', 'Jh3d', 'Jd3d', 'Jc3d', 'Ts3d', 'Th3d', 'Td3d', 'Tc3d', '9s3d', '9h3d', '9d3d', '9c3d', '8s3d', '8h3d', '8d3d', '8c3d', '7s3d', '7h3d', '7d3d', '7c3d', '6s3d', '6h3d', '6d3d', '6c3d', '5s3d', '5h3d', '5d3d', '5c3d', '4s3d', '4h3d', '4d3d', '4c3d', '3c3d', 'As3c', 'Ah3c', 'Ad3c', 'Ac3c', 'Ks3c', 'Kh3c', 'Kd3c', 'Kc3c', 'Qs3c', 'Qh3c', 'Qd3c', 'Qc3c', 'Js3c', 'Jh3c', 'Jd3c', 'Jc3c', 'Ts3c', 'Th3c', 'Td3c', 'Tc3c', '9s3c', '9h3c', '9d3c', '9c3c', '8s3c', '8h3c', '8d3c', '8c3c', '7s3c', '7h3c', '7d3c', '7c3c', '6s3c', '6h3c', '6d3c', '6c3c', '5s3c', '5h3c', '5d3c', '5c3c', '4s3c', '4h3c', '4d3c', '4c3c', 'As2s', 'Ah2s', 'Ad2s', 'Ac2s', 'Ks2s', 'Kh2s', 'Kd2s', 'Kc2s', 'Qs2s', 'Qh2s', 'Qd2s', 'Qc2s', 'Js2s', 'Jh2s', 'Jd2s', 'Jc2s', 'Ts2s', 'Th2s', 'Td2s', 'Tc2s', '9s2s', '9h2s', '9d2s', '9c2s', '8s2s', '8h2s', '8d2s', '8c2s', '7s2s', '7h2s', '7d2s', '7c2s', '6s2s', '6h2s', '6d2s', '6c2s', '5s2s', '5h2s', '5d2s', '5c2s', '4s2s', '4h2s', '4d2s', '4c2s', '3s2s', '3h2s', '3d2s', '3c2s', '2s2h', '2s2d', '2s2c', 'As2h', 'Ah2h', 'Ad2h', 'Ac2h', 'Ks2h', 'Kh2h', 'Kd2h', 'Kc2h', 'Qs2h', 'Qh2h', 'Qd2h', 'Qc2h', 'Js2h', 'Jh2h', 'Jd2h', 'Jc2h', 'Ts2h', 'Th2h', 'Td2h', 'Tc2h', '9s2h', '9h2h', '9d2h', '9c2h', '8s2h', '8h2h', '8d2h', '8c2h', '7s2h', '7h2h', '7d2h', '7c2h', '6s2h', '6h2h', '6d2h', '6c2h', '5s2h', '5h2h', '5d2h', '5c2h', '4s2h', '4h2h', '4d2h', '4c2h', '3s2h', '3h2h', '3d2h', '3c2h', '2d2h', '2c2h', 'As2d', 'Ah2d', 'Ad2d', 'Ac2d', 'Ks2d', 'Kh2d', 'Kd2d', 'Kc2d', 'Qs2d', 'Qh2d', 'Qd2d', 'Qc2d', 'Js2d', 'Jh2d', 'Jd2d', 'Jc2d', 'Ts2d', 'Th2d', 'Td2d', 'Tc2d', '9s2d', '9h2d', '9d2d', '9c2d', '8s2d', '8h2d', '8d2d', '8c2d', '7s2d', '7h2d', '7d2d', '7c2d', '6s2d', '6h2d', '6d2d', '6c2d', '5s2d', '5h2d', '5d2d', '5c2d', '4s2d', '4h2d', '4d2d', '4c2d', '3s2d', '3h2d', '3d2d', '3c2d', '2c2d', 'As2c', 'Ah2c', 'Ad2c', 'Ac2c', 'Ks2c', 'Kh2c', 'Kd2c', 'Kc2c', 'Qs2c', 'Qh2c', 'Qd2c', 'Qc2c', 'Js2c', 'Jh2c', 'Jd2c', 'Jc2c', 'Ts2c', 'Th2c', 'Td2c', 'Tc2c', '9s2c', '9h2c', '9d2c', '9c2c', '8s2c', '8h2c', '8d2c', '8c2c', '7s2c', '7h2c', '7d2c', '7c2c', '6s2c', '6h2c', '6d2c', '6c2c', '5s2c', '5h2c', '5d2c', '5c2c', '4s2c', '4h2c', '4d2c', '4c2c', '3s2c', '3h2c', '3d2c', '3c2c']

QhQs 7s3d Tc3s KhQd Kh4c 8s6d Ts5s Tc4c Jd8c Ks3c Ah8c Jd5s QhTh Ad2c 9c5c 9d3d QcJc 6s3h Qc5s Ah7h 8d8s 7d4s 4c3c 6c6h 7s4h 9d8d Qs6s Ah9d AcTc 4c2d 9h3h Tc4h 8h3h Ts3d Ks5c 8d2s 7s2s 5c3c Kh2h KcTc Ad3c 7d2s AsKs 6c2c 5d4c AdKh 9d7c 3s2d KsTd Qc4c 6c6s AdKs 9s5c Ac2h 4d2c Ac6c Qh3d Qh4d 7h4s Ts6s 6h2s 6d4c Js2c Ks4c Jh2h 8s5c Kc8d 8h5d 9h5h AcQh JhTs 6d5c Qh9s Kh7s Jd8s Ad2h Ts2d Js8d Ts2c Js5d 9h6d KcJh Kh2c KdJd Tc3d Jh6d KdJs Kd9h 5h4s Jd2c QdTc KhQh 4d4h 7c2d Qh6s Ks6c Jc4h AdJh Ts3h Kd3d 3s2s AcQc 7s3c AcTs Th4d Qd5s Jh8s KdTd Tc5c 4c2h 8d2c 8d4c 9s2d 9h2d 9h6h 5c4h 9s2h 7s5c Tc5s 6d3c Ad8d Kc4h Td8c Th6d KdTh Ts5c Ks8s 4s3d 7c5h 7d6h 6h5d Td8d Kd8c JcTd 6s2c 7c4d AsTh Td3d Jc2d Kd9d 7c4h AdJd Td4s 5h5s Ac6d Ad4c Jh5h 9c4c As5h Th4h AcJh 5d2d KcQs 8s2d 7h6c 7c6d Ad8s 9h8c AhKd 9c4h 9c5d 4c3d Kd9s Kh2s AhJd Js2h Ts7s Th2h Qc4d 5h3d 6d4s 6d3h Ah5d 5c2d Jc8s 7c3c JdJs 4s3s Qs7h AhQh Qs9d Qh8h 8h7s 8s7s Kh2d 7c4s As3d 9s5s Qs6d 9h5c Qs6h Jd6h Qh7d Qs8s 9d4s Qc3h JcJh Kc4d QdTs Tc8d Qd5h Qs2s Jh4h 4d2h Kc6d 9h6c Qs9c Js4s Jd3d Tc9s KcQd 7d6c KcTd 8d5s Ad7s 4c3s AcKh 5s2h QdJc Js6h 4c2c 9h7c Ah5c KsJh Kh5c Qs4c KsJs Td3c 6s4c 8s6h 7c6c 7s2h Jd9h 5d2s Js6s 6s2s Kc7d Ac4d 8s7d Kc8c Jh2d Kd9c Td9h Qd4s Ad6s Qd3c Ac4s Th3d As5c QsTs KcJd 5h3h 8d7s 6h6s Qc9c AhJc Ks3s 6d6s 5s3h Kd6c Th3s Qh8s Qc6s AdAc Jc6c As8s QcQs 8c5h As7h Ac6s Th8c 3h2c Tc6d Jc9s 8d5h Ah7c Ks8h AdAh Kd3h 4d3s 8c5d Kh5d Jd2s 7s3s 9d5c 9s3h 7d2d 3h3s 5s3s AdTh Tc9c As2d Tc9d 9s8s KhTc AhTc 2d2c 8c7s 8c7d KdQc 9d2s Qs8c 7h5s Jd3h Kc8s Qc9h 8c5s Td4h 3d3h JhTh As8h 7d4h Ad6h 9s3s AsJc Ad3s Ah6c 9s2c 8h6s 7s6h 5s4h As2h Tc3h As4d Qh2h 9h7d Jc8d Jh8c 2c2s 9d8c Ac2s Ts9d 3c3h AcKd Jh2c Ah3s As6s Tc9h Kc2h Td2h QsJd Kc6c Ac4h 7h2h JcTc 8s3d Ah6h KhJd Ah5s Kh3c Kd4d 9h7h 5s2c 8c6c Jh5d Qc8d 8d7d 8c3s Qd6h 5s2d 9s8d Tc2c 5c4d 6s4d Kd3c Kc6h Ac3d 4d2s 6h2d Jc6s 3c2s QcTc KhJc Ks6d Qs7c As3h 3d3c Kc9h Qh9h 8d2h Jd4c Qc2d Kc3h Qd8s Ts6d As8c Qh3s Kc8h Qs9h AhQc Ad6c Ts4c Js9d AsQh 8s3h 9c2c 9s6h 7c6s 6d3s Td4d Ah2c Kc5h Jd6s KdKs Qh9d 7s2c 3c2c 8s4s 5d2c Js7c KcQc Js5h 6s4s Ah4c Qd2s Ts3s Qd8h 9c2s 9d5d Td2d 7d6s 5d3h Qd6s 6c3c 8s4h Qc7c Td8h Qs2d 7h3h 9c7d AsQs 4h2s Kh7d AhAs 4d3h 4h4s 5c2h 8h3s Kc6s Js7s Ts6c QcJs QhJd Qc6c Kc7s JcTs 6c3d Ks5d AcQd 5d2h 7c2s Jc2s 7d7h KhTd Td5h As4h KcQh 7h7s Th5c As2c 6c5d Td9s Qc7s Qh2d 6c2d As2s 6d2c Th7d KdQh 9d8s 8h2s Qh5d Qs2h 9d4h Tc7d Th7c Th6s 7c5c 8h8s 8h2d 5h2d Ad4s 9c9s Ah4d Qd3h Kc4s Kd3s Ks5s Jh9d 8c6s Qc5c 5c5s 8c6h 9d4d 9c6d Ac9s Qd8d Td6c 6s5c 8h3d Qc8c 9s7d Jd7s AsTd 8c5c 8d8c Qh5h Qs3d 9h3c Ah8h Ks9h Kc7c 7h2s Th9s 8d6c Js3h 7s5s Ad8h Qd7s 3h2h Js6c Kd8s Qh4s 7c6h Kd7h Th7s Qh3h Th5d Kd8h JhTd Js4d AsJh AcKc 9s6s Ts4h Td3h 9c5s Js2d Qs3h Qh2s Td5d Kd8d Td9d 6h4d Jh9c Td7c Kd5s Jc4d 8d4h 7d7c Kd5d 6c4d Ad7d Kd5c Ks4s Ts2h 5d3c 9d2c Jd5c Jh3h 4c2s Qh6c AhKc 9h2h QcQh 5h2c Kc4c Ad6d Jh7c Js7h 9c2h 3s2h 8c8s 8s7c Qc5h QsJc 7s6s 5s2s Td7h 8h5c AcJd Kd5h KdKc 7h5d 7d4d 8s5d 8c2h Jd7c KsQs 7c3h 6c5s 9c7c Qs4d Js8h 9d3h 9c3h 5h2h AhTd Qc7h AdJs As3c Kd2h 7h4d 7h3s 6h3d 5d4d Qc6d 9d8h Js4c 7d6d Ac3h Qs7s JdTh 9s4d 9c4d Ac4c 4h2h 3h2s 5d4s 9h7s Ks7c Kh9d Ks2d Kh6h 4c4s 8c2c Ad5d Qh3c 8h2h 8s4d Jh9h Qc2h 6c2s Jh5c 9h4d Ac9d Kh6s Qd3s 7c2h Ad8c AsTc Kh8s 6c4h Qd6c 3d3s ThTs Jh9s Qs3c Th4c Qh2c 9h9s 4d3c 8s2h 7s4d Td7s Qc4h Jd2h Ks7d Jd4s Jc5d Qc2c Ts2s 8d3s Qd7c KcKh 9s7c 4h3s 3d2h 6c5h 6d5h Kh4h Ac9h AcTh Kd2c JsTc 8d6s Kh7c Qd8c 7d3c 6d4h Ts4s Qh4h Tc8c 7s4c Ad2d Kh9s Th9c Kh3h AhQs 6h4s Kc2s 8s6c 5c3s As9c Th6h AdKc Qh7h Jd4d KhTs AsKh 7h6d Js5s 4s2c 5d5c Jd3s Jc3h Td9c KsJd QdQh 5h4c Jd5h Ah3c Ac7s 7s6d 6c4s Th2d Jh4s 7h6s Jd3c Kc5s 5c2s 9s8h Ah8d QhTd 8c2d 6h2c Ac2d 5c3h 9c6s 9h4s Kc3s 6c3s 9d6s Kc2c 6s4h As4c 7h4h 9h5d 9d9c Kh7h Ah4s 9d2h 7c4c As9s 6d4d Jh6c Js8s 6h5c Jd6d Tc2h Td6d 7d4c AdKd Ad9s Ah3h Qd7d Kh9h Jc9c Jc8h 4s2s 5h4d QsTh 8d5d Qd9s Js3s Tc2d Jc7c Qh5s Qd4h TdTc 9c8d KsTh 3d2d AhTs 7d7s 7c7h Kc2d Th2s Qd2h Td4c 5s4d 8h4c Qc6h Tc7c 9d6c 8s3c KsTs 6d2d Ts8h 5h3c QsJs 3h2d Kh8h 7h6h Jc4c 8c6d Ad9h 9h5s 9h6s AcTd 9c6c AhKh 8d8h Js8c 4h2d 9c4s Kc3d 8c8h As5d Jh4c 2c2h Qc4s 8d4s KhQc 8d3d As4s Jc3c AdQs Ah6s 9d6h 8d4d AdQd JsTh Kc5d Ad5c KsTc Qd3d QcTs Kd4h 8d3h 8d2d KhQs 3c2h 3c3s JdJh Ac6h 4s2h Jc4s Kd7d AdQh AsJs Th7h QcJh Qc3d AdTc Jd2d Qd4c 9s4s Qs5h Qh9c Ah8s Jh3c 9h4h Ks4h 5c4c AhKs QsJh Kc5c 9c3c 9d5s KcTs Ac5s 5c5h 5s3d Ks8c Qs7d Kh8d Td3s 4s3h Qh6h JcJs Jd6c QsTd Qc3s Qd7h 9h4c Qd5c 6c2h 7h5h AcJs 8d7c 6c5c Js2s Qh4c Qc9s 9s7h 4d3d 7h3d AsQd Ks9d 5s4c Td6h Kh4d QcJd Jc5c Ac5c 3c2d Ac8s Th9h Jd9d Jh5s 5h4h 7c7s Th2c JcTh Th3c AhQd Ac2c Jd9c AcAs 9h8s KsQh Jh4d 7d3d Qs8h QhTc Th5s 9d2d 6h5s 8h6h 8c3c Th6c Jc2h Jc9d Kh3d 7s6c Ac8d Jd8d Ts5d 7s3h Kd2s 9d6d 8s2s Ks2c Jh8h Ac7h AdQc 5s4s AsKd JdTs Qh5c Qc7d Qh7c Ah4h QdQs 6s2d Qc3c Jc8c Kh5h QsTc QhJs 9s6c AcAh 7h3c 8c7h Qc5d 8h6d 7c3d 8c3h Jd7h Ts8d Ah7d 4h3h Jc3d As9h 5h3s 8c2s 5c3d 7c5d Jh7s Ts8c AhTh 7h5c 9c5h Qh6d 7h2d 8h6c Tc8h QdJh AdAs Js3d 6h4c Qd2c Ad9d Tc4s Qd5d 9c2d TcTs TcTh Qs9s 7h2c 5d3s Ks6h AdTs Ah2h 5c2c Tc3c Jh7d Ad9c AcQs 6s3s 6d5d Tc7s KdQs 9s6d Ks9s KcJs JdTc 9d7h KhTh Kd7s Tc8s Js6d 7s2d 6d2h 9s4c As6d Jc7d KcKs 6d6c 8h7c Td5s Ks3h Js3c 6h5h 6s5h Jd4h 8c3d 6d2s Kd6h 9s8c 7c5s Td7d Th8s 9c9h As6c QdJs QcTd JhJs Kh9c Qs5d 9c3s Qh8c 9d5h Th9d 9s5d Jc6d Jh7h AsKc As6h 6d3d 9d7d KdTc JdTd 6s3c Tc6c KsQd Js9h Ts9s Qc8h Kh6d 9d7s Jh3d Jc9h 8h4h JdJc Qs2c 3s2c 2d2s 8s6s Ks6s Jd8h Ts6h Jc5s 7d5d Qs4s 8s5s Kd2d 4c4h Ks2s KsQc Js4h 2d2h Ks3d 4d4s Tc6h 9d9h Ac8c 5s3c Qs5s Ks5h Qh8d 6h3c Kd4s 8h5s Ah9s Tc6s 6s2h 9s7s 9s3d 4h3d 9h8d 3d2s Th8d As9d QdTd Qc9d Jd7d KhKs 8s7h 8s2c 9d3c Ts9c 2h2s Ad4h Ad5h Tc5h As7d As7c 5d5h Kc9c As5s 9s2s Qc2s Jc3s 9c3d 5h2s 6h4h 5d4h 6c3h 9d3s Kd7c 8h4d Ac3s 4c3h Ts7d 8c4d Ks8d Td8s Th3h Ah9c Qs6c 8h3c 4s2d 5d5s KcJc 8h5h Jc7h KdJc Qs8d 8d5c Jc7s 8d7h 8c4c 6c4c 9s3c 7d3h Ac7d Td6s Kc3c Tc2s Ah3d KdJh Qd4d 9h2s Ts3c 7d2c 8h7d Tc4d 8h2c Ah7s 8d6h Ac9c Jh3s 3d2c Jh2s TdTh 9c7s 5c4s Ad4d QhTs 9c7h Kc9d Kd6d Kh5s 8c7c 6s5s Ah6d 8d6d Ks7s Ac7c AdTd Ah9h Kc9s QhJh Ks4d As3s KsJc Jd5d 7d5s TdTs Ah2s 9h3s Th4s AsQc Ad3h Ks7h KhJs 8s4c 7s4s JhTc AsJd 6h3h Tc7h Ad7h 7c3s 8s3s 7d3s 8h4s Js9c Qd9d JsTs AhJh Jh6s 9s5h Jd9s 6h2h As7s QcTh 7s5h Kd4c 6s5d 9c8h Qd9c Js5c KhJh KdQd Qs4h Ad2s Ah2d QdQc QdTh 8s5h Js7d Tc5d 4h2c Ac3c AcJc Ad7c 7d5h 7h4c AcKs Jc5h Qd9h KdTs Kh3s Ad3d 4d4c 9h3d Ts8s 6h3s 7d2h 4d2d 6d5s KdKh 7s5d 6d6h 9d9s 9h2c Kh8c 5d3d As8d Ts9h Td2s Ks2h 9h8h 6s3d 9c8s Qs3s Th5h Jh6h AsTs Ad5s Kh4s 8c4h Qd6d Ts7c Kc7h KcTh Qs5c 4h3c QhJc 7d5c Ac5d 8c4s Th8h Jh8d 9d4c Qd2d Ac8h Kh6c QdJd JsTd Jc2c Ks9c Jc6h 9c8c Ts5h AhJs Ts4d 9s4h AdJc Js9s 4s3c Kd6s Ac5h 8h7h Td2c 7c2c Qc8s Ts7h 9c6h Td5c Ah5h 8d3c Qh7s

3c2c, 3d2c, 3h2c, 3s2c, 4c2c, 4d2c, 4h2c, 4s2c, 5c2c, 5d2c, 5h2c, 5s2c, 6c2c, 6d2c, 6h2c, 6s2c, 7c2c, 7d2c, 7h2c, 7s2c, 8c2c, 8d2c, 8h2c, 8s2c, 9c2c, 9d2c, 9h2c, 9s2c, Tc2c, Td2c, Th2c, Ts2c, Jc2c, Jd2c, Jh2c, Js2c, Qc2c, Qd2c, Qh2c, Qs2c, Kc2c, Kd2c, Kh2c, Ks2c, Ac2c, Ad2c, Ah2c, As2c, 2c2d, 3c2d, 3d2d, 3h2d, 3s2d, 4c2d, 4d2d, 4h2d, 4s2d, 5c2d, 5d2d, 5h2d, 5s2d, 6c2d, 6d2d, 6h2d, 6s2d, 7c2d, 7d2d, 7h2d, 7s2d, 8c2d, 8d2d, 8h2d, 8s2d, 9c2d, 9d2d, 9h2d, 9s2d, Tc2d, Td2d, Th2d, Ts2d, Jc2d, Jd2d, Jh2d, Js2d, Qc2d, Qd2d, Qh2d, Qs2d, Kc2d, Kd2d, Kh2d, Ks2d, Ac2d, Ad2d, Ah2d, As2d, 2c2h, 2d2h, 3c2h, 3d2h, 3h2h, 3s2h, 4c2h, 4d2h, 4h2h, 4s2h, 5c2h, 5d2h, 5h2h, 5s2h, 6c2h, 6d2h, 6h2h, 6s2h, 7c2h, 7d2h, 7h2h, 7s2h, 8c2h, 8d2h, 8h2h, 8s2h, 9c2h, 9d2h, 9h2h, 9s2h, Tc2h, Td2h, Th2h, Ts2h, Jc2h, Jd2h, Jh2h, Js2h, Qc2h, Qd2h, Qh2h, Qs2h, Kc2h, Kd2h, Kh2h, Ks2h, Ac2h, Ad2h, Ah2h, As2h, 2c2s, 2d2s, 2h2s, 3c2s, 3d2s, 3h2s, 3s2s, 4c2s, 4d2s, 4h2s, 4s2s, 5c2s, 5d2s, 5h2s, 5s2s, 6c2s, 6d2s, 6h2s, 6s2s, 7c2s, 7d2s, 7h2s, 7s2s, 8c2s, 8d2s, 8h2s, 8s2s, 9c2s, 9d2s, 9h2s, 9s2s, Tc2s, Td2s, Th2s, Ts2s, Jc2s, Jd2s, Jh2s, Js2s, Qc2s, Qd2s, Qh2s, Qs2s, Kc2s, Kd2s, Kh2s, Ks2s, Ac2s, Ad2s, Ah2s, As2s, 4c3c, 4d3c, 4h3c, 4s3c, 5c3c, 5d3c, 5h3c, 5s3c, 6c3c, 6d3c, 6h3c, 6s3c, 7c3c, 7d3c, 7h3c, 7s3c, 8c3c, 8d3c, 8h3c, 8s3c, 9c3c, 9d3c, 9h3c, 9s3c, Tc3c, Td3c, Th3c, Ts3c, Jc3c, Jd3c, Jh3c, Js3c, Qc3c, Qd3c, Qh3c, Qs3c, Kc3c, Kd3c, Kh3c, Ks3c, Ac3c, Ad3c, Ah3c, As3c, 3c3d, 4c3d, 4d3d, 4h3d, 4s3d, 5c3d, 5d3d, 5h3d, 5s3d, 6c3d, 6d3d, 6h3d, 6s3d, 7c3d, 7d3d, 7h3d, 7s3d, 8c3d, 8d3d, 8h3d, 8s3d, 9c3d, 9d3d, 9h3d, 9s3d, Tc3d, Td3d, Th3d, Ts3d, Jc3d, Jd3d, Jh3d, Js3d, Qc3d, Qd3d, Qh3d, Qs3d, Kc3d, Kd3d, Kh3d, Ks3d, Ac3d, Ad3d, Ah3d, As3d, 3c3h, 3d3h, 4c3h, 4d3h, 4h3h, 4s3h, 5c3h, 5d3h, 5h3h, 5s3h, 6c3h, 6d3h, 6h3h, 6s3h, 7c3h, 7d3h, 7h3h, 7s3h, 8c3h, 8d3h, 8h3h, 8s3h, 9c3h, 9d3h, 9h3h, 9s3h, Tc3h, Td3h, Th3h, Ts3h, Jc3h, Jd3h, Jh3h, Js3h, Qc3h, Qd3h, Qh3h, Qs3h, Kc3h, Kd3h, Kh3h, Ks3h, Ac3h, Ad3h, Ah3h, As3h, 3c3s, 3d3s, 3h3s, 4c3s, 4d3s, 4h3s, 4s3s, 5c3s, 5d3s, 5h3s, 5s3s, 6c3s, 6d3s, 6h3s, 6s3s, 7c3s, 7d3s, 7h3s, 7s3s, 8c3s, 8d3s, 8h3s, 8s3s, 9c3s, 9d3s, 9h3s, 9s3s, Tc3s, Td3s, Th3s, Ts3s, Jc3s, Jd3s, Jh3s, Js3s, Qc3s, Qd3s, Qh3s, Qs3s, Kc3s, Kd3s, Kh3s, Ks3s, Ac3s, Ad3s, Ah3s, As3s, 5c4c, 5d4c, 5h4c, 5s4c, 6c4c, 6d4c, 6h4c, 6s4c, 7c4c, 7d4c, 7h4c, 7s4c, 8c4c, 8d4c, 8h4c, 8s4c, 9c4c, 9d4c, 9h4c, 9s4c, Tc4c, Td4c, Th4c, Ts4c, Jc4c, Jd4c, Jh4c, Js4c, Qc4c, Qd4c, Qh4c, Qs4c, Kc4c, Kd4c, Kh4c, Ks4c, Ac4c, Ad4c, Ah4c, As4c, 4c4d, 5c4d, 5d4d, 5h4d, 5s4d, 6c4d, 6d4d, 6h4d, 6s4d, 7c4d, 7d4d, 7h4d, 7s4d, 8c4d, 8d4d, 8h4d, 8s4d, 9c4d, 9d4d, 9h4d, 9s4d, Tc4d, Td4d, Th4d, Ts4d, Jc4d, Jd4d, Jh4d, Js4d, Qc4d, Qd4d, Qh4d, Qs4d, Kc4d, Kd4d, Kh4d, Ks4d, Ac4d, Ad4d, Ah4d, As4d, 4c4h, 4d4h, 5c4h, 5d4h, 5h4h, 5s4h, 6c4h, 6d4h, 6h4h, 6s4h, 7c4h, 7d4h, 7h4h, 7s4h, 8c4h, 8d4h, 8h4h, 8s4h, 9c4h, 9d4h, 9h4h, 9s4h, Tc4h, Td4h, Th4h, Ts4h, Jc4h, Jd4h, Jh4h, Js4h, Qc4h, Qd4h, Qh4h, Qs4h, Kc4h, Kd4h, Kh4h, Ks4h, Ac4h, Ad4h, Ah4h, As4h, 4c4s, 4d4s, 4h4s, 5c4s, 5d4s, 5h4s, 5s4s, 6c4s, 6d4s, 6h4s, 6s4s, 7c4s, 7d4s, 7h4s, 7s4s, 8c4s, 8d4s, 8h4s, 8s4s, 9c4s, 9d4s, 9h4s, 9s4s, Tc4s, Td4s, Th4s, Ts4s, Jc4s, Jd4s, Jh4s, Js4s, Qc4s, Qd4s, Qh4s, Qs4s, Kc4s, Kd4s, Kh4s, Ks4s, Ac4s, Ad4s, Ah4s, As4s, 6c5c, 6d5c, 6h5c, 6s5c, 7c5c, 7d5c, 7h5c, 7s5c, 8c5c, 8d5c, 8h5c, 8s5c, 9c5c, 9d5c, 9h5c, 9s5c, Tc5c, Td5c, Th5c, Ts5c, Jc5c, Jd5c, Jh5c, Js5c, Qc5c, Qd5c, Qh5c, Qs5c, Kc5c, Kd5c, Kh5c, Ks5c, Ac5c, Ad5c, Ah5c, As5c, 5c5d, 6c5d, 6d5d, 6h5d, 6s5d, 7c5d, 7d5d, 7h5d, 7s5d, 8c5d, 8d5d, 8h5d, 8s5d, 9c5d, 9d5d, 9h5d, 9s5d, Tc5d, Td5d, Th5d, Ts5d, Jc5d, Jd5d, Jh5d, Js5d, Qc5d, Qd5d, Qh5d, Qs5d, Kc5d, Kd5d, Kh5d, Ks5d, Ac5d, Ad5d, Ah5d, As5d, 5c5h, 5d5h, 6c5h, 6d5h, 6h5h, 6s5h, 7c5h, 7d5h, 7h5h, 7s5h, 8c5h, 8d5h, 8h5h, 8s5h, 9c5h, 9d5h, 9h5h, 9s5h, Tc5h, Td5h, Th5h, Ts5h, Jc5h, Jd5h, Jh5h, Js5h, Qc5h, Qd5h, Qh5h, Qs5h, Kc5h, Kd5h, Kh5h, Ks5h, Ac5h, Ad5h, Ah5h, As5h, 5c5s, 5d5s, 5h5s, 6c5s, 6d5s, 6h5s, 6s5s, 7c5s, 7d5s, 7h5s, 7s5s, 8c5s, 8d5s, 8h5s, 8s5s, 9c5s, 9d5s, 9h5s, 9s5s, Tc5s, Td5s, Th5s, Ts5s, Jc5s, Jd5s, Jh5s, Js5s, Qc5s, Qd5s, Qh5s, Qs5s, Kc5s, Kd5s, Kh5s, Ks5s, Ac5s, Ad5s, Ah5s, As5s, 7c6c, 7d6c, 7h6c, 7s6c, 8c6c, 8d6c, 8h6c, 8s6c, 9c6c, 9d6c, 9h6c, 9s6c, Tc6c, Td6c, Th6c, Ts6c, Jc6c, Jd6c, Jh6c, Js6c, Qc6c, Qd6c, Qh6c, Qs6c, Kc6c, Kd6c, Kh6c, Ks6c, Ac6c, Ad6c, Ah6c, As6c, 6c6d, 7c6d, 7d6d, 7h6d, 7s6d, 8c6d, 8d6d, 8h6d, 8s6d, 9c6d, 9d6d, 9h6d, 9s6d, Tc6d, Td6d, Th6d, Ts6d, Jc6d, Jd6d, Jh6d, Js6d, Qc6d, Qd6d, Qh6d, Qs6d, Kc6d, Kd6d, Kh6d, Ks6d, Ac6d, Ad6d, Ah6d, As6d, 6c6h, 6d6h, 7c6h, 7d6h, 7h6h, 7s6h, 8c6h, 8d6h, 8h6h, 8s6h, 9c6h, 9d6h, 9h6h, 9s6h, Tc6h, Td6h, Th6h, Ts6h, Jc6h, Jd6h, Jh6h, Js6h, Qc6h, Qd6h, Qh6h, Qs6h, Kc6h, Kd6h, Kh6h, Ks6h, Ac6h, Ad6h, Ah6h, As6h, 6c6s, 6d6s, 6h6s, 7c6s, 7d6s, 7h6s, 7s6s, 8c6s, 8d6s, 8h6s, 8s6s, 9c6s, 9d6s, 9h6s, 9s6s, Tc6s, Td6s, Th6s, Ts6s, Jc6s, Jd6s, Jh6s, Js6s, Qc6s, Qd6s, Qh6s, Qs6s, Kc6s, Kd6s, Kh6s, Ks6s, Ac6s, Ad6s, Ah6s, As6s, 8c7c, 8d7c, 8h7c, 8s7c, 9c7c, 9d7c, 9h7c, 9s7c, Tc7c, Td7c, Th7c, Ts7c, Jc7c, Jd7c, Jh7c, Js7c, Qc7c, Qd7c, Qh7c, Qs7c, Kc7c, Kd7c, Kh7c, Ks7c, Ac7c, Ad7c, Ah7c, As7c, 7c7d, 8c7d, 8d7d, 8h7d, 8s7d, 9c7d, 9d7d, 9h7d, 9s7d, Tc7d, Td7d, Th7d, Ts7d, Jc7d, Jd7d, Jh7d, Js7d, Qc7d, Qd7d, Qh7d, Qs7d, Kc7d, Kd7d, Kh7d, Ks7d, Ac7d, Ad7d, Ah7d, As7d, 7c7h, 7d7h, 8c7h, 8d7h, 8h7h, 8s7h, 9c7h, 9d7h, 9h7h, 9s7h, Tc7h, Td7h, Th7h, Ts7h, Jc7h, Jd7h, Jh7h, Js7h, Qc7h, Qd7h, Qh7h, Qs7h, Kc7h, Kd7h, Kh7h, Ks7h, Ac7h, Ad7h, Ah7h, As7h, 7c7s, 7d7s, 7h7s, 8c7s, 8d7s, 8h7s, 8s7s, 9c7s, 9d7s, 9h7s, 9s7s, Tc7s, Td7s, Th7s, Ts7s, Jc7s, Jd7s, Jh7s, Js7s, Qc7s, Qd7s, Qh7s, Qs7s, Kc7s, Kd7s, Kh7s, Ks7s, Ac7s, Ad7s, Ah7s, As7s, 9c8c, 9d8c, 9h8c, 9s8c, Tc8c, Td8c, Th8c, Ts8c, Jc8c, Jd8c, Jh8c, Js8c, Qc8c, Qd8c, Qh8c, Qs8c, Kc8c, Kd8c, Kh8c, Ks8c, Ac8c, Ad8c, Ah8c, As8c, 8c8d, 9c8d, 9d8d, 9h8d, 9s8d, Tc8d, Td8d, Th8d, Ts8d, Jc8d, Jd8d, Jh8d, Js8d, Qc8d, Qd8d, Qh8d, Qs8d, Kc8d, Kd8d, Kh8d, Ks8d, Ac8d, Ad8d, Ah8d, As8d, 8c8h, 8d8h, 9c8h, 9d8h, 9h8h, 9s8h, Tc8h, Td8h, Th8h, Ts8h, Jc8h, Jd8h, Jh8h, Js8h, Qc8h, Qd8h, Qh8h, Qs8h, Kc8h, Kd8h, Kh8h, Ks8h, Ac8h, Ad8h, Ah8h, As8h, 8c8s, 8d8s, 8h8s, 9c8s, 9d8s, 9h8s, 9s8s, Tc8s, Td8s, Th8s, Ts8s, Jc8s, Jd8s, Jh8s, Js8s, Qc8s, Qd8s, Qh8s, Qs8s, Kc8s, Kd8s, Kh8s, Ks8s, Ac8s, Ad8s, Ah8s, As8s, Tc9c, Td9c, Th9c, Ts9c, Jc9c, Jd9c, Jh9c, Js9c, Qc9c, Qd9c, Qh9c, Qs9c, Kc9c, Kd9c, Kh9c, Ks9c, Ac9c, Ad9c, Ah9c, As9c, 9c9d, Tc9d, Td9d, Th9d, Ts9d, Jc9d, Jd9d, Jh9d, Js9d, Qc9d, Qd9d, Qh9d, Qs9d, Kc9d, Kd9d, Kh9d, Ks9d, Ac9d, Ad9d, Ah9d, As9d, 9c9h, 9d9h, Tc9h, Td9h, Th9h, Ts9h, Jc9h, Jd9h, Jh9h, Js9h, Qc9h, Qd9h, Qh9h, Qs9h, Kc9h, Kd9h, Kh9h, Ks9h, Ac9h, Ad9h, Ah9h, As9h, 9c9s, 9d9s, 9h9s, Tc9s, Td9s, Th9s, Ts9s, Jc9s, Jd9s, Jh9s, Js9s, Qc9s, Qd9s, Qh9s, Qs9s, Kc9s, Kd9s, Kh9s, Ks9s, Ac9s, Ad9s, Ah9s, As9s, JcTc, JdTc, JhTc, JsTc, QcTc, QdTc, QhTc, QsTc, KcTc, KdTc, KhTc, KsTc, AcTc, AdTc, AhTc, AsTc, TcTd, JcTd, JdTd, JhTd, JsTd, QcTd, QdTd, QhTd, QsTd, KcTd, KdTd, KhTd, KsTd, AcTd, AdTd, AhTd, AsTd, TcTh, TdTh, JcTh, JdTh, JhTh, JsTh, QcTh, QdTh, QhTh, QsTh, KcTh, KdTh, KhTh, KsTh, AcTh, AdTh, AhTh, AsTh, TcTs, TdTs, ThTs, JcTs, JdTs, JhTs, JsTs, QcTs, QdTs, QhTs, QsTs, KcTs, KdTs, KhTs, KsTs, AcTs, AdTs, AhTs, AsTs, QcJc, QdJc, QhJc, QsJc, KcJc, KdJc, KhJc, KsJc, AcJc, AdJc, AhJc, AsJc, JcJd, QcJd, QdJd, QhJd, QsJd, KcJd, KdJd, KhJd, KsJd, AcJd, AdJd, AhJd, AsJd, JcJh, JdJh, QcJh, QdJh, QhJh, QsJh, KcJh, KdJh, KhJh, KsJh, AcJh, AdJh, AhJh, AsJh, JcJs, JdJs, JhJs, QcJs, QdJs, QhJs, QsJs, KcJs, KdJs, KhJs, KsJs, AcJs, AdJs, AhJs, AsJs, KcQc, KdQc, KhQc, KsQc, AcQc, AdQc, AhQc, AsQc, QcQd, KcQd, KdQd, KhQd, KsQd, AcQd, AdQd, AhQd, AsQd, QcQh, QdQh, KcQh, KdQh, KhQh, KsQh, AcQh, AdQh, AhQh, AsQh, QcQs, QdQs, QhQs, KcQs, KdQs, KhQs, KsQs, AcQs, AdQs, AhQs, AsQs, AcKc, AdKc, AhKc, AsKc, KcKd, AcKd, AdKd, AhKd, AsKd, KcKh, KdKh, AcKh, AdKh, AhKh, AsKh, KcKs, KdKs, KhKs, AcKs, AdKs, AhKs, AsKs, AcAd, AcAh, AdAh, AcAs, AdAs, AhAs

To get things going, here is my embarrassingly easy to beat answer in python:

    acs = []
    ac = []
    rs = 'AKQJT98765432'
    for r in rs:
        for s in 'schd':
            ac.append(r+s)
    for c in ac:
        for i in ac:
            if (i != c) and (rs.index(i[0]) <= rs.index(c[0]) and (i+c not in acs) and (c+i not in acs)):
                acs.append(i+c)
    print(acs)

@WheatWizard The title and the question both say "in shortest amount of code"

I also think this challenge is vastly under-specified.  Since the output is constant it would be nice if you could include it in the body of the question, or if it is too large describe it in a more rigorous manner.  Until then I am voting to close this temporarily as unclear.

I added some detail and definitions and specified output format. Hopefully it's clearer - feel free to rollback or edit it!

I'm so confused how this is on hold. The question is so over explained its crazy. You have the desired output, you have the goal (shortest code), Jonathan Allen posted a great answer. I posted a weak (but valid) answer. How is this "vastly under specified"??? I seriously don't even get what to do to fix it if this is not acceptable.

@lessharm yeah - it had 4 close votes for "unclear" prior to my update to (over) clarify the question, and since then the 5th close vote came in (which is pretty shocking!) I've voted to reopen and so has one other person, but it needs two more votes...

Its too bad the people that will happily down vote it wont explain why. It was up for a couple hours and got 5+ votes in that time, so clearly people were interested in it.

Jelly, 21 bytes
9Ḋ;“TJQKA”Ṛp“cdhs”ŒcK

A full program printing the combos* separated by spaces (as a niladic link without the trailing K the result would be a list of combos, where each combo is a list of lists, with integers for 2-9 and characters for other parts).
Try it online! (Note: change the trailing K to L and it will display the length of the list, 1326.)
How?
9Ḋ;“TJQKA”Ṛp“cdhs”ŒcK - Main link: no arguments
9Ḋ                    - nine dequeued               [2,3,4,5,6,7,8,9]
   “TJQKA”            - literal list of characters  ['T','J','Q','K','A']
  ;                   - concatenate                 [2,3,4,5,6,7,8,9,'T','J','Q','K','A']
          Ṛ           - reverse                     ['A','K','Q','J','T',9,8,7,6,5,4,3,2]
            “cdhs”    - literal list of characters  ['c','d','h','s']
           p          - Cartesian product           [['A','c'],['A','d'], ... ,[2,'s']]
                  Œc  - Unordered pairs             [[['A','c'],['A','d']], ...(1326)...]
                    K - join with spaces (to pretty print, otherwise they all run
                      -   together like AcAdAcAhAcAsAcKdAcKhAcKs...2d2h2d2s2h2s)

* it's what the kids call 'em!

Great explanation, just spent 30 minutes reading about Cartesian products :D

...and I noticed you used "combos" in the title too :D - next up Badugi!

First Badugi challenge is now in the sandbox

Nice Badugi challenge.. explanation looks good to me. Would make an attempt in Python if you post. Have been checking out Jelly too after seeing your answer. Might try that out on some simpler questions.

FYI - I just posted that question.

Python 2, 100 98 bytes
r=range
d=lambda i:'AKQJT98765432'[i/4]+'cdhs'[i%4]
for u in r(52):
 for t in r(u):print d(t)+d(u)

-2 bytes from dylnan
Try it online!
d maps the numbers from 0 to 51 to card names such that they keep their sorting order (0-3 -> Aces, 4-7 -> Kings, etc)
The program loops over all pairs of numbers 0-51 where the second is greater than the first, and prints the pair of cards corresponding to that pair of numbers.

98 bytes (you don't need the last newline and tab for the print statement). 98 byte alternative with one for loop and list comprehension.

Bash+sed, 90 bytes
printf %s\\n {{2..9},T,J,Q,K,A}{c,d,h,s}{{2..9},T,J,Q,K,A}{c,d,h,s}|sed '/\(..\)\1/,/As/d'

The Bash brace-expansion generates the cross-join of all pairs in ascending order (using the Bridge ordering of the suits).  The Sed command removes the unwanted pairs: for each leading card C, we eliminate the same-card pair (C C) and all subsequent pairs (i.e. all trailing cards higher than C) until we see and remove the Ace of Spades (C As).  After that, there's new leading card and we repeat until we finally remove AsAs and the input ends.
Output
Piped through rs 0 26 to make it fit better:
2d2c  2h2c  2h2d  2s2c  2s2d  2s2h  3c2c  3c2d  3c2h  3c2s  3d2c  3d2d  3d2h  3d2s  3d3c  3h2c  3h2d  3h2h  3h2s  3h3c  3h3d  3s2c  3s2d  3s2h  3s2s  3s3c
3s3d  3s3h  4c2c  4c2d  4c2h  4c2s  4c3c  4c3d  4c3h  4c3s  4d2c  4d2d  4d2h  4d2s  4d3c  4d3d  4d3h  4d3s  4d4c  4h2c  4h2d  4h2h  4h2s  4h3c  4h3d  4h3h
4h3s  4h4c  4h4d  4s2c  4s2d  4s2h  4s2s  4s3c  4s3d  4s3h  4s3s  4s4c  4s4d  4s4h  5c2c  5c2d  5c2h  5c2s  5c3c  5c3d  5c3h  5c3s  5c4c  5c4d  5c4h  5c4s
5d2c  5d2d  5d2h  5d2s  5d3c  5d3d  5d3h  5d3s  5d4c  5d4d  5d4h  5d4s  5d5c  5h2c  5h2d  5h2h  5h2s  5h3c  5h3d  5h3h  5h3s  5h4c  5h4d  5h4h  5h4s  5h5c
5h5d  5s2c  5s2d  5s2h  5s2s  5s3c  5s3d  5s3h  5s3s  5s4c  5s4d  5s4h  5s4s  5s5c  5s5d  5s5h  6c2c  6c2d  6c2h  6c2s  6c3c  6c3d  6c3h  6c3s  6c4c  6c4d
6c4h  6c4s  6c5c  6c5d  6c5h  6c5s  6d2c  6d2d  6d2h  6d2s  6d3c  6d3d  6d3h  6d3s  6d4c  6d4d  6d4h  6d4s  6d5c  6d5d  6d5h  6d5s  6d6c  6h2c  6h2d  6h2h
6h2s  6h3c  6h3d  6h3h  6h3s  6h4c  6h4d  6h4h  6h4s  6h5c  6h5d  6h5h  6h5s  6h6c  6h6d  6s2c  6s2d  6s2h  6s2s  6s3c  6s3d  6s3h  6s3s  6s4c  6s4d  6s4h
6s4s  6s5c  6s5d  6s5h  6s5s  6s6c  6s6d  6s6h  7c2c  7c2d  7c2h  7c2s  7c3c  7c3d  7c3h  7c3s  7c4c  7c4d  7c4h  7c4s  7c5c  7c5d  7c5h  7c5s  7c6c  7c6d
7c6h  7c6s  7d2c  7d2d  7d2h  7d2s  7d3c  7d3d  7d3h  7d3s  7d4c  7d4d  7d4h  7d4s  7d5c  7d5d  7d5h  7d5s  7d6c  7d6d  7d6h  7d6s  7d7c  7h2c  7h2d  7h2h
7h2s  7h3c  7h3d  7h3h  7h3s  7h4c  7h4d  7h4h  7h4s  7h5c  7h5d  7h5h  7h5s  7h6c  7h6d  7h6h  7h6s  7h7c  7h7d  7s2c  7s2d  7s2h  7s2s  7s3c  7s3d  7s3h
7s3s  7s4c  7s4d  7s4h  7s4s  7s5c  7s5d  7s5h  7s5s  7s6c  7s6d  7s6h  7s6s  7s7c  7s7d  7s7h  8c2c  8c2d  8c2h  8c2s  8c3c  8c3d  8c3h  8c3s  8c4c  8c4d
8c4h  8c4s  8c5c  8c5d  8c5h  8c5s  8c6c  8c6d  8c6h  8c6s  8c7c  8c7d  8c7h  8c7s  8d2c  8d2d  8d2h  8d2s  8d3c  8d3d  8d3h  8d3s  8d4c  8d4d  8d4h  8d4s
8d5c  8d5d  8d5h  8d5s  8d6c  8d6d  8d6h  8d6s  8d7c  8d7d  8d7h  8d7s  8d8c  8h2c  8h2d  8h2h  8h2s  8h3c  8h3d  8h3h  8h3s  8h4c  8h4d  8h4h  8h4s  8h5c
8h5d  8h5h  8h5s  8h6c  8h6d  8h6h  8h6s  8h7c  8h7d  8h7h  8h7s  8h8c  8h8d  8s2c  8s2d  8s2h  8s2s  8s3c  8s3d  8s3h  8s3s  8s4c  8s4d  8s4h  8s4s  8s5c
8s5d  8s5h  8s5s  8s6c  8s6d  8s6h  8s6s  8s7c  8s7d  8s7h  8s7s  8s8c  8s8d  8s8h  9c2c  9c2d  9c2h  9c2s  9c3c  9c3d  9c3h  9c3s  9c4c  9c4d  9c4h  9c4s
9c5c  9c5d  9c5h  9c5s  9c6c  9c6d  9c6h  9c6s  9c7c  9c7d  9c7h  9c7s  9c8c  9c8d  9c8h  9c8s  9d2c  9d2d  9d2h  9d2s  9d3c  9d3d  9d3h  9d3s  9d4c  9d4d
9d4h  9d4s  9d5c  9d5d  9d5h  9d5s  9d6c  9d6d  9d6h  9d6s  9d7c  9d7d  9d7h  9d7s  9d8c  9d8d  9d8h  9d8s  9d9c  9h2c  9h2d  9h2h  9h2s  9h3c  9h3d  9h3h
9h3s  9h4c  9h4d  9h4h  9h4s  9h5c  9h5d  9h5h  9h5s  9h6c  9h6d  9h6h  9h6s  9h7c  9h7d  9h7h  9h7s  9h8c  9h8d  9h8h  9h8s  9h9c  9h9d  9s2c  9s2d  9s2h
9s2s  9s3c  9s3d  9s3h  9s3s  9s4c  9s4d  9s4h  9s4s  9s5c  9s5d  9s5h  9s5s  9s6c  9s6d  9s6h  9s6s  9s7c  9s7d  9s7h  9s7s  9s8c  9s8d  9s8h  9s8s  9s9c
9s9d  9s9h  Tc2c  Tc2d  Tc2h  Tc2s  Tc3c  Tc3d  Tc3h  Tc3s  Tc4c  Tc4d  Tc4h  Tc4s  Tc5c  Tc5d  Tc5h  Tc5s  Tc6c  Tc6d  Tc6h  Tc6s  Tc7c  Tc7d  Tc7h  Tc7s
Tc8c  Tc8d  Tc8h  Tc8s  Tc9c  Tc9d  Tc9h  Tc9s  Td2c  Td2d  Td2h  Td2s  Td3c  Td3d  Td3h  Td3s  Td4c  Td4d  Td4h  Td4s  Td5c  Td5d  Td5h  Td5s  Td6c  Td6d
Td6h  Td6s  Td7c  Td7d  Td7h  Td7s  Td8c  Td8d  Td8h  Td8s  Td9c  Td9d  Td9h  Td9s  TdTc  Th2c  Th2d  Th2h  Th2s  Th3c  Th3d  Th3h  Th3s  Th4c  Th4d  Th4h
Th4s  Th5c  Th5d  Th5h  Th5s  Th6c  Th6d  Th6h  Th6s  Th7c  Th7d  Th7h  Th7s  Th8c  Th8d  Th8h  Th8s  Th9c  Th9d  Th9h  Th9s  ThTc  ThTd  Ts2c  Ts2d  Ts2h
Ts2s  Ts3c  Ts3d  Ts3h  Ts3s  Ts4c  Ts4d  Ts4h  Ts4s  Ts5c  Ts5d  Ts5h  Ts5s  Ts6c  Ts6d  Ts6h  Ts6s  Ts7c  Ts7d  Ts7h  Ts7s  Ts8c  Ts8d  Ts8h  Ts8s  Ts9c
Ts9d  Ts9h  Ts9s  TsTc  TsTd  TsTh  Jc2c  Jc2d  Jc2h  Jc2s  Jc3c  Jc3d  Jc3h  Jc3s  Jc4c  Jc4d  Jc4h  Jc4s  Jc5c  Jc5d  Jc5h  Jc5s  Jc6c  Jc6d  Jc6h  Jc6s
Jc7c  Jc7d  Jc7h  Jc7s  Jc8c  Jc8d  Jc8h  Jc8s  Jc9c  Jc9d  Jc9h  Jc9s  JcTc  JcTd  JcTh  JcTs  Jd2c  Jd2d  Jd2h  Jd2s  Jd3c  Jd3d  Jd3h  Jd3s  Jd4c  Jd4d
Jd4h  Jd4s  Jd5c  Jd5d  Jd5h  Jd5s  Jd6c  Jd6d  Jd6h  Jd6s  Jd7c  Jd7d  Jd7h  Jd7s  Jd8c  Jd8d  Jd8h  Jd8s  Jd9c  Jd9d  Jd9h  Jd9s  JdTc  JdTd  JdTh  JdTs
JdJc  Jh2c  Jh2d  Jh2h  Jh2s  Jh3c  Jh3d  Jh3h  Jh3s  Jh4c  Jh4d  Jh4h  Jh4s  Jh5c  Jh5d  Jh5h  Jh5s  Jh6c  Jh6d  Jh6h  Jh6s  Jh7c  Jh7d  Jh7h  Jh7s  Jh8c
Jh8d  Jh8h  Jh8s  Jh9c  Jh9d  Jh9h  Jh9s  JhTc  JhTd  JhTh  JhTs  JhJc  JhJd  Js2c  Js2d  Js2h  Js2s  Js3c  Js3d  Js3h  Js3s  Js4c  Js4d  Js4h  Js4s  Js5c
Js5d  Js5h  Js5s  Js6c  Js6d  Js6h  Js6s  Js7c  Js7d  Js7h  Js7s  Js8c  Js8d  Js8h  Js8s  Js9c  Js9d  Js9h  Js9s  JsTc  JsTd  JsTh  JsTs  JsJc  JsJd  JsJh
Qc2c  Qc2d  Qc2h  Qc2s  Qc3c  Qc3d  Qc3h  Qc3s  Qc4c  Qc4d  Qc4h  Qc4s  Qc5c  Qc5d  Qc5h  Qc5s  Qc6c  Qc6d  Qc6h  Qc6s  Qc7c  Qc7d  Qc7h  Qc7s  Qc8c  Qc8d
Qc8h  Qc8s  Qc9c  Qc9d  Qc9h  Qc9s  QcTc  QcTd  QcTh  QcTs  QcJc  QcJd  QcJh  QcJs  Qd2c  Qd2d  Qd2h  Qd2s  Qd3c  Qd3d  Qd3h  Qd3s  Qd4c  Qd4d  Qd4h  Qd4s
Qd5c  Qd5d  Qd5h  Qd5s  Qd6c  Qd6d  Qd6h  Qd6s  Qd7c  Qd7d  Qd7h  Qd7s  Qd8c  Qd8d  Qd8h  Qd8s  Qd9c  Qd9d  Qd9h  Qd9s  QdTc  QdTd  QdTh  QdTs  QdJc  QdJd
QdJh  QdJs  QdQc  Qh2c  Qh2d  Qh2h  Qh2s  Qh3c  Qh3d  Qh3h  Qh3s  Qh4c  Qh4d  Qh4h  Qh4s  Qh5c  Qh5d  Qh5h  Qh5s  Qh6c  Qh6d  Qh6h  Qh6s  Qh7c  Qh7d  Qh7h
Qh7s  Qh8c  Qh8d  Qh8h  Qh8s  Qh9c  Qh9d  Qh9h  Qh9s  QhTc  QhTd  QhTh  QhTs  QhJc  QhJd  QhJh  QhJs  QhQc  QhQd  Qs2c  Qs2d  Qs2h  Qs2s  Qs3c  Qs3d  Qs3h
Qs3s  Qs4c  Qs4d  Qs4h  Qs4s  Qs5c  Qs5d  Qs5h  Qs5s  Qs6c  Qs6d  Qs6h  Qs6s  Qs7c  Qs7d  Qs7h  Qs7s  Qs8c  Qs8d  Qs8h  Qs8s  Qs9c  Qs9d  Qs9h  Qs9s  QsTc
QsTd  QsTh  QsTs  QsJc  QsJd  QsJh  QsJs  QsQc  QsQd  QsQh  Kc2c  Kc2d  Kc2h  Kc2s  Kc3c  Kc3d  Kc3h  Kc3s  Kc4c  Kc4d  Kc4h  Kc4s  Kc5c  Kc5d  Kc5h  Kc5s
Kc6c  Kc6d  Kc6h  Kc6s  Kc7c  Kc7d  Kc7h  Kc7s  Kc8c  Kc8d  Kc8h  Kc8s  Kc9c  Kc9d  Kc9h  Kc9s  KcTc  KcTd  KcTh  KcTs  KcJc  KcJd  KcJh  KcJs  KcQc  KcQd
KcQh  KcQs  Kd2c  Kd2d  Kd2h  Kd2s  Kd3c  Kd3d  Kd3h  Kd3s  Kd4c  Kd4d  Kd4h  Kd4s  Kd5c  Kd5d  Kd5h  Kd5s  Kd6c  Kd6d  Kd6h  Kd6s  Kd7c  Kd7d  Kd7h  Kd7s
Kd8c  Kd8d  Kd8h  Kd8s  Kd9c  Kd9d  Kd9h  Kd9s  KdTc  KdTd  KdTh  KdTs  KdJc  KdJd  KdJh  KdJs  KdQc  KdQd  KdQh  KdQs  KdKc  Kh2c  Kh2d  Kh2h  Kh2s  Kh3c
Kh3d  Kh3h  Kh3s  Kh4c  Kh4d  Kh4h  Kh4s  Kh5c  Kh5d  Kh5h  Kh5s  Kh6c  Kh6d  Kh6h  Kh6s  Kh7c  Kh7d  Kh7h  Kh7s  Kh8c  Kh8d  Kh8h  Kh8s  Kh9c  Kh9d  Kh9h
Kh9s  KhTc  KhTd  KhTh  KhTs  KhJc  KhJd  KhJh  KhJs  KhQc  KhQd  KhQh  KhQs  KhKc  KhKd  Ks2c  Ks2d  Ks2h  Ks2s  Ks3c  Ks3d  Ks3h  Ks3s  Ks4c  Ks4d  Ks4h
Ks4s  Ks5c  Ks5d  Ks5h  Ks5s  Ks6c  Ks6d  Ks6h  Ks6s  Ks7c  Ks7d  Ks7h  Ks7s  Ks8c  Ks8d  Ks8h  Ks8s  Ks9c  Ks9d  Ks9h  Ks9s  KsTc  KsTd  KsTh  KsTs  KsJc
KsJd  KsJh  KsJs  KsQc  KsQd  KsQh  KsQs  KsKc  KsKd  KsKh  Ac2c  Ac2d  Ac2h  Ac2s  Ac3c  Ac3d  Ac3h  Ac3s  Ac4c  Ac4d  Ac4h  Ac4s  Ac5c  Ac5d  Ac5h  Ac5s
Ac6c  Ac6d  Ac6h  Ac6s  Ac7c  Ac7d  Ac7h  Ac7s  Ac8c  Ac8d  Ac8h  Ac8s  Ac9c  Ac9d  Ac9h  Ac9s  AcTc  AcTd  AcTh  AcTs  AcJc  AcJd  AcJh  AcJs  AcQc  AcQd
AcQh  AcQs  AcKc  AcKd  AcKh  AcKs  Ad2c  Ad2d  Ad2h  Ad2s  Ad3c  Ad3d  Ad3h  Ad3s  Ad4c  Ad4d  Ad4h  Ad4s  Ad5c  Ad5d  Ad5h  Ad5s  Ad6c  Ad6d  Ad6h  Ad6s
Ad7c  Ad7d  Ad7h  Ad7s  Ad8c  Ad8d  Ad8h  Ad8s  Ad9c  Ad9d  Ad9h  Ad9s  AdTc  AdTd  AdTh  AdTs  AdJc  AdJd  AdJh  AdJs  AdQc  AdQd  AdQh  AdQs  AdKc  AdKd
AdKh  AdKs  AdAc  Ah2c  Ah2d  Ah2h  Ah2s  Ah3c  Ah3d  Ah3h  Ah3s  Ah4c  Ah4d  Ah4h  Ah4s  Ah5c  Ah5d  Ah5h  Ah5s  Ah6c  Ah6d  Ah6h  Ah6s  Ah7c  Ah7d  Ah7h
Ah7s  Ah8c  Ah8d  Ah8h  Ah8s  Ah9c  Ah9d  Ah9h  Ah9s  AhTc  AhTd  AhTh  AhTs  AhJc  AhJd  AhJh  AhJs  AhQc  AhQd  AhQh  AhQs  AhKc  AhKd  AhKh  AhKs  AhAc
AhAd  As2c  As2d  As2h  As2s  As3c  As3d  As3h  As3s  As4c  As4d  As4h  As4s  As5c  As5d  As5h  As5s  As6c  As6d  As6h  As6s  As7c  As7d  As7h  As7s  As8c
As8d  As8h  As8s  As9c  As9d  As9h  As9s  AsTc  AsTd  AsTh  AsTs  AsJc  AsJd  AsJh  AsJs  AsQc  AsQd  AsQh  AsQs  AsKc  AsKd  AsKh  AsKs  AsAc  AsAd  AsAh

Perl 5, 73 bytes
@,=map{/./;map$&.$_,c,d,h,'s'}2..9,T,J,Q,K,A;map{say$i,$_}@,while$i=pop@,

Try it online!


text:
The greedy regex (robbers)
This is the robbers' post. The cops' is here.
Your challenge is to take a cop's post and find an input that the regex matches but the program returns a falsey value.
Once you have cracked a cop's post, comment in a link to your crack. (If you don't have enough rep to comment, please say so, and someone will do it for you.) The robber with the most cracks wins.
Example
Let's say a cop's regex is (all of the flavors):
/^[0-9]$/

And the program is (JS):
x=>Boolean(parseInt(x))

Than a valid crack would be 0, because the regex matches 0 but 0 is falsey.

Python, ppperry
\n

Try it online!
. doesn't match newline by default.

Python 3, pperry
İ

Try it online!
The lower case variant i̇ of this character is created by a an i and a ċȯṁḃi̇̇ṅi̇̇ṅġ ḋȯṫ which results in a length of 2.

That was the intended solution!

JavaScript, ThePirateBay
Solution:
Try it online!

Java, Roman Gräf
is.is.is.is.

Try it online!
Most things which match the regex crack it, so I'm not sure if the regex is what was intended

I think the cop misunderstood the challenge, and that you misunderstood the regex : you're right that getting a false from the program while having the regex match is trivial, even more so than you think since (?is) is java's shorthand flag notation and turns on case-insensitivity and single-line mode for the rest of the regex, rather than the positive lookahead which it looks like you understood it as. (little illustration)

@Aaron I've used those flags before so I really should have noticed that. If you would like to post an answer assuming the cop had true and false switches I encourage it since you spotted the intended answer

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
The greedy regex (cops)
This is the cops' post. The robbers' is here.
You make a program and a regex.
For most inputs, one of the following happens:

the regex doesn't match, and the program returns a falsey value
the regex doesn't match, and the program returns a truthy value
the regex matches, and the program returns a truthy value

But for one (or more) input, the regex matches, but the program returns a falsy value.
You should try to keep this input hidden. Robbers will try to find an input where the regex matches, but the program returns a falsy value.
Post your program and your regex, as well as your language name, byte count of the program, regex flavor, and byte count of the regex.
If a robber finds an input where the regex matches, but the program returns a falsy value, even if it wasn't the intended input your program is considered cracked, and you edit in a link to the robber's crack.
If nobody has cracked your program & regex after a week, then edit in that your submission is safe and is therefore not eligible for cracking. Also edit in the intended input. The shortest (program bytes + regex bytes) non-cracked submission wins.
Example
Let's say your regex is (all of the flavors):
/^[0-9]$/

And your program is (JS):
x=>Boolean(parseInt(x))

Then a valid crack would be 0, because the regex matches 0 but 0 is falsey.
Delimiters don't count in the byte count.
I can't enforce the banning of hash functions with rules, but please don't use SHA/RSA or anything that is unfair to the robbers

Are cryptographic hash functions allowed? I can imagine regex (..)+ and program print hash(input)==...

Python, cracked
Regex: (?!.)
Program: from operator import not_
This is a little easier than my previous one.

JavaScript (Cracked)
Regex: ..
Program: a=>[...a].length-1
This is an easy one.

Intended solution

Cracked

JavaScript ES6, 12 bytes + 3 bytes
Regex: ...
Code: a=>a+1<a-1+2

It is supposed to be hard to produce a false. With your program, almost any 3-digits number (and more inputs) would produce it.

Python 3, cracked by ovs
Regex: .
Program: lambda a:len(a.lower()) == 1
This shouldn't be wasn't too hard.

Cracked

Pyth
Regex: .*
Program: !qC%.hz^TT"U|(¡
Try it online!
Simple hash function, shouldn't be allowed, but it is. I could've made it much stronger, but I tried to optimize for byte count.

Stop suggesting we make things into pop-cons! Pop-cons are almost never good nowadays, and this challenge is much much better as a cops and robbers. The issue is that the OP hasn't yet clarified, which does not mean that it should be a pop-con.

He has to do one of the two things, otherwise the winner is whoever can create the shortest hash that remains secure.

I'm not arguing with that, I'm arguing with the Maybe make the challenge a popularity contest instead. That is in no way the correct solution to a problem in a question. Take a look through this and see how many are closed. Pop-con is not a solution to an under specified challenge, it is a separate challenge type.

Good point, turns out I wasn't aware of what makes a challenge a good popularity contest. Edited my answer.

Java (OpenJDK 9), 198 bytes, (Cracked)
public static boolean isProgramValid(String n) {
    try{
        Class.forName(n);
    } catch(Exception e){
       return false;
    }
    return true;
}

public static String regex = "^(?is)([a-z]+\\.){4}.*$";

Should be an easy one.
Try it online!

Isn't the question tagged as code-golf? Why all these white spaces and boolean instead of int?

Cracked

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
My program knows your language. Does yours?
Given a list of production rules and start symbol of a proper finite context-free grammar (CFG) of printable characters, your program or function must output its formal language (the set of all sentences which can be constructed from it).
Task
A context-free grammar is formally defined as a 4-tuple of a few parts. Here, they are defined for you to solve this challenge.
For the purposes of the challenge, a production rule is of the form {begin, {end-1, end-2, end-3, ..., end-n}} or equivalent. The begin part is always one printable character (0x20 to 0x7E), and the end-i are all strings of printable characters.
Your program will receive as input a list of production rules and a start symbol. The start symbol is a single printable character.
An iteration takes an input list of strings and is defined as follows: To each string s in the input list, look at the first character c in it which is found as the begin of a production rule. To each end-i on the right side of that rule, add to the list the string s but where the first instance of c is replaced by the string end-i. Then remove the original string s if and only if there is a character c.
The program would repeat applying iterations, beginning with the start symbol, until an iteration does not affect the list of strings, at which point it outputs the list of strings (with repeats removed).
This is equivalent to the following pseudo-code:
rules = input()
start_symbol = input()

define iteration(string_list,rules):
  for each string in string_list:
    c = first char in string which is the first element of a rule in rules
    // ^^ This is a Mathematica builtin, right? ^^
    if(c exists):
      ends = the second element of that rule
      for each end in ends:
        // replace the first instance of c with end.
        string_list.append(string.replace(c,end))
      string_list.remove(string)
      // make sure you don't remove the original string if
      // there does not exist a c

  return string_list

current_string = start_symbol

// Clearly this is inefficient to apply iteration twice
// but hey, this is code golf. As long as it runs in less than 60 seconds on TIO!
while(iteration(current_string)!=current_string):
  current_string = iteration(current_string)

print remove_repeats(current_string)

Note that you do not need to follow this exact pseudo-code as long as your program yields correct output.
Example
Given the start symbol S and production rules:
{S:{aE,bE,c}}
{E:{ab,aC}}
{C:{a,b,c}}

We do:
{S} // start
{aE,bE,c} // apply first rule to the first element
{aab,aaC,bab,baC,c} // apply second rule to the first and second element
{aab,aaa,aab,aac,bab,baa,bab,bac,c}             // apply third rule to the second and fourth elements
{aab,aaa,aac,bab,baa,bac,c} // remove repeats

Input restrictions
This should only matter to people who care.
The CFG ...

has no recursion.
has no cycles.
has no unreachable symbols.
has no unproductive symbols.

The list of production rules ...

may have productions resulting in an empty string.
may be taken in any format, as long as it encodes only a begin character and a list of alternatives as end-i for each rule.
has no duplicate begin characters.
has no duplicate end characters within a production rule

Test Cases
start symbol, {rule1, rule2, ...}, expected output
S, {S: {aE,bE,c}, E: {ab,aC}, C: {a,b,c}}, {aab,aaa,aac,bab,baa,bac,c}
S, {S: {a,B}, B: {g,k}}, {a,g,k}
A, {A: {B,C,D}, B: {c,d}, C:{b,d}, D:{b,c}}, {c,b,d}
~, {~: {`,^,/}, /:{`^,``}, ^:{``,```}}, {`,``,```,````}
+, {A: {1,2,3}, +:{A,B,C}}, {1,2,3,B,C}

Notes

The input will be taken in any convenient format as long as it gives no information other than the production rules and start symbol.
The output should be given such that the list of strings as output is clearly encoded and unique.
Please specify what format your list of production rules are taken in.
This is code-golf, so shortest code in each language wins. Do not be discouraged from posting by answers in golfing languages.

Stack exchange thought the title of this question implied subjectivity :P. Anyway, Sandbox Post.

JavaScript, 118 bytes
m=>g=c=>(i=0,c=[...new Set([].concat(...c.map(n=>[...n].find(x=>k=m[o=x])?k.map(t=>n.replace(o,t,i=1)):n)))],i?g(c):c)

f=

m=>g=c=>(i=0,c=[...new Set([].concat(...c.map(n=>[...n].find(x=>k=m[o=x])?k.map(t=>n.replace(o,t,i=1)):n)))],i?g(c):c)

print = x => console.log(JSON.stringify(x))
print(f({S:['a','B'],B:['g','k']})(['S']))
print(f({S:['aE', 'bE', 'c'], E:['ab', 'aC'], C:['a', 'b', 'c']})(['S']))
print(f({A:['B','C','D'],B:['c','d'],C:['b','d'],D:['b','c']})(['A']))
print(f({'~':['`','^','/'],'/':['`^','``'],'^':['``','```']})(['~']))
print(f({A:['1','2','3'], '+':['A','B','C']})(['+']))

Python 2, 124 bytes
def f(s,r,i=0):
 while s[i:]:
	if s[i]in r:return list(set(s[:i]+l+s[i+1:]for v in r[s[i]]for l in f(v,r)))
	i+=1
 return[s]

Try it online!


text:
Twice as long, half the price
Related: I double the source, you double the output!

When Steve Jobs launched the iPhone 3G, the slogan said

Twice as fast, half the price

I changed the word fast to long to better represent this challenge.
Objective
Write a program that outputs a non-zero, even integer. If the source code is doubled, the value of the output must be cut off by half.
To double the source in a Unix shell (with Core Utilites):
cat source.txt source.txt > doubled-source.txt

Rules & Requirements
Now the requirement has changed and the task has been even more challenging!

You must build a full program.
The initial source is no longer required to be at least 1 byte long. An empty program qualifies as long as the output is correct.
Both the integers must be in base 10 (outputting them in any other base or with scientific notation is forbidden), and must not be zero. The integer is no longer required to be positive, so if you like a negative number, it's OK.
Your program must not take input (or have an unused, empty input) and must not throw any error (compiler warnings are not considered errors). Exit code must be zero.
Outputting the integers with trailing / leading spaces / newlines is allowed, as long as only one integer is output.
You can't assume a newline between copies of your source. If you need one, clarify it. See the Unix shell command above.
Standard loopholes are forbidden.

Because this is a code-golf, the shortest (original, undoubled) code in each language wins!
Extras
Please give description / explanation to your code if possible.

Must the old and new program be in the same language?

@tsh Definitely

By the way, zero byte answers to this question can't exist.

@WheatWizard This is exactly the opposite.

@Arthur That is somewhat true but also misleading.  The only difference between this question and that is the operation involved.  I consider this a rather minor difference that doesn't add anything not already present in the original.

Brain-Flak, 12 bytes
(()()[][{}])

Outputs 2. Try it online!
The doubled program outputs 1. Try it online!
Explanation
This code pushes 2 + stack height - top of stack.  Initially, this is 2 + 0 - (implicit) 0 = 2.  When this code is run again, it pops the existing 2 and pushes 2 + 1 - 2 = 1.

This is in fact a provably optimal solution.  I don't have the space for the complete proof in this comment but it's not very complex, feel free to ping me in chat for a complete proof.

Python 2, 35 34 bytes
Uses a concept similar to that of Wheat Wizard in the double challenge with an improvement I found to his original code. Here I use the fact that the length of the file is 34 bytes long. Meaning it is equal to 4 modulo 6. (34%6 = 4). The double source code would have a length of 68. And 68%6 = 2, which is exactly what we want.
print open(__file__,"a").tell()%6#

Try it online!
Double source code
Explanation
This opens the source code file in append mode
open(__file__,"a")
We then find the current position in the file, this will be at the end of the file due to opening in append mode
open(__file__,"a").tell()
We print this length modulo 6
print open(__file__,"a").tell()%6
And add a comment, so that doubling the source code does not execute more code
print open(__file__,"a").tell()%6#

Jelly, 2 bytes
¬‘

Outputs 2, Try it online!
While
¬‘¬‘

Outputs 1, Try it online!
How?
The default input to a monadic chain is zero...
¬‘   - Main link: no arguments
¬    - logical not -- not the implicit input of 0 to yield 1
 ‘   - increment   -- increment 1 to yield 2
     - implicit print if this is the end of the program, otherwise...
     ...
  ¬‘ - continues the monadic chain:
  ¬  - logical not -- not the 2 to yield 0
   ‘ - increment   -- increment 0 to yield 1
     - implicit print if this is the end of the program

The two byters:
Ị‘ - insignificant (abs(z)<=1); increment
Ṇ‘ - non-vectorising logical not; increment

would work too.

Ly, 7 bytes
2y1-+-N

Try it online!
Simple port of the Brain-Flak answer.

05AB1E, 3 bytes
Outputs 4
6rÍ

Try it online!
Doubled Source
Outputs 2
6rÍ6rÍ

Try it online!
Explanation
6      # push 6
 r     # reverse the stack (does nothing)
  Í    # subtract 2

With the doubled source we continue with
6      # push 6
 r     # reverse the stack (puts 4 on top)
  Í    # subtract 2

Does the r in the singlet form of your answer put 4 on top the top of the stack?

@TaylorScott: In the single form we only have a 6 on the stack so r does nothing.

sh, 50 bytes
#!/bin/sh
expr 200 / `wc -c $0 | cut -c 1-3`
exit

Jelly, 7 bytes
®‘!İ©Ḥµ

Try it online!
Outputs 2.
Duplicated Source:
®‘!İ©Ḥµ®‘!İ©Ḥµ

Try it online!
Outputs 1.


text:
Unicode rectangles
Given

a matrix a of characters from u=" ╶╺╵└┕╹┖┗╴─╼┘┴┶┚┸┺╸╾━┙┵┷┛┹┻╷┌┍│├┝╿┞┡┐┬┮┤┼┾┦╀╄┑┭┯┥┽┿┩╃╇╻┎┏╽┟┢┃┠┣┒┰┲┧╁╆┨╂╊┓┱┳┪╅╈┫╉╋"
the coordinates of a submatrix as x,y,w,h (left, top, width>1, height>1)
a thickness t of 1 (as in ┌) or 2 (as in ┏)

render an inner border for the submatrix with the specified thickness, taking into account existing lines.
x=4;y=1;w=2;h=3;t=2;
a=[' ┌───┐',
   '┌┼┐  │',
   '│└┼──┘',
   '└─┘   ']

// output
r=[' ┌───┐',
   '┌┼┐ ┏┪',
   '│└┼─╂┨',
   '└─┘ ┗┛']

When overwriting a line fragment, the new thickness should be the greater of
the old thickness and t.
This isn't about input parsing or finding the Kolmogorov complexity of Unicode,
so you may assume a,u,x,y,w,h,t are available to you as variables.
Also, you may put the result in a variable r instead of returning or
outputting it, as long as r is of the same type as a.
If your language forces you to put code in functions (C, Java, Haskell, etc)
and your solution consists of a single function, you can omit the function
header and footer.
Larger test:
x=4;y=1;w=24;h=4;t=1;
a=['┏┱─────┐         ┌┐     ┎──┲━┓',
   '┠╂─────┘         ││     ┃  ┗━┛',
   '┃┃               ││     ┃     ',
   '┠╂──┲━━┓  ┏━━━━┓ ││    ┌╂┰┐   ',
   '┃┃  ┗━━┩  ┃    ┃ └╆━┓  └╂┸┘   ',
   '┃┃     │  ┃    ┃  ┃ ┃   ┃     ',
   '┗┹─────┘  ┗━━━━┛  ┗━┛   ╹     ']

// output
r=['┏┱─────┐         ┌┐     ┎──┲━┓',
   '┠╂──┬──┴─────────┼┼─────╂──╄━┛',
   '┃┃  │            ││     ┃  │  ',
   '┠╂──╆━━┓  ┏━━━━┓ ││    ┌╂┰┐│  ',
   '┃┃  ┗━━╃──╂────╂─┴╆━┱──┴╂┸┴┘  ',
   '┃┃     │  ┃    ┃  ┃ ┃   ┃     ',
   '┗┹─────┘  ┗━━━━┛  ┗━┛   ╹     ']

will the input always hold 0 <= x < x + w < width(a) and 0 <= y < y + h < height(a)?

@tsh yes, input will be valid

Bah, my default font is dodgy - it shows some of those characters with the wrong heaviness unless you zoom in a lot.

@Neil I'm sorry about that. One workaround is to paste the examples in an editor where you can choose the font.

About your bounty - it is impossible to award three 150-rep bounties. You have to double the rep count every time you start another bounty on the same question.

@MDXF Oh... I didn't think about that. Thanks. There must be ways around it though, e.g. start a bounty on a fake question.

JavaScript, 218 bytes
(a,x,y,w,h,t,u)=>a.map((l,j)=>l.map((c,i)=>u[(g=(a,b)=>a?g(a/3|0,b/3|0)*3+Math.max(a%3,b%3):b)(u.indexOf(c),t*((j==y||j==y+h-1)*((i>x&&i<x+w)*9+(i>=x&&i<x+w-1))+(i==x||i==x+w-1)*((j>y&&j<y+h)*3+(j>=y&&j<y+h-1)*27)))]))

a should be taken as array of array of char.

f =

(a,x,y,w,h,t,u)=>a.map((l,j)=>l.map((c,i)=>u[(g=(a,b)=>a?g(a/3|0,b/3|0)*3+Math.max(a%3,b%3):b)(u.indexOf(c),t*((j==y||j==y+h-1)*((i>x&&i<x+w)*9+(i>=x&&i<x+w-1))+(i==x||i==x+w-1)*((j>y&&j<y+h)*3+(j>=y&&j<y+h-1)*27)))]))

x=4;y=1;w=24;h=4;t=1;
a=['┏┱─────┐         ┌┐     ┎──┲━┓',
   '┠╂─────┘         ││     ┃  ┗━┛',
   '┃┃               ││     ┃     ',
   '┠╂──┲━━┓  ┏━━━━┓ ││    ┌╂┰┐   ',
   '┃┃  ┗━━┩  ┃    ┃ └╆━┓  └╂┸┘   ',
   '┃┃     │  ┃    ┃  ┃ ┃   ┃     ',
   '┗┹─────┘  ┗━━━━┛  ┗━┛   ╹     '].map(x => [...x])
u=" ╶╺╵└┕╹┖┗╴─╼┘┴┶┚┸┺╸╾━┙┵┷┛┹┻╷┌┍│├┝╿┞┡┐┬┮┤┼┾┦╀╄┑┭┯┥┽┿┩╃╇╻┎┏╽┟┢┃┠┣┒┰┲┧╁╆┨╂╊┓┱┳┪╅╈┫╉╋";

output = f(a,x,y,w,h,t,u).map(x => x.join('')).join('\n');
document.write(`<pre lang="en" style="font-family: Consolas,Menlo,Monaco,Lucida Console,Liberation Mono,DejaVu Sans Mono,Bitstream Vera Sans Mono,Courier New,monospace,sans-serif;">${output}</pre>`)

as mentioned above, you are allowed to replace (a,x,y,w,h,t,u)=>... with r=...

Python 3, 226 201 197 bytes
n,m=x+w-1,y+h-1
r=[*map(list,a)]
R=range
for i in R(x,x+w):
 for j in R(y,y+h):A,B=j in(y,m),i in(x,n);r[j][i]=u[sum(3**o*max((i<n*A,y<j*B,x<i*A,j<m*B)[o]*t,u.index(a[j][i])//3**o%3)for o in R(4))]

Try it online!
Ungolfed:
n,m=x+w-1,y+h-1
r=[*map(list,a)]
for i in range(x,x+w):
 for j in range(y,y+h):
  p=u.index(a[j][i])
  c=(p%3,p%9//3,p%27//9,p//27)
  A,B=j in(y,m),i in(x,n)
  P=(i<n*A,y<j*B,x<i*A,j<m*B)
  l=sum(max(P[o]*t,c[o])*3**o for o in range(4))
  r[j][i]=u[l]

(p%3,p%9//3,p%27//9,p//27)[o] → p//3**o%3 saves a bunch of bytes. Then max(…)*3**o for → 3**o*max(…)for saves one more. And then you can eke one more out by inlining the 3** and shuffling P around to index it with o%5-1, yielding: sum(o*max((i<n*A,j<m*B,y<j*B,xl.map((c,i)=>u[c=u.indexOf(c),g=n=>c/n%3<t&&g(n,c+=n),j==y|j==h&&(i>=x&i<w&&g(1),i>x&i<=w&&g(9)),i==x|i==w&&(j>=y&j<h&&g(27),j>y&j<=h&&g(3)),c]),w+=x-1,h+=y-1)

a=`
┏┱─────┐         ┌┐     ┎──┲━┓
┠╂─────┘         ││     ┃  ┗━┛
┃┃               ││     ┃
┠╂──┲━━┓  ┏━━━━┓ ││    ┌╂┰┐
┃┃  ┗━━┩  ┃    ┃ └╆━┓  └╂┸┘
┃┃     │  ┃    ┃  ┃ ┃   ┃
┗┹─────┘  ┗━━━━┛  ┗━┛   ╹
`.match(/.+/g).map(s=>[...s]);
x=4;
y=1;
w=24;
h=4;
t=1;
u=" ╶╺╵└┕╹┖┗╴─╼┘┴┶┚┸┺╸╾━┙┵┷┛┹┻╷┌┍│├┝╿┞┡┐┬┮┤┼┾┦╀╄┑┭┯┥┽┿┩╃╇╻┎┏╽┟┢┃┠┣┒┰┲┧╁╆┨╂╊┓┱┳┪╅╈┫╉╋";
r=a.map((l,j)=>l.map((c,i)=>u[c=u.indexOf(c),g=n=>c/n%3<t&&g(n,c+=n),j==y|j==h&&(i>=x&i<w&&g(1),i>x&i<=w&&g(9)),i==x|i==w&&(j>=y&j<h&&g(27),j>y&j<=h&&g(3)),c]),w+=x-1,h+=y-1)
;document.write(`
${r.map(s=>s.join``).join`\n`}
`);


text:
Plus Primes vs Minus Primes
Most of us know...
that all primes p>3 are of the form
But, how many are the Plus Primes (6n+1) and how many are the Minus Primes (6n-1) in a certain range?
The Challenge
Given an integer k>5 , count how many primes<=k are PlusPrimes and how many are MinusPrimes.
Examples
for k=100 we have
[5, 11, 17, 23, 29, 41, 47, 53, 59, 71, 83, 89] 12 MinusPrimes
and
[7, 13, 19, 31, 37, 43, 61, 67, 73, 79, 97] 11 PlusPrimes
for k=149 we have
[5, 11, 17, 23, 29, 41, 47, 53, 59, 71, 83, 89, 101, 107, 113, 131, 137, 149]
18 MinusPrimes
and
[7, 13, 19, 31, 37, 43, 61, 67, 73, 79, 97, 103, 109, 127, 139]
15 PlusPrimes
Rules
Your code must output 2 integers: one for the MinusPrimes and one for the PlusPrimes in any order you like (please specify which is which).
This is code-golf: shortest answer in bytes wins!
Test Cases

Input -> Output    [MinusPrimes,PlusPrimes]

6->[1,0]
7->[1,1]
86->[11,10]
986->[86,78]
5252->[351,344]
100000->[4806,4784]
4000000->[141696, 141448]

I did not know! :(

@StewieGriffin, it's easy to intuit if you look at the modulus sequence: 0%6 is a multiple of 6, 1%6 cannot be determined, 2%6 is a multiple of 2, 3%6 is a multiple of 3, 4%6 is a multiple of 2, and 5%6 cannot be determined.

@zzzzBov that'd be really helpful if I knew why modulus had a sequence, and what it meant for primes... I wish high school taught number theory...

@SocraticPhoenix, modulus means "remainder after division". 0, 6, 12, etc all produce 0 after division by 6; 1, 7, 13 all produce 1. Since we're looking for numbers that can't be divided into factors, knowing that a number is divisible by an integer greater than 1 tells us that the number is not prime.

05AB1E, 10 9 bytes
Saved 1 byte thanks to Erik the Outgolfer
Outputs as [PlusPrimes, MinusPrimes]
LDpÏ6%5Ñ¢

Try it online!
or as a Test Suite
Explanation
L             # push range [1 ... input]
 DpÏ          # keep only primes
    6%        # mod each by 6
      5Ñ      # divisors of 5 [1, 5]
        ¢     # count

Python 2, 77 bytes
-2 bytes thanks to Neil

lambda x:[sum(all(n%j for j in range(2,n))for n in range(i,x,6))for i in 7,5]

Try it online!
Previous solution, 83 81 79 bytes
-1 byte thanks to Mr. Xcoder
-2 bytes thanks to Halvard Hummel
lambda x:map([all(n%i for i in range(2,n))*n%6for n in range(4,x)].count,[5,1])

Try it online!
Both output as [MinusPrimes,PlusPrimes]

83

81 bytes

80?

I've done too many JavaScript array comprehensions - I'd forgotten that Python lists often don't need []s.

So, you divide n by all numbers from i to n-1 to see if it is prime, then generate all of the integers (5,11,...) and (7,13, ...) and test if the number in question is there, and count them.  Seems efficient.  ;)

@Yakk that's why I didn't added the last 2 test cases on the link c:

MATL, 10 bytes
Zq6\!5lh=s

Try it online! Or verify all test cases.
Explanation
Zq     % Implicitly input k. Push row vector of primes up to k
6\     % Modulo 6, element-wise
!      % Transpose into a column vector
5lh    % Push row vector [5, 1]
=      % Is equal?, element-wise with broadcast
s      % Sum of each column. Implicitly display

Mathematica, 51 bytes
(s=#;Mod[Prime~Array~PrimePi@s,6]~Count~#&/@{5,1})&

Try it online!
@ngenisis golfed it down, saving 4 bytes
Mathematica, 47 bytes
sPrime~Array~PrimePi@s~Mod~6~Count~#&/@{5,1}

Mod can also be infix, and if you're going to name the first argument s, just use a named argument: sPrime~Array~PrimePi@s~Mod~6~Count~#&/@{5,1}

Jelly, 7 bytes
s6ÆPSm4

Plus, then minus.
Try it online!
How it works
s6ÆPSm4  Main link. Argument: n

s6       Split [1, ..., n] into chunks of length 6.
  ÆP     Test all integers for primality.
    S    Sum across columns.
         This counts the primes of the form 6k + c for c = 1, ..., 6.
     m4  Take every 4th element, leaving the counts for 6k + 1 and 6k + 5.

Japt, 15 13 11 bytes
Output order is [+,-].
õj ò6 yx ë4

Test it

Took some inspiration from Dennis' Jelly solution but, after golfing, it's closer to being a port.
2 bytes saved thank to Oliver bringing the previously-unknown-to-me ë method for arrays to my attention.

Explanation
Implicit input of integer U.
õj

Generate an array of integers (õ) from 1 to U and check if each is a prime (j), giving an array of booleans.
ò6

Partition the array into sub-arrays of length 6.
yx

Transpose (y) and sum the columns.
ë4

Get every 4th element of the array and implicitly output them.

Original, 19 17 16 15 bytes
õ fj
5â £è_%6¥X

Test it

1 byte thanks to an inspired suggestion from Oliver to use the divisors of 5 after I'd rested on my laurels splitting 15 to an array.

Retina, 53 51 bytes
.+
$*
1
$`1¶
G`1111
A`^(11+)\1+$
1{6}

*M`111
\b1\b

Try it online! Explanation:
.+
$*

Convert to unary.
1
$`1¶

Count from 1 up to n.
G`1111

Delete numbers less than 4.
A`^(11+)\1+$

Delete composite numbers.
1{6}

Take the remainder modulo 6.
*M`111

Print the number of numbers with a remainder between 3 and 5.
\b1\b

Print the number of numbers with a remainder of 1.

Ruby, 61 60 bytes
(52 bytes + 8 for the -rprimes flag)
->n{[1,5].map{|x|(4..n).count{|i|i.prime?&&i%6==x}}}

Returns an array of the form [plus primes, minus primes].
Saved 1 byte thanks to G B!
Try it online.

I was inspired by your answer and updated mine (in Haskell)!

@jferard I'm very glad to hear that! :)

You can use count on the range without the splat operator (save 1 byte).

Perl 6, 42 bytes
Saved 1 byte by removing a useless space...
Saved 2 bytes by reorganizing the map call — thanks to @Joshua.
Saved 3 bytes because .round equals .round: 1.
Actually the complex exponential is cool but very expensive characterwise. Saved 10 bytes just by ditching it...
{[+] map {.is-prime*($_%6-1??i!!1)},5..$_}

Try it online!
This was the version with the complex exponential. (I like it too much to delete it.) The new version works exactly in the same way, just the complex exponential is replaced by the much shorter ternary operator.

{[+] map {.is-prime*exp(π*($_%6-1)i/8).round},5..$_}

Try it online!
The output is a complex number (PlusPrimes) + (MinusPrimes)i. I hope it's not too much against the rules.

Explanation: It's a function that takes one integer argument. We iterate over all integers from 5 to the argument ((5..$_)). For each of these, we evaluate .is-prime (this is called on $_, the argument of the mapped block), multiply it (if numified, True == 1, False == 0) with a complex exponential that's made to be either exp(0) = 1 (for $_%6 = 1) or exp(iπ/2) = i (for $_%6 = 5), and finally round it to the nearest integer. Summing them up with [+] gives the result.
Finally: it's really efficient, so I'm not sure if TIO won't time out before you get your output for higher numbers (for 1e5, it takes 26 sec on my machine, and TIO tends to be somewhat slower).

that's fine. good job!

I think you mean inefficient? Nice method though!

That was a crude attempt at irony :—).

When golfing, using the method forms of map or grep can sometimes cost you a few characters. This saves 2 chars: {[+] map {.is-prime*exp(π*($_%6-1)i/8).round: 1},5..$_}

Forgot to do that here, thanks for bringing it to my attention!

J, 23 bytes
1#.5 1=/6|_1 p:@i.@p:>:

Try it online!
1#.5 1=/6|_1 p:@i.@p:>:   input: y
          _1       p:     number of primes
                     >:   less than y + 1
             p:@i.        prime range from 0 to that number
        6|                get residues modulo 6
   5 1=/                  table of values equal to 5 or 1
1#.                       sum of each (antibase 1)

Stacked, 37 bytes
[~>$primeYES 6%5 1,$=table tr$summap]

Try it online!
Rather slow, tests for primality for each K < N. Works similar to my J answer.

C#, 202 179 174 Bytes
-23 Bytes thanks to Mr. Xcoder
-5 Bytes thanks to Cyoce
Function that returns an array of length 2, [MinusPrimes, PlusPrimes]
Execute by calling a(n).
int[]a(int n){int[]r={0,0};for(int i=5;i<=n;i++)if(i%2*b(i)>0)if(i%6<5)r[1]++;else++r[0];return r;}int b(int n){for(int i=3;i-2<Math.Sqrt(n);i+=2)if(n%i<1)return 0;return 1;}

Properly formatted code on Try It Online: Here

Can you add a tio link?

Sorry for golfing byte-to-byte, 194 bytes: public int[]a(int n){int[]r=new int[2];for(int i=5;i<=n;i++)if(i%2*b(i)>0)if(i%6<5)r[1]++;else++r[0];return r;}public int b(int n){for(int i=3;i<=Math.Sqrt(n)+1;i+=2)if(n%i<1)return 0;return 1;}

193 bytes: public int[]a(int n){int[]r=new int[2];for(int i=5;i<=n;i++)if(i%2*b(i)>0)if(i%6<5)r[1]++;else++r[0];return r;}public int b(int n){for(int i=3;i-2<Math.Sqrt(n);i+=2)if(n%i<1)return 0;return 1;}

lmao youre loving this arent you ;)

179 bytes: int[]a(int n){int[]r=new int[2];for(int i=5;i<=n;i++)if(i%2*b(i)>0)if(i%6<5)r[1]++;else++r[0];return r;}int b(int n){for(int i=3;i-2<Math.Sqrt(n);i+=2)if(n%i<1)return 0;return 1;}, you don't need public. This golf is a bit better :)

You can save more 3 bytes if you use two ints instead of using an array and then returning a new array, like this: return new[]{MinusPrimesVar,PlusPrimesVar}

Could you swap new int[2] for {0,0}?

You can ditch the second separate method and merge it together like this: n->{int[]r={0,0};for(int i=5,j,c;i<=n;i++){for(j=3,c=1;j-2<Math.Sqrt(i);j+=2)c=i%j<1?0:c;if(i%2*c>0)if(i%6<5)r[1]++;else++r[0];}return r;} (135 bytes)

Oh, and you can golf another three bytes (132 bytes total) by changing for(j=3,c=1;j-2<Math.Sqrt(i);j+=2)c=i%j<1?0:c; to for(j=c=1;j<Math.Sqrt(i);)c=i%(j+=2)<1?0:c;

Sorry for all the comments.. Just take a look at my Java 8 answer to golf it by a lot more.. (thanks to @Nevay).

thanks for all the help, since youve posted a separate answer and stated its a golf of mine, im just gonna leave mine as is and take the lessons onto the next challenge :P

Japt, 18 16 bytes
-2 bytes thanks to @Oliver
õ_j ©Z%6
5â £è¥X

Try it online!
Outputs in the format [PlusPrimes, MinusPrimes].

Hmm ... I just got back to my desk, golfed mine down to 17 bytes and then saw you'd posted this ... don't know whether I should post it or not as the crux of both our solutions is mapping over [5,1] to get the counts and you got there first.

@Shaggy IMO your solution has enough differences to remain a separate post. You used filter and a string; I used the mapping function of õ and an array. Besides, I got the [5,1] idea from another answer.

I'll think on it a bit; solutions in different languages using similar methods (even if one "borrowed" it from the other) is OK but 2 solutions in the same language doing so doesn't sit entirely well with me. I've edited into my post as an alternative for now.

I decided to run with it and then shaved another byte off.

You can use 5â to get [1,5]

@Oliver That's really clever, thanks! Will edit in a little while.

I've completely changed my approach now; if you ant to nab my original solution to save yourself a byte, feel free :)

Haskell, 81 69 bytes
f n=(\r->sum[1|i<-[2..n],all((>0).rem i)[2..i-1],rem i 6==r])<$>[5,1]

Try it online!
First solution was:
r!l=sum[1|i<-l,rem i 6==r]
f n|l<-[i|i<-[2..n],all((>0).rem i)[2..i-1]]=(5!l,1!l)

But I read w0lf's answer in Ruby...

MATLAB 2017a, 29 Bytes
sum(mod(primes(k),6)'==[5,1])

Explanation: primes(k) gets all primes up to and including k. mod(primes(k),6)' takes the modulus 6 of all primes and transposes it so the sum runs along the correct dimension. ==[5,1] sets all fives (minusPrimes) to 1 in the first column and all ones (plusPrimes) to 1 in the second column. sum() sums each column.
This outputs [minusPrime, plusPrime]

Actually, 21 bytes
u5x`p░⌠6@%1=;`╖*ƒ⌡Ml╜

Try it online!
Outputs the PlusPrimes first, followed by the MinusPrimes
Explanation:
u5x`p░⌠6@%1=;`╖*ƒ⌡Ml╜
u5x                    range(5, n+1)
   `p░                 primes in range
      ⌠6@%1=;`╖*ƒ⌡M    for each prime:
       6@%               mod 6
          1=             equal to 1
            ;`╖*ƒ        execute ╖ if p%6==1 (add 1 to register 0, consuming p)
                   l   length of resulting list (MinusPrimes)
                    ╜  push value in register 0 (PlusPrimes)

Pyth, 15 bytes
/K%R6fP_TSQ5/K1

Test Suite.
Pyth, 16 bytes
m/%R6fP_TSQd,1 5

Test Suite.

How?
Explanation #1

/K%R6fP_TSQ5/K1 - Full program.

     fP_TSQ     - Filter the primes in the range [1...input].
  %R6           - Mod 6 on each.
 K              - Assign them to a variable K.
/          5    - Count the occurrences of 5 in K.
            /K1 - Count the occurrences of 1 in K.
                - Implicitly output the result.

Explanation #2

m/%R6fP_TSQd,1 5 - Full program.

     fP_TSQ      - Filter the primes in the range [1...input]
  %R6            - Mod 6 on each.
            ,1 5 - Push the list [1, 5]
m/         d     - Count how many of each there are.
                 - Implicitly output the result.

Alternatives:

/K%R6fP_TSQ5/KhZ    (16 bytes)
K%R6fP_TSQ/K5/K1    (16 bytes)
m/%R6fP_TSQdj15T    (16 bytes)
m/%R6fP_TSQd[1 5    (16 bytes)
m/%R6fP_TSQdsM`15   (17 bytes)
m/%R6.MP_ZSQd,1 5   (17 bytes)
m/%R6.MP_ZSQdj15T   (17 bytes)
m/%R6.MP_ZSQd[1 5   (17 bytes)

Congrats on 10k!!

@LuisMendo Thanks a lot :-)

Jelly,  12 11  10 bytes
Thanks to @cairdcoinheringaahing for some tips in chat. Thanks to @Dennis for saving one byte in chat.
ÆR%6ċÐ€1,5

Try it online!
Jelly, 11 bytes
ÆR%6µ1,5=þS

Try it online!
Jelly, 11 bytes
ÆR%6µċ5,ċ1$

Try it online!

How does this work?
Explanation #1
ÆR%6ċÐ€1,5   As usual, full program.

ÆR           Get all the primes in the range [2...input].
  %6         Modulo each by 6.
       1,5   The two-element list [1, 5].
    ċÐ€      Count the occurrences of each of ^ in the prime range.

Explanation #2
ÆR%6µ1,5=þS   As usual, full program.

ÆR            Get all the primes in the range [2...input].
  %6          Modulo each by 6.
    µ         Chain separator.
     1,5      The two-element list [1, 5].
        =     Equals?
         þ    Outer product.
          S   Sum.

Explanation #3
ÆR%6µċ5,ċ1$   As usual, full program.

ÆR            All the primes in the range [2...input].
  %6          Modulo each by 6.
    µ     $   Some helpers for the chains.
       ,      Two element list.
     ċ5       The number of 5s.
        ċ1    The number of 1s.

Java 8, 141 140 138 106 101 100 96 94 81 bytes
n->{int r[]={0,0},c;for(;n-->4;r[n%6/4]+=c)for(c=n;c>1;c=c-1&~n%c>>-1);return r;}

Returns an integer-array with two values, in reversed order compared to the challenge description:
[plusPrime, minusPrime].
Port of @Xynos' C# answer, after I golfed 39 40 42 bytes.
Huge help from @Nevay for another whopping -55 bytes.
Explanation:
Try it here. (Final test case of 4000000 is exceeding the 60 sec time limit slightly.)
n->{                   // Method with integer parameter and integer-array return-type
  int r[]={0,0},       //  Return integer-array, starting at [0,0]
      c;               //  Temp integer
  for(;n-->4;          //  Loop (1) as long as the input is larger than 4
                       //  and decrease `n` by 1 before every iteration
      r[n%6/4]+=c)     //    After every iteration, increase the plus or minus prime by `c`
                       //    (where `c` is either 0 or 1)
    for(c=n;           //   Reset `c` to `n`
        c>1;           //   And inner loop (2) as long as `c` is larger than 1
      c=               //    Change `c` to:
        c-1&~n%c>>-1;  //     inverting the bits of `n`,                    [~n]
                       //     modulo-`c` that result,                       [%c]
                       //     then bit-shift right that by -1,              [>>-1]
                       //     and then bitwise-AND that result with `c-1`   [c-1&]
    );                 //   End of inner loop (2)
                       //  End of loop (1) (implicit / single-line body)
  return r;            //  Return result integer-array
}                      // End of method

106 bytes: n->{int r[]={0,0},i=4,j,c;for(;i++<n;){for(j=c=1;j*j<i;)c=i%(j+=2)<1?0:c;if(i%2*c>0)r[i%6%5]++;}return r;}

101 bytes: n->{int r[]={0,0},i=4,j,c;for(;i++<n;r[i%6%5%2]-=-i%2*c>>-1)for(j=c=1;j*j<i;)c|=i%(j+=2)-1;return r;}

96 bytes: n->{int r[]={0,0},i=4,j,c;for(;i++<n;r[i%6%5%2]+=i&c)for(j=c=1;j*j++<i;)c&=-i%++j>>-1;return r;} (-1 thanks to your j++,++j)

@Nevay Thanks. And been able to golf one more by changing (j+=2) to two separate ++.

94 bytes: n->{int r[]={0,0},i=4,j,c;for(;i++<n;r[i%6/4]+=i&c)for(j=c=1;j*j++<i;)c&=-i%++j>>-1;return r;} ([plusPrime, minusPrime]).

90 bytes: n->{int r[]={0,0},j,c;for(;n>4;r[n%6/4]+=n--&c)for(j=c=1;j*j++<n;)c&=-n%++j>>-1;return r;}

88 bytes: n->{int r[]={0,0},j,c;for(;n>4;r[n%6/4]+=n--&c)for(j=c=1;j*j++<n;)c&=-n%j>>-1;return r;}

86 bytes: n->{int r[]={0,0},j,c;for(;n>4;r[n%6/4]+=n--&c)for(j=c=1;++j<n;)c&=-n%j>>-1;return r;} (will timeout for the last test case).

84 bytes: n->{int r[]={0,0},j,c;for(;n>4;r[n--%6/4]+=c)for(j=c=1;++j<n;)c&=-n%j>>-1;return r;}

83 bytes: n->{int r[]={0,0},c;for(;n>4;r[n--%6/4]-=~c/2)for(c=n;c-->2;)c&=-n%c>>-1;return r;}

82 bytes: n->{int r[]={0,0},c;for(;n-->4;r[n%6/4]+=c/2)for(c=n;c-->3;)c&=~n%c>>-1;return r;}

81 bytes: n->{int r[]={0,0},c;for(;n-->4;r[n%6/4]+=c)for(c=n;c>1;)c=c-1&~n%c>>-1;return r;}

@Nevay Wow, you've been busy!

JavaScript (ES6), 83 82 80 68 66 bytes
Turned out a fully recursive solution was much shorter than mapping an array!
Output order is [-,+]. Craps out with an overflow error somewhere around 3490.
f=(n,a=[0,0])=>n>4?f(n-1,a,(g=y=>n%--y?g(y):y<2)(n)&&++a[n%6%5]):a

Try it

o.innerText=(

f=(n,a=[0,0])=>n>4?f(n-1,a,(g=y=>n%--y?g(y):y<2)(n)&&++a[n%6%5]):a

)(i.value=6);oninput=_=>o.innerText=i.value>5?f(+i.value):[0,0]
<input id=i min=6 type=number><pre id=o>

R + numbers, 66 60 58 40 bytes
-16 bytes thanks to Jarko Dubbeldam! I subsequently golfed another two bytes off.
cat(table(numbers::Primes(4,scan())%%6))

Prints PlusPrimes MinusPrimes to stdout; reads from stdin.
table tabulates the count of each occurrence of the values in its input vector, in ascending order of value. Hence, since there are only two values, namely 1 and 5 (mod 6), this is exactly the function we need, along with numbers::Primes, which returns all primes between 4 and the input.
Try it online!
Base R, 97 91 89 86 65 bytes
a bunch of bytes saved by Jarko here, too
function(n)table((5:n)[sapply(5:n,function(x)all(x%%2:x^.5))]%%6)

This is nearly identical to the above, except it calculates all the primes in base R rather than using a package, and it returns by function output rather than printing it out. You can see in the output that it returns a table with names 1 and 5, with the counts below.
Try it online!

47 bytes

(Dennis added numbers to TIO, so that works now :))

42 bytes

all(x%%2:x^.5>0), anything nonzero is already truthy, so all(x%%2:x^.5) works too

@JarkoDubbeldam very nice! Turns out since all the values are greater than 4 we can get rid of the >4 since we won't have 2 in there anymore as a prime, so this golfs to 40 bytes instead.

Oh, I left that in to tally the TRUE and FALSE as plus or minus, but you're right that tallying 2 and 5 works too.

CJam, 19 bytes
ri){mp},6f%_5e=p1e=

Program that takes the input from STDIN, and outputs the two numbers separated by newline through STDOUT.
Try it online!
Explanation
ri){mp},6f%_5e=p1e=

ri                        Read integer k
  )                       Add 1
       ,                  Filter the (implicit) array [0 1 ... k] ...
   {mp}                   ... on the function "is prime"
         f                Map over the resulting array...
          %               ... the function "modulus" ...
        6                 ... with extra parameter 6
           _              Duplicate the resulting array
             e=           Count occurrences ...
            5             ... of number 5
               p          Print with newline
                 e=       Count occurrences ...
                1         ... of number 1. Implicitly display

JavaScript (SpiderMonkey), 151, 140, 131 bytes
n=>[...Array(n+1).keys()].splice(5).filter(a=>!/^1?$|^(11+?)\1+$/.test("1".repeat(a))).reduce((r,a)=>(a%6<2?r[1]++:r[0]++,r),[0,0])

Try it online!
Thanks to shaggy for helping with a bug fix and golfing.
Explanation:
n=>                                                   // Create a lambda, taking n
    [...Array(n+1).keys()]                            // Create a list from 0 to n+1
        .splice(5)                                    // remove first five elements
        .filter(a=>                                   // filter the list to get primes
             !/^1?$|^(11+?)\1+$/.test("1".repeat(a))) // using the famous regex here: https://stackoverflow.com/questions/2795065/how-to-determine-if-a-number-is-a-prime-with-regex
        .reduce((r,a)=>                               // reduce the list
           (a%6<2?r[1]++:r[0]++,r),                   // by counting plus primes
           [0,0])                                     // and minus primes

Retturns 17,15 for 149 (Should be 18,15). You need to increase the size of your array by 1: TIO. Incidentally, this is just "vanilla" ES6, nothing specific to SpiderMonkey in it. Also, you can use Stack Snippets for JS, rather than TIO. And, you have a lot of spaces you can remove.

Another couple of quick savings for you, to get you down to 131 bytes.

@Shaggy I did not realise you could use reduce like that.

Pari/GP, 41 bytes
n->vecsum([[i>3,i<3]|i<-primes([4,n])%6])

Try it online!