Playing cards: Difference between revisions

 

Each card must have a pip value and a suit value which constitute the unique value of the card.

 

=={{header|ACL2}}==

(if (or (zp i) (endp (rest xs)))

(rest xs)

(defun draw-from-deck (deck)

(mv (first deck) (rest deck)))

 

Example (first 4 cards of a shuffled deck):

4 of DIAMONDS

(NIL <state>)</pre>

 

=={{header|Ada}}==

* [http://www.csail.mit.edu/timeline/timeline.php?query=event&id=93 LOC was essential; Algol 68's REF was a mistake.]

 

 

# class members & attributes #

(init OF class deck)(deck);

(shuffle OF class deck)(deck);

 

{{Out|Example output}}

<pre>((King OF Clubs), (6 OF Hearts), (7 OF Diamonds), (Ace OF Hearts), (9 OF Spades), (10 OF Clubs), (Ace OF Spades), (8 OF Clubs), (4 OF Spades), (8 OF Hearts), (Jack OF Hearts), (3 OF Clubs), (7 OF Hearts), (10 OF Hearts), (Jack OF Clubs), (Ace OF Clubs), (King OF Spades), (9 OF Clubs), (7 OF Spades), (5 OF Spades), (7 OF Clubs), (Queen OF Clubs), (9 OF Diamonds), (2 OF Spades), (6 OF Diamonds), (Ace OF Diamonds), (Queen OF Diamonds), (5 OF Hearts), (4 OF Clubs), (5 OF Clubs), (4 OF Hearts), (3 OF Diamonds), (4 OF Diamonds), (3 OF Hearts), (King OF Diamonds), (2 OF Clubs), (Jack OF Spades), (2 OF Diamonds), (5 OF Diamonds), (Queen OF Spades), (10 OF Diamonds), (King OF Hearts), (Jack OF Diamonds), (Queen OF Hearts), (8 OF Spades), (2 OF Hearts), (8 OF Diamonds), (10 OF Spades), (9 OF Hearts), (6 OF Clubs), (3 OF Spades), (6 OF Spades))</pre>

 

 

=={{header|ATS}}==

(* ****** ****** *)

//

 

(* ****** ****** *)

 

=={{header|AutoHotkey}}==

values := [2,3,4,5,6,7,8,9,10,"J","Q","K","A"]

Gui, font, s14

GuiControl,, Deck, % deck

return

 

=={{header|AutoIt}}==

#Region ;**** Directives created by AutoIt3Wrapper_GUI ****

#AutoIt3Wrapper_Change2CUI=y

Print()

#EndRegion ;#### USAGE ####

{{Out|Example output}}

<pre>

2C|4D|6H|AC|KC|6S|3C|AS|KS|3H|4S|10D|AD|8D|7C|QH|4C|5H|5S|3D|2D|7D|9C|2S|QD|6C|KH|7S|3S|7H|8H|JH|QC|JC|10H|JD|KD|5D|5C|9H|8S|9D|QS|8C|10C|2H|6D|10S|9S|JS|AH

</pre>

 

=={{header|Batch File}}==

The data structure is a simple string with 3 characters per card, one char for the suit, a char for the pip (T) means ten and a last char not printed that would allow to sort a hand.

setlocal enabledelayedexpansion

 

set arr=!arr:@@@=%temp2%!

set "%~1=!arr!"

{{Out}}

<pre>

♥4 ♠4 ♣4 ♥J ♣A ♣9

</pre>

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

Suit$() = "Clubs", "Diamonds", "Hearts", "Spades"

Rank$() = "Ace", "Two", "Three", "Four", "Five", "Six", "Seven", \

REM Return the name of a card:

DEF FNcardname(card&)

Output:

<pre>Creating a new deck...

 

=={{header|C}}==

#include <stdlib.h>

#include <locale.h>

//free(d);

return 0;

<pre>

New deck, 52 cards: ♠A ♠2 ♠3 ♠4 ♠5 ♠6 ♠7 ♠8 ♠9 ♠10 ♠J ♠Q ♠K ♥A ♥2 ...

</pre>

See also [[Playing Cards/C]]

 

=={{header|C++}}==

#include <algorithm>

#include <ostream>

return os;

}

 

 

 

 

 

 

}

 

 

 

