    #!/usr/bin/perl6

    use v6;

    if True {
        say "Hello";
    }

    if True {
    say "Hello"; # Bad indentation intended
            }

    if True { say "Hello" }

    if True {say "Hello"}

    if True { say "Hello" } else { say "Goodbye" }; say "world";

    ## BEGIN Comments

    say 1 #`( blah TODO blah
    here? ) 2 ;
    say 1 #`{{ blah TODO blah
    here? }} 2 ;
    say 1 #`[[ blah TODO blah ]
    here? ]] 2 ;
    say 1 #`««« blah TODO blah
    here? »»» 2 ;
    say 1 #` ( blah TODO blah
    2 ;

    #`[
      This is another multi-line comment. ]
    my @sorted = @names.sort({ %sets{$_} }).sort({ %matches{$_} }).reverse;
    #`{ So is this, though it's not actually multi-line. }

    say 'code again';

    #`(  Multiple line comments `( sub-comment )`)`

    ## END Comments

    #`[
    And this is how a multi would work.
    That says why we do what we do below.
    ]

    say "No more";

    #`{{a}a}} say ok

    say "No more";

    say "this is code";

    =begin pod

    A very simple Pod6 document

    =end pod

    =begin head1
    Top Level Heading
    =end head1

    =head1 Top level heading

    =for head1
    Top Level Heading

    =cutsdads

    =begin pod

    =head1 This is a head1 title

    This is a paragraph.

    =head2 Subsection
    # plop
    Here some text for the subsection.

    =end pod

    =begin table :caption<My Tasks>
    mow lawn
    take out trash
    =end table

    =head1 This is a heading block
    This is an ordinary paragraph.
    Its text will be squeezed and
    short lines filled. It is terminated by
    the first blank line.

    =head2 This is another heading block
    This is yet another ordinary paragraph,
    at the first virtual column set by the
    previous directive

    #| Base class for magicians
    class Magician {
      has Int $.level;
      has Str @.spells;
    }

    #| Fight mechanics
    sub duel(Magician $a, Magician $b) {
    }
    #=«<((
     <Magicians only, no mortals. >
     Magicians only, no mortals.
    ))>»

    say Magician.WHY;

    #|<< This is an example of stringification:
        * Numbers turn into strings
     >   * Regexes operate on said strings
        * C<with> topicalizes and places result into $_
    >>
    sub search-in-seq( Int $end, Int $number ) {
        with (^$end).grep( /^$number/ ) {
            .say for $_<>;
        }
    }
    #= Uses     * topic    * decont operator

    =head1 plop
    abc

    =head1 plop
    =para
    abc

    =head1 plop
     abc
    abc

    =head1 plop
    abc

    say 1;

    =head1 plop

    say 1;

    =for head1
    plop

    =for table :conf[str, 'str', "str", 1, True] :conf(str, 'str', "str", 1, True)
    =for table :conf<str 'str' "str" 1 True>
    =for table :conf{k => str, k=>'str', k=>"str", k=>1, k=>True}
    =for table :a :!b :42k :+s
    abc

    say 2;

    =begin a
    abc
    =end a

    =begin b sa
    =end b
    say 2;

    =begin a
    abc

    abc

    abc
    =end a
    say 0 ;
    =begin a:config{42}
    abc

    =head1 The
    Title

    abc
    =end ab
    say 1 ;

    =begin b sa
    =end b
    =begin a
    abc
    =begin b
    abc
    =end b a
    abc

    abc
    =end a
    say 3 ;

    =item a
    =item b
    =begin code
     =item a
    =end code

    =begin code
     =item a
     b
    =end code d
    =end code

    =begin comment
    Here are several
    lines
    of comment
    =end comment

    =begin pod
    =head1 acB<<I<a>>>a B<c> U<d> BB<a>

    C<my $var = 1; say $var;>
    Perl 6 homepage L<https://perl6.org> L<Perl 6 homepage|https://perl6.org>
    Comments L<#Comments> L<Comments|#Comments>
    Perl 6 is awesome Z<Of course it is!>
    Perl 6 is multi-paradigmatic N<Supporting Procedural, Object Oriented, and Functional programming>
    Enter your name K<John Doe> E<0xBB> characters.

    A X<hash|hashes, definition of; associative arrays>

    =DISCLAIMER
    P<http://www.MegaGigaTeraPetaCorp.com/std/disclaimer.txt>

    A X<hash|hashes, definition of; associative arrays>
    is an unordered collection of scalar values indexed by their
    associated string key.

        my @names = <Foo Bar Baz>;
        my @upper-case-names = @names.map: { .uc }    # OUTPUT: [FOO BAR BAZ]

    =end pod

    =begin table :caption<My Tasks>
    mow lawn
    take out trash
    =end table

    =begin table :config{caption => "My Tasks"}
    mow lawn
    take out trash
    =end table

    say "\c999 \c999999999 \c[LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER B] \c77s \c[77,22]";
    say "\x0 \x00 \x[0] \x[00] \x[f] \xaaa \xfffffff \xffh \x[ffff] \x[fffffff] \x[42,42]";
    say "\o0 \o00 \o[0] \o[00] \o[7] \o333 \o77777777 \o77h \o[333] \o[77777777] \o[42,42]";

    say Q[A literal string] ;
    say ｢More plainly.｣ ;
    say Q ^Almost any non-word character can be a delimiter!^ ;
    say Q ｢｢Delimiters can be repeated/nested if they are adjacent.｣｣ ;

    say Q (this is fine, because of space after Q) ;
    say Q 'and so is this' ;
    say Q<Make sure you <match> opening and closing delimiters> ;
    say Q{This is still a closing curly brace → \} ;

    say Q;yes, this is fine; ;
    say Q('this is a function') ;

    say 'Very plain';
    say q[This back\slash stays];
    say q[This back\\slash stays]; # Identical output
    say q{This is not a closing curly brace → \}, but this is → };
    say Q :q $There are no backslashes here, only lots of \$\$\$>!$;
    say '(Just kidding. There\'s no money in that string)';
    say 'No $interpolation {here}!';
    say Q:q!Just a literal "\n" here!;
    say Q:q[a\[]
    say Q[A literal string] ;
    say ｢More plainly.｣ ;
    say Q ^Almost any non-word character can be a delimiter!^ ;
    say Q ｢｢Delimiters can be repeated/nested if they are adjacent.｣｣ ;

    say qq[My favorite color is {$n+2}!];
    say qq{My favorite color\- is {$n+2}!};
    say Q:qq{My favorite color\- is {$n+2}!};
    say "My $color[0].uc(
    ) $n+$n.^name favorite color \q[1is] {$n+2}!abc&uc('a')";

    say qqww|a|;
    say qq:w:w|a|;
    say q:a:v|a|;

    say(qq:to/TERM INATOR/, 1+1);
     blah blah
     TERM INATOR

    my $don't-do-that = 1;
    my $piece_of_π = 3.14;
    my $駱駝道    = 1;
    my $lexical   = 1;
    my $*dynamic1 = 10;
    my $*dynamic2 = 100;

    sub say-all() {
        say "$lexical, $*dynamic1, $*dynamic2";
    }

    say-all();

    {
        my $lexical   = 2;
        my $*dynamic1 = 11;
        $*dynamic2    = 101;
    }

    my $square = 9 ** 2;
    my @array  = 1, 2, 3;   # Array variable with three elements
    my %hash   = London => 'UK', Berlin => 'Germany';

    class FailHash is Hash {
        has Bool $!final = False;
        multi method AT-KEY ( ::?CLASS:D: Str:D \key ){
            fail X::OutOfRange.new(:what("Hash key"), :got(key),
              :range(self.keys)) if $!final && !self.EXISTS-KEY(key);
            callsame
        }

        method finalize() {
            $!final = True
        }
    }

    my %h is FailHash = oranges => "round", bananas => "bendy";

    say %h<oranges>;
    %h.finalize;
    say %h<cherry>;
    CATCH { default { put .^name, ': ', .Str } }

    my ( @foo, $bar );
    @foo = ($bar) = 42, "str";

    say anon class þ {};
    say anon sub þ  { 42 };

    sub a {
        state @x;
        state $l = 'A';
        @x.push($l++);
    };

    say a for 1..6;

    sub foo($x) {
        my $v = @;
        $v[$x] = $x;
        say $v;
    }

    foo($_) for ^3;

    use MONKEY-TYPING;
    augment class Int {
        method is-answer { self == 42 }
    }
    say 42.is-answer;

    my $in = 0;

    sub f(*@c) {
        (temp $in)++;
         "<f>\n"
         ~ @c».indent($in).join("\n")
         ~ (+@c ?? "\n" !! "")
         ~ '</f>'
    };

    for <ab:c d$e fgh ij*> {
        .say if m/<-alpha>/;
    }

    for '.' {
        .Str.say when !.IO.d;
        .IO.dir()».&?BLOCK when .IO.d # lets recurse a little!
    }

    use Dog:auth<Somebody>:ver<2.0>;

    infix:<+>
    infix:<*>
    infix:«<=»

    postfix:<²>
    WOW:That'sAwesome
    WOW:That's<<🆒>>
    party:sweet<16>

    infix:<+>
    infix:<<+>>
    infix:«+»
    infix:['+']
    infix:('+')

    my $a:b<c>:d<e> = 100;
    my $a:d<e>:b<c> = 200;
    say $a:b<c>:d<e>;

    use Test; plan 1; constant &term:<👍> = &ok.assuming(True);
    👍

    my $x = do if True { 42 };

    say 1000000, 1_000_000, 10_00000, 100_00_00;
    say -2, 12345, 0xBEEF, 0o755, :3<1201>;
    say 1.0, 3.14159, -2.5, :3<21.0012>;
    say 1e0, 6.022e23, 1e-9, -2e48, 2e2i, .42;
    say 2.e2, .2, 0o39, 0xfF3u, 0oi, 0xi, :3<>, :23<gg ; # error

    for $size «[r/]« (2**60, 2**50, 2**40, 2**30, 2**20, 2**10)
              Z      <EB     PB     TB     GB     MB     KB> -> [\v,\suffix]

    my $a = 32;
    $a += 10;
    $a -= 2;
    $a = 3;
    $a min= 5;
    $s ~= 'b';

    sub infix:<space-concat> ($a, $b) { $a ~ " " ~ $b };
    my $a = 'word1';
    $a space-concat= 'word2';

    my Real $a = 1/2;
    $a = 3.14;
    $a .= round;

    my $a = True;
    say so $a != True;
    my $i = 10;

    my $release = Date.new(:2015year, :12month, :24day);
    my $today = Date.today;
    say so $release !before $today;

    say 4 R/ 12;
    say [R/] 2, 4, 16;
    say [RZ~] <1 2 3>,<4 5 6>

    say (1, 2, 3) »*» 2;
    say (1, 2, 3, 4) »~» <a b>;
    say (1, 2, 3) »+« (4, 5, 6);
    say (&sin, &cos, &sqrt)».(0.5);

    say @a »+=» 1;
    my ($a, $b, $c);
    (($a, $b), $c) «=» ((1, 2), 3);

    say !« @wisdom;
    @a»++;
    say -« [[1, 2], 3];

    @slops».?this-method-may-not-exist();

    my %outer = 1, 2, 3 Z=> <a b c>;
    my %inner = 1, 2 Z=> <x z>;
    say %outer «~» %inner;

    say $neighbors »>>+<<» ($p, *);

    sub plus { $^a + $^b };
    say [[&plus]] 1, 2, 3;

    my @n = [\~] 1..*;
    say @n[^5];

    @l = <a b c d> Z~ 1, 2, *;
    say so 1 S& 2 S& 3;
    @a X[+=] @b;
    multi sub postfix:<++>($x is rw) is assoc<non>
    say $filename++ for 1..3;
    $x % $y == $x - floor($x / $y) * $y
    say <a a b c a d> ⊍ bag(<a a b c c>);
    say -« <1 2 3>

    # This is wrong: creates a Hash of Mixes, not Mix:
    my Mix %mix;
    # Works with $ sigil:
    my Mix $mix;
    # Can be typed:
    my Mix[Int] $mix-of-ints;

    my $x;
    my $x = 7;
    my Int $x = 7;
    my Int:D $x = 7;
    ndef)
    my Int $x where { $_ > 3 } = 7;
    my Int $x where * > 3 = 7;

    $str ~~ tr:d:c!dol!wne!;
    $str ~~ TR:c/dol/wne/;
    $str ~~ s!foo!fox!;
    $str ~~ /foo/bar/;
    $str ~~ ///;
    $str ~~ rx/foo/bar/;
    $str ~~ Q :regex /foo/;
    $str ~~ s{b(.)r} = " d$0n";
    $str ~~ regex{fox}; # error
    $str ~~ regex {fox};
    rx/ ^ab /;
    / ^ ab /;
    rx/ \d ** 2/;
    $str ~~ tr:d:c!dol!wne!;
    $str ~~ TR:c/dol/wne/;
    $str ~~ s!foo!fox!;
    $str ~~ rx/foo/;
    $str ~~ regex:ds {fox};
    $str ~~ regex{fox};
    my a = /a/;
    rx/ ^ab /;
    a = / ^ ab 'a' "$a" \d \n\n <:L :Script<Latin>> <:Block('Basic Latin')>  /;
    //;
     rx:sigspace.\d+ < :Script +:Block "Basic Latin" + :L> #plop
    '-'.;
    rx/ \d ** 2 <[\d a d]+[\x233..\] " \c[dsds]]>/;
    say $str ~~ m:g/[(<[ACGT]> **: 3) \s*]+ \s+ (<[A..Z a a..z \s]>+)/;
    say '$333' ~~ m/^^ <?[$]> . \d+ /;
    say '/foo/o/bar/' ~~ /\/.**!{1..10}\//;
    rx(a);
    rx (a);
    $str ~~ regex {fox};
    $str ~~ s{b(.)r} = " d$0n";
    if 'abc' ~~ / [a||b] (c) / {
        say ~$0;                # OUTPUT: «c␤»
    }
    if 'abc' ~~ / $<myname> = [ \w+ ] / {
        say ~$<myname>      # OUTPUT: «abc␤»
    }
    say 'abc' ~~ / a <( b )> c/;
    say 'abc' ~~ / <(a <( b )> c)>/;
    say "abc" ~~ /a. | ab { print "win" } /;

    so 'hello world' ~~ m:Perl5/^hello (world)/;   # OUTPUT: «True␤»
    so 'hello world' ~~ m/^hello (world)/;         # OUTPUT: «False␤»
    so 'hello world' ~~ m/^ 'hello ' ('world')/;   # OUTPUT: «True␤»

    say "Abra abra CADABRA" ~~ m:exhaustive/:i a \w+ a/;

    my regex ipv4-octet { \d ** 1..3 <?{ $/.Int <= 255 && $/.Int >= 0 }> }
    my regex ipv4-octet { \d ** 1..3 <?{ True }> }
    say 'abc' ~~ / <?before a> && . /;
    say 'abcdefg' ~~ rx{ abc <[email protected]ending_letters> };
    s:g[\d+ <?before \s* @units>] = 5 * $/;

    sub walk(\thing, *@keys) is rw {
        my $current := thing;
        for @keys -> $k {
            if $k ~~ Int {
                $current := $current[$k];
            }
            else {
                $current := $current{$k};
            }
        }
        $current;
    }

    my %hash;
    walk(%hash, 'some', 'key', 1, 2) = 'autovivified';

    say %hash.perl;

    class X::WithoutLineNumber is X::AdHoc {
        multi method gist(X::WithoutLineNumber:D:) {
            $.payload
        }
    }
    die X::WithoutLineNumber.new(payload => "message")

    { return; CATCH { default { $*ERR.say: .^name, ': ', .Str } } }

    multi sub trait_mod:<is>(Routine $r, :$export!)

    react {
        whenever signal(SIGINT) {
            say "goodbye";
            done
        }
    }

    signal(SIGINT).tap: { say "bye"; exit }; loop {}

    method base-repeating(Rational:D: Int:D() $base = 10)

    multi sub prefix:<-->($x is rw) is assoc<non>

    multi MAIN(Bool :$man) {
        run $*EXECUTABLE, '--doc', $*PROGRAM;
    }

    for $file.lines -> $line {
        next unless $line; # ignore any empty lines

        my ($pairing, $result) = $line.split(' | ');
        my ($p1, $p2)          = $pairing.words;
        my ($r1, $r2)          = $result.split(':');

        %sets{$p1} += $r1;
        %sets{$p2} += $r2;

        if $r1 > $r2 {
            %matches{$p1}++;
        } else {
            %matches{$p2}++;
        }
    }

    for @sorted -> $n {
        my $match-noun = %matches{$n} == 1 ?? 'match' !! 'matches';
        my $set-noun   = %sets{$n} == 1 ?? 'set' !! 'sets';
        say "$n has won %matches{$n} $match-noun and %sets{$n} $set-noun";
    }

    say "Math: { 1 + 2 }";

    my @people = <Luke Matthew Mark>;
    say "The synoptics are: {@people}";

    say "{%sets}";
    say "we have @flavors[0]";
    say "we have @flavors[]";
    say "we have @flavors.sort()";
    say "we have @flavors.sort.join(', ')";

    my @valid-players = $file.get.words;

    for $file.lines -> $line {
        my ($pairing, $result) = $line.split(' | ');
        my ($p1, $p2)          = $pairing.split(' ');
        if $p1 ∉ @valid-players {
            say "Warning: '$p1' is not on our list!";
        }
        if $p2 ∉ @valid-players {
            say "Warning: '$p2' is not on our list!";
        }
    }

    my @array = [ 'x', 'xx', 'xxx', 'o', 'oo', 'X', 'Y', 'Z' ];
    my @array = <  x    xx    xxx    o    oo    X    Y    Z  >;

    sub plus { $^a + $^b };
    say [[&plus]] 1, 2, 3;

    say [X~] (1, 2), <a b>;

    my @n = [\~] 1..*;
    say @n[^5];

    my @l = <a b c d> Z~ ':' xx *;
       @l = <a b c d> Z~ 1, 2, *;

    say so 1 S& 2 S& 3;

    say %color«cherry "$fruit"».raku
    say $a.:<++>;

    say 2 !(elem) (1, 2, 3);

    say $_ if /A/ ^ff^ /C/ for @list

    my @result;
    <people of earth>
        ==> map({ .tc })
        ==> my @caps; @caps   # also could wrap in parentheses instead
        ==> grep /<[PE]>/
        ==> sort()
        ==> @result;

    my @result
        <== sort()
        <== grep({ /<[PE]>/ })
        <== my @caps            # unlike ==>, there's no need for additional statement
        <== map({ .tc })
        <== <people of earth>;

    False and do { 42.say };
    3, do if 1 { 2 }  ;
    if 0 { say "no" } elsif False { say "NO" } else { say "yes" }
    $_ = 1; unless False -> $a { $a.say } ;
    when so $a { say 'a' }

    for 1..100 {
        when * %% 15 { say 'FizzBuzz' }
        when * %% 3  { say 'Fizz' }
        when * %% 5  { say 'Buzz' }
        default      { say $_ }
    }

    multi sub grab(**@a) { "grab $_".say for @a }
    multi sub grab(\a) {
        a ~~ Iterable and a.VAR !~~ Scalar ?? nextwith(|a) !! nextwith(a,)
    }

    for '.' {
        .Str.say when !.IO.d;
        .IO.dir()».&?BLOCK when .IO.d # lets recurse a little!
    }

    say a».(0.5); say a>>.(0.5); a.:<sa> ; a. sa :!False
    func <a b>

    if 'abc-abc-abc' ~~ / $<string>=( [ $<part>=[abc] ]* % '-' ) / {
        say ~$<string>;          # OUTPUT: «abc-abc-abc␤»
        say ~$<string><part>;    # OUTPUT: «abc abc abc␤»
        say ~$<string><part>[0]; # OUTPUT: «abc␤»
    }

    [«[«[«[+]»]»]»] <1 2 3 4>