"""Run the example code for Rosetta Code ["Playing cards" task] (http://rosettacode.org/wiki/Playing_cards)."""

}

}

 

Output:

8 of ♠, 10 of ♥, 3 of ♠, 10 of ♣, 9 of ♥, 10 of ♠, 3 of ♣, J of ♠, K of ♣, K of ♦, A of ♠</pre>

 

(def pips [:ace 2 3 4 5 6 7 8 9 10 :jack :queen :king])

 

(println (format "%s of %ss"

(if (keyword? pip) (name pip) pip)

 

=={{header|COBOL}}==

{{works with|GnuCOBOL}}

program-id. playing-cards.

 

 

end program playing-cards.

 

{{out}}

queen of hearts</pre>

 

 

 

class Card

constructor: (@pip, @suit) ->

@cards[i] = @cards.splice(randomCard, 1, card)[0]

 

=={{header|Common Lisp}}==

A card is a cons of a suit and a pip. A deck is a list of cards, and so dealing is simply popping off of a deck. Shuffling is naïve, just a sort with a random predicate. Printing is built in.

 

'(club diamond heart spade)

"Card suits are the symbols club, diamond, heart, and spade.")

(sort list #'(lambda (x y)

(declare (ignore x y))

=={{header|D}}==

std.range, std.random;

 

while (!d.empty)

d.dealCard.writeln;

{{out}}

<pre>Deck:

 

===More Refined Version===

 

struct Card {

g.sortDeck.showDeck;

}

{{out}}

<pre>Host

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

 

Readln;

 

=={{header|E}}==

See [[Playing Cards/E]]

 

=={{header|Elixir}}==

{{trans|Erlang}}

defstruct pip: nil, suit: nil

end

end

 

 

{{out}}

 

This module is used by [[Go_Fish]].

-module( playing_cards ).

 

 

suites() -> ["Clubs", "Hearts", "Spades", "Diamonds"].

{{out}}

<pre>

Since our data structure is both a sequence and a stack, we can leverage the existing <code>randomize</code> word for shuffling and <code>pop</code> word for dealing.

 

vectors ;

IN: rosetta-code.playing-cards

randomize ! shuffle the deck

dup pop drop ! deal from the deck (and discard)

{{out}}

<pre>

 

=={{header|Fantom}}==

enum class Suit { clubs, diamonds, hearts, spades }

enum class Pips { ace, two, three, four, five,

}

}

 

=={{header|Forth}}==

{{works with|GNU Forth}}

 

create pips s" A23456789TJQK" mem,

new-deck shuffle .deck

5 .hand

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

 

IMPLICIT NONE

END SUBROUTINE Print_deck

 

Example use:

USE Cards

CALL Print_deck

This creates a new deck, shuffles it, deals five cards to hand, prints the cards in hand and then prints the cards remaining in the deck.

 

=={{header|Go}}==

 

import (

}

return hands, true

Example use:

 

import (

fmt.Println("\nReturning the cards to the deck")

fmt.Println(d)

Output:

<pre>

 

=={{header|Groovy}}==

 

enum Pip {

 

String toString() { cards.isEmpty() ? "Empty Deck" : "Deck $cards" }

Test Code

deck.shuffle()

Output:

<pre>TWO of DIAMONDS

 

Straightforward implementation with explicit names for pips and suits. A deck is just a list of cards. Dealing consists of splitting off cards from the beginning of the list by the usual pattern matching (not shown). Printing is automatic. Purely functional shuffling is a bit tricky, so here we just do the naive quadratic version. This also works for other than full decks.

 

data Pip = Two | Three | Four | Five | Six | Seven | Eight | Nine | Ten |

shuffle' g [] _ ys = ys

shuffle' g (x:xs) n ys = shuffle' g' xs (n+1) (insertAt k x ys) where

 

=={{header|Hy}}==

A simple program that deals out two five card hands.

 

(setv pips (.split "2 3 4 5 6 7 8 9 10 J Q K A"))

(setv suits (.split "♥ ♦ ♣ ♠"))

(print "\nThe first hand delt was:" (.join " " (map str first_hand)))

(print "\nThe second hand delt was:" (.join " " (map str second_hand)))

 

Sample Output:

The remaining cards in the deck are...

3♦ 6♥ 10♠ Q♦ 7♥ 2♠ 5♥ K♥ A♦ A♥ J♥ 4♣ 3♥ A♣ 8♦ 5♦ 10♥ 7♠ A♠ J♠ 5♣ 2♥ 9♥ 4♦ 8♠ 9♦ 6♠ 7♣ 10♣ 2♣ Q♥ Q♠ 9♠ 7♦ 8♥ Q♣ 3♠ 6♦ K♣ 4♠ K♦ J♦

 

=={{header|Icon}} and {{header|Unicon}}==

 

cards := 2 # cards per hand

procedure card2string(x) #: return a string version of a card

return x.pip || x.suit

Sample output:

<pre>New deck : 2H 3H 4H 5H 6H 7H 8H 9H 10H JH QH KH AH 2S 3S 4S 5S 6S 7S 8S 9S 10S JS QS KS AS 2D 3D 4D 5D 6D 7D 8D 9D 10D JD QD KD AD 2C 3C 4C 5C 6C 7C 8C 9C 10C JC QC KC AC

=={{header|J}}==

'''Solution:'''<br>

NB. Defines a Rosetta Code playing cards class

NB. Multiple decks may be used, one for each instance of this class.

)

 

 

'''Example use:'''

coinsert 'rcpc' NB. insert rcpc class in the path of current locale

pc=: newDeck ''

42 2

destroy__pc ''

 

=={{header|Java}}==

{{works with|Java|1.5+}}

 

 

The card:

private final Suit suit;

private final Pip value;

return value + " of " + suit;

}

The deck:

import java.util.LinkedList;

 

return deck.toString();

}

 

=={{header|JavaScript}}==

this.pip = pip;

this.suit = suit;

return this.deck.shift();

};

 

=={{header|Julia}}==

A deck consists of an array of integers and a <tt>DeckDesign</tt> type, which defines the meanings of the cards. This is a somewhat simplified implementation. While strictly speaking, a deck should be an array of cards, it is sufficient here to use integers. Indeed, cards and hands are just decks with smaller numbers of cards.

 

type DeckDesign{T<:Integer,U<:String}

rlen::T

Deck(collect(1:des.rlen*des.slen), des)

end

 

'''Define a Few of the Standard Methods'''

Many of these definitions are simply passed through to the card array component of the deck. But note that <tt>size</tt> returns parameters appropriate to a complete deck. This behavior is helpful when assigning meaning to any list of cards.

Base.isempty(d::Deck) = isempty(d.cards)

Base.empty!(d::Deck) = empty!(d.cards)

join(r.*s, " ")

end

 

'''Define Some Special Methods'''

<tt>deal!</tt> is the only deck specific method required to complete the essentials for this task.

 

function deal!{T<:Integer}(d::Deck, hlen::T)

if hlen < length(d)

chop(s)

end

 

'''Main'''

d = fresh(pokerlayout())

println("A new poker deck:")

println("And now the deck contains:")

println(pretty(d))

 

{{out}}

 

Create the deck.

s:"SHCD" / suites

 

/ create a new deck

newdeck:{deck::,/s,'\:v}

 

Show the deck.

 

show()

 

Shuffle the deck.

 

shuffle();show()

 

Deal: Get the N top cards and remove them from the deck.

Deal 5 cards.

deal:{c:deal1[x];deck::(deck _dvl c);c}

 

 

#deck / 5 cards are removed

 

Deal 3 more hands.

(("D6"

"DJ"

"H3"

"S6"

 

We now have 32 cards left.

32

show()

 

=={{header|Kotlin}}==

const val SUITS = "shdc"

 

println("\nThe 10 cards dealt from the bottom of the deck are:")

printDeck(dealtBottom)

Sample output:

{{out}}

 

The 10 cards dealt from the bottom of the deck are:

 

=={{header|Liberty BASIC}}==

Dim holdCards(1, 1)

Print "The Sorted Deck"

pipLabel$ = "Ace Deuce Three Four Five Six Seven Eight Nine Ten Jack Queen King"

pip$ = Word$(pipLabel$, faceValue)

 

=={{header|Logo}}==

{{works with|UCB Logo}}

make "pips {Ace Two Three Four Five Six Seven Eight Nine Ten Jack Queen King}

 

new.deck

shuffle.deck

 

=={{header|Lua}}==

===Version 1===

suits = {"Clubs", "Diamonds", "Hearts", "Spades"}

faces = {2,3,4,5,6,7,8,9,10,"Jack","Queen","King","Ace"}

print(d - 4 .. "")

print(-b .. "")

 

===Version 2===

local tBoard = {} -- cards in a board

local nPlayers = 5 -- number of players

 

print('ALL CARDS IN THE DECK\n', table.concat(tDeck, ' '), '\n')

 

Output:

2d 3d 4d 5d 6d 7d 8d 9d Td Jd Qd Kd Ad 2s 3s 4s 5s 6s 7s 8s 9s Ts Js Qs Ks As 2h 3h 4h 5h 6h 7h 8h 9h Th Jh Qh Kh Ah 2c 3c 4c 5c 6c 7c 8c 9c Tc Jc Qc Kc Ac

 

ALL CARDS IN THE DECK

7c 3d 8h 7h 7s 9c 8c Ks 8s 2s 5s 8d 2h 3h Jc 6h Td Ts Jh Tc 6s Kd 7d 4h 4d 5d Qd 5h 5c Kh 9d 2d Ah 6d 3c Js 9h 9s 6c Qc 2c Jd Ac Th 4s Qs Ad Qh 4c 3s As Kc

=={{header|M2000 Interpreter}}==

We can use one or more packs. When we need a card and deck has no card then a new pack inserted (automatic drop some random cards)

Module PlayCards {

Font "Arial" ' Ensure characters exist for Suits

}

PlayCards

 

=={{header|M4}}==

define(`setRand',

`define(`randSeed',ifelse(eval($1<10000),1,`eval(20000-$1)',`$1'))')dnl

deal deal(`b')

deal deal(`b')

 

DeckShuffle[deck_] := RandomSample[deck, Length@deck]

Example usage:

<pre>deck = DeckShuffle@MakeDeck[]; Print[deck]

 

=={{header|MiniScript}}==

pips = ["Ace","Two","Three","Four","Five","Six","Seven",

"Eight","Nine","Ten","Jack","Queen","King"]

hand = []

end for

return hand

display = function(stack)

for card in stack

end for

end function

print "Deck created. Cards in Deck: " + deck.len

print "First hand: "

display hand

{{out}}

Deck Shuffled

Nine of Diamonds (value: 308)

Seven of Clubs (value: 106)

 

=={{header|MUMPS}}==

 

=={{header|Nim}}==

 

type

 

 

 

 

 

for suit in Suit:

 

 

 

 

 

=={{header|OCaml}}==

Straightforward implementation with algebraic types for the pips and suits, and lists of their values. A deck is an array of cards.

Jack | Queen | King | Ace

let pips = [Two; Three; Four; Five; Six; Seven; Eight; Nine; Ten;

deck.(i) <- deck.(j);

deck.(j) <- temp

 

=={{header|PARI/GP}}==

Uses a global variable v to pass around the remaining cards in the deck. If used inside a function this would be a good case for a dynamically-scoped variable (<code>local</code>) rather than the typically-preferred lexical scoping of <code>my</code>.

newdeck()={

v=vector(52,i,i);

);

v

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

 

use strict;

 

@Playing_Card_Deck::suits = qw

{my $invocant = shift;

my $class = ref($invocant) || $invocant;

foreach my $suit (@Playing_Card_Deck::suits)

{foreach my $pip (@Playing_Card_Deck::pips)

# Removes the top card of the given deck and returns it as a hash

# with the keys "suit" and "pip".

 

sub shuffle

sub print_cards

# Prints out a description of every card in the deck, in order.

Some examples of use:

$deck->shuffle;

my %card = $deck->deal;

print uc("$card{pip} OF $card{suit}\n");

This creates a new deck, shuffles it, removes the top card, prints out that card's name in all caps, and then prints the rest of the deck.

 

{{out}}

 

=={{header|PHP}}==

{{works with|PHP|5.3+}}

Implementation:

{

// if unable to save as UTF-8, use other, non-UTF-8, symbols here

return $result[ 0 ];

}

 

Usage:

header( 'Content-Type: text/plain; charset=utf-8' );

 

 

// show the remaining cards in the deck

 

This will output something like:

♥A ♥6 ♦2 ♦5 ♥J ♣T ♦3 ♠5 ♠A ♣8 ♥8 ♥7 ♥K ♦7 ♥T ♦6 ♦T ♣6 ♣3 ♣A ♦4 ♥4 ♠6 ♣9</pre>

 

 

 

 

 

 

 

 

 

 

 

{{out}}

 

=={{header|PicoLisp}}==

{{trans|Common Lisp}}

Club Diamond Heart Spade )

 

 

(de shuffle (Lst)

 

=={{header|Prolog}}==

{{works with|SWI Prolog|4.8.0}}

 

 

A card is represented by the term "card(Pip, Suit)".

print_card(card(Pip, Suit)) :-

format('~a of ~a~n', [Pip, Suit]).

 

=={{header|PureBasic}}==

This approach keeps track of the cards in an abbrieviated form but allows them to be expanded to a more wordy form when they are dealt or shown.

Structure card

pip.s

Input()

CloseConsole()

Sample output:

<pre>Dealt: Queen of Hearts

=={{header|Python}}==

===Python 2.x, standalone===

 

class Card(object):

def deal(self):

self.shuffle() # Can't tell what is next from self.deck

 

===Python 3: extending [[Poker hand analyser#Python]]===

Assume the code from [[Poker hand analyser#Python]] is in a file pokerhand.py and importable.

from itertools import product

from random import randrange

print(deck.deal(), end=' ')

print()

 

{{out}}

 

The remaining cards are a Deck of 2♦ 2♠ 4♦ 4♠ 5♦ 6♦ 8♦ 8♣ j♥ j♠ q♦ a♦</pre>

 

=={{header|R}}==

suit <- c("Clubs", "Diamonds", "Hearts", "Spades")

# Create a deck

deck <- deal(deck)

# While no-one is looking, sneakily deal a card from the bottom of the pack

 

=={{header|Racket}}==

 

 

;; suits:

(set-box! deck (shuffle (unbox deck))))

 

(define (deck-deal deck)

(begin0 (first (unbox deck))

(deck-deal my-deck)

(deck-deal my-deck)

 

{{out}}

> </pre>

 

=={{header|REXX}}==

===version 1===

* 1) Build ordered Card deck

* 2) Create shuffled stack

Say 'Left on shuffled stack:'

Say ' 'subword(ss,1,26) /* and what's left on stack */

Output:

<pre>

===version 2===

A check is made to see if ASCII characters can be used to display the suits &nbsp; (if using an ASCII machine).

box = build(); say ' box of cards:' box /*a brand new standard box of 52 cards.*/

deck= mix(); say 'shuffled deck:' deck /*obtain a randomly shuffled deck. */

say; say right('[south]' hand.3, 60)

say; say; say; say 'remainder of deck: ' deck

/*──────────────────────────────────────────────────────────────────────────────────────*/

build: _=; ranks= "A 2 3 4 5 6 7 8 9 10 J Q K" /*ranks. */

@= @ word(_, ?) /*shuffled deck, 1 card at a time.*/

_= delword(_, ?, 1) /*elide just─chosen card from deck*/

{{out|output|text=&nbsp; when using the internal default values of four hands holding five cards:}}

<pre>

The Cards game, Screen shot : http://ring-lang.sourceforge.net/doc/_images/ringqt_shot48.jpg

 

Load "guilib.ring"

 

oTest = new qTest

oTest.qsleep(nTime)

 

=={{header|Ruby}}==

 

{{works with|Ruby|2.0.0+}}

# class constants

SUITS = %i[ Clubs Hearts Spades Diamonds ]

hand = deck.deal(5)

puts hand.join(", ")

 

{{out}}

 

=={{header|Run BASIC}}==

card$ = "A,2,3,4,5,6,7,8,9,T,J,Q,K" ' Cards Ace to King

 

next deal

print

<pre>TD 7S JD 7C 3H AS 6D QD KH 5H 2C QH 8C

8H 5S 7D 2D 2H 4D KS JS 7H QC KC 9S TH

=={{header|Rust}}==

{{libheader|rand}}

 

use std::fmt;

println!("{}", deck.deal().unwrap());

}

'''Sample output: 5 random cards'''

<pre>Jack of Diamonds

 

=={{header|Scala}}==

import scala.util.Random

 

}

override def toString():String="Deck: " + (cards mkString ", ")

Usage:

val deckShuffled:Deck=deck.shuffle

 

val (cards, rest3) =deckShuffled deal 6

println(cards)

Output:

<pre>Deck: Four of Diamonds, Two of Diamonds, Queen of Diamonds, Jack of Diamonds, Nine of Diamonds, Five of Diamonds, Seven of Diamonds, Ten of Diamonds, Six of Diamonds, Ace of Diamonds, King of Diamonds, Three of Diamonds, Eight of Diamonds, Ten of Spades, Seven of Spades, Eight of Spades, King of Spades, Ace of Spades, Three of Spades, Queen of Spades, Jack of Spades, Six of Spades, Five of Spades, Nine of Spades, Four of Spades, Two of Spades, Seven of Hearts, Queen of Hearts, Two of Hearts, Ten of Hearts, Eight of Hearts, Jack of Hearts, Four of Hearts, Nine of Hearts, Six of Hearts, King of Hearts, Five of Hearts, Three of Hearts, Ace of Hearts, King of Clubs, Jack of Clubs, Queen of Clubs, Six of Clubs, Three of Clubs, Two of Clubs, Eight of Clubs, Seven of Clubs, Ace of Clubs, Four of Clubs, Nine of Clubs, Five of Clubs, Ten of Clubs

The procedure <code>shuffle</code> requires an appropriate procedure <code>random</code> to be

defined. Some Scheme implementations provide this as an extension.

(quote (ace 2 3 4 5 6 7 8 9 10 jack queen king)))

 

(syntax-rules ()

((deal! deck hand)

Example:

(shuffle new-deck))

 

 

(display hand)

Sample output:

<pre>((jack . hearts) (5 . clubs) (9 . hearts) (7 . clubs) (6 . spades))</pre>

 

=={{header|Sidef}}==

define Suit = <♦ ♣ ♥ ♠>;

 

 

d.shuffle;

{{out}}

<pre>

===Version 1===

{{works with|GNU Smalltalk}}

instanceVariableNames: 'thePip theSuit'

classVariableNames: 'pips suits'

 

"create a deck, shuffle it, remove the first card and display it"

 

'''Note''': there's something odd with the class method for getting pips and suits; it's because I've not understood how to initialize class variables to certain values without the need to explicitly call a method to do so.

===Version 2===

{{works with|GNU Smalltalk}}

 

| cards |

'2c' '3c' '4c' '5c' '6c' '7c' '8c' '9c' 'Tc' 'Jc' 'Qc' 'Kc' 'Ac'

) deepCopy]

 

The Card class should obviously be more intricate to fulfil the needs of a CardGame class. :-)

 

Use example:

a Deck

st> myDeck displayNl

5

st> myHand

 

=={{header|Swift}}==

{{works with|Swift 2.0}}

 

Enter this into a playground to see results

import Foundation

 

 

 

 

=={{header|Tcl}}==

 

namespace eval playing_cards {

playing_cards::print $hand -sort true

puts "\nthe deck:"

 

=={{header|VBScript}}==

=====Implementation=====

class playingcard

dim suit

end sub

end class

 

=====Invocation=====

dim pack

set pack = new carddeck

end if

 

 

=====Output=====

Each users hand is another edit buffer.

There is no need for any routines to display the deck or a hand, since each of them is displayed in an edit window.

 

Call("CREATE_DECK")

Buf_Switch(#11) // players hand

Reg_ins(9) // insert the cards here

 

=={{header|zkl}}==

var suits=T(0x1F0D1,0x1F0C1,0x1F0B1,0x1F0A1); //unicode 🃑,🃁,🂱,🂡

 

fcn deal(cards=5){ deck.pop(0,cards); }

fcn toString{ deck.pump(String,"toString"); }

d.println(d.deck.len());

d.deal().println();

{{out}}

<pre>

🃄🂷🂤🃉🂡🂽🂥🂶🃃🃇🂳🂫🃍🃅🂭🃚🃞🃋🃘🂹🃛🂩🂺🃁🂮🂣🃖🂨🃙🃝🃒🂪🃂🃊🂲🃈🂧🃑🃆🂵🂴🃔🂾🂦🃓🂻🃕

</pre>