title: Minimizing flights of stairs climbed

text:
# Question
Title: Minimizing flights of stairs climbed
# Challenge

Given input as a list/array of natural numbers that each represent the floor of a class a student has to go to, sort the numbers in a way such that the MAD (mean average deviation) number of flights between classes is minimized, thus saving energy and preventing the chance of being late to a class.

When sorted like this, the highest floor is in the middle of the list/array and the lowest floors are on the sides.

# Rules

* The student starts and ends on the first floor for entering and exiting the school building.
* The student only uses the stairs to get to each class.
* The list is in sequential order.
* This is code-golf, so answers will be scored in bytes with fewer bytes being the goal.

# Test cases

| Input | Possible Outputs |
| --- | --- |
| 8, 9, 6, 4, 7, 10, 5, 7, 8 | 4, 6, 7, 8, 10, 9, 8, 7, 5
5, 7, 8, 9, 10, 8, 7, 6, 4 |
| 4, 7, 3, 5, 7, 8, 4, 2, 4 | 2, 4, 4, 7, 8, 7, 5, 4, 3
3, 4, 5, 7, 8, 7, 4, 4, 2 |
| 4, 1, 2, 3, 2, 9, 4, 6, 2, 8 | 2, 2, 4, 6, 9, 8, 4, 3, 2, 1
1, 2, 3, 4, 8, 9, 6, 4, 2, 2 |

# Answer
> 14 votes
# Vyxal, 3 bytes

```
smy

```

Try it Online!

Look ma, no Unicode!

```
s   # Sort
 m  # Mirror, appending the reverse
  y # Push every second item, and the rest.

```

# Answer
> 10 votes
# Python 2 or 3,  ~~40~~  35 bytes

```
lambda a:a.sort()or(a+a[::-1])[::2]

```

**Try it online!**

### How?

Sort the input list, append (`+`) the sorted input list in reverse (`[::-1]`), take every other value (`[::2]`).

Note that `a.sort()` sorts `a` and returns `None`, which is falsey, and, as such, the `or` evaluates its right argument, `(a+a[::-1])[::2]` where we use the now sorted `a`.

# Answer
> 4 votes
# jq, 26 bytes

Takes a list of numbers as input, outputs as a stream. Uses the same method as Jonathan Allan answers.

```
sort|(.+reverse)[keys[]*2]

```

Try it online!

# Answer
> 3 votes
# Jelly, 5 bytes

```
Ṣm0m2

```

A monadic Link that accepts a list of positive integers and yields a list of positive integers.

**Try it online!**

### How?

```
Ṣm0m2 - Link: list of positive integers, F
Ṣ     - sort F
 m0   - append the reverse (m is overloaded to do this when given 0)
   m2 - modulo-2 slice (get every other value)

```

# Answer
> 3 votes
# JavaScript (ES6), 54 bytes

```
f=a=>+a?a:[a.sort((a,b)=>b-a).pop(),...f(a)].reverse()

```

Try it online!

### How?

At each iteration, we pick the smallest element from the original array, append the result of a recursive call and reverse the resulting array. We stop when there's only one element remaining in the original array.

For the input `[8, 9, 6, 4, 7]`, this gives:

```
5th iteration: [ **9** ]
4th iteration: [ **8**, 9 ] -> [ 9, 8 ]
3rd iteration: [ **7**, 9, 8 ] -> [ 8, 9, 7 ]
2nd iteration: [ **6**, 8, 9, 7 ] -> [ 7, 9, 8, 6 ]
1st iteration: [ **4**, 7, 9, 8, 6 ] -> [ 6, 8, 9, 7, 4 ]
```

# Answer
> 2 votes
# Factor, 55 bytes

```
[ natural-sort dup <evens> swap <odds> reverse append ]

```

Try it online!

## Explanation

It's a quotation (anonymous function) that takes a sequence from the data stack and leaves a sequence on the data stack. Assuming `{ 8 9 6 4 7 10 5 7 8 }` is on the data stack when this quotation is called...

| Word | Comment | Data stack (top on right) |
| --- | --- | --- |
| `natural-sort` | Sort into ascending order | `{ 4 5 6 7 7 8 8 9 10 }` |
| `dup` | Copy top of stack | `{ 4 5 6 7 7 8 8 9 10 } { 4 5 6 7 7 8 8 9 10 }` |
| `<evens>` | Get elements at even indices as a virtual sequence | `{ 4 5 6 7 7 8 8 9 10 } T{ evens { seq { 4 5 6 7 7 8 8 9 10 } } }` |
| `swap` | Swap top two data stack objects | `T{ evens { seq { 4 5 6 7 7 8 8 9 10 } } } { 4 5 6 7 7 8 8 9 10 }` |
| `<odds>` | Get elements at odd indices as a virtual sequence | `T{ evens { seq { 4 5 6 7 7 8 8 9 10 } } } T{ odds { seq { 4 5 6 7 7 8 8 9 10 } } }` |
| `reverse` | Reverse a sequence | `T{ evens { seq { 4 5 6 7 7 8 8 9 10 } } } { 9 8 7 5 }` |
| `append` | Append a sequence to another sequence | `{ 4 6 7 8 10 9 8 7 5 }` |

# Answer
> 2 votes
# 05AB1E, 4 bytes

```
{Â«ι

```

Outputs both possible results. If this is not allowed, add a trailing `н` or `θ` to leave just the first or last list of the pair instead.

Try it online or verify all test cases.

**Explanation:**

```
{     # Sort the (implicit) input-list
 Â    # Bifurcate it, short for Duplicate & Reverse copy
  «   # Merge the lists together
   ι  # Uninterleave it into two lists
      # (after which this pair of lists is output implicitly as result)

```

# Answer
> 2 votes
# Ruby, ~~45 38~~ 36 bytes

```
->l{a=0;l+l.sort!.map{l.slice!a-=1}}

```

Try it online!

### How on earth?

I think this should be undefined behaviour, but somehow it works:

* `l.sort!` is the first step, we need a sorted array to perform our magic
* `l.sort!.map` does not iterate on the **original** array and will stop as soon as it reaches the last element of the **current** array.
* `l.slice!a-=1` gets the elements in reverse order, skipping one at every iteration. The first element will be the max, on the second iteration, we will get the second last, which will be the 3rd highest number (because the max was removed, and the last element is now the 2nd highest number). And so on.
* Finally, `l+l.sort!.map{...}` will join the remaining element in l with the result of the mapping operation. Again, we are not using the original array to perform the addition, but the current array.

# Answer
> 1 votes
# MathGolf, ~~11~~ 7 bytes

```
]êsx{▐x

```

-4 bytes by porting *@Arnauld*'s JavaScript answer (with an iterative instead of recursive approach).

Try it online.

**Explanation:**

```
]        # Wrap the stack into a list, so we start with an empty list []
 ê       # Push the inputs as an integer-array
  s      # Sort it
   x     # Reverse it
    {    # Loop over these descending sorted values:
     ▐   #  Append the current value to the list
      x  #  And reverse the entire list
         # (after the loop the entire stack is output implicitly as result)

```

# Answer
> 1 votes
# , ~~41~~ 37 bytes

*-4 bytes thanks to @Dominic van Essen.*

```
function(x)c(y<-sort(x),rev(y))[!1:0]

```

Try it online!

Uses the most common strategy here.

The index `!1:0` is recycled to vector length and therefore alternates `FALSE TRUE FALSE TRUE...` to get every second element.

# Answer
> 1 votes
# Wolfram, 33 bytes

```
Join[#,Reverse@#][[;;;;2]]&@*Sort

```

Try it here!

Logic copied from other answers. Sort, join with reverse, take every other item

# Answer
> 1 votes
# C (gcc), ~~154~~ \\$\cdots\\$ ~~119~~ 117 bytes

```
i;j;k;*b;*f(a,l)int*a;{i=j=qsort(a,l,4,L"\x62b078bǃ");b=malloc(4*l);for(k=-~l-l%2;i<l;j+=2)b[i++]=a[j/l?k-=2:j];a=b;}

```

Try it online!

*Saved a whopping 21 bytes thanks to ceilingcat and his execstack magic!!!*

Inputs the a pointer to an array of floors of classes that a student has to go to as natural numbers \\${1 \dots n}\\$, and the array's length (because pointers in C carry no length information).
Return a pointer to an array of the floors sorted so that the mean average deviation of flights between classes are minimized.

# Answer
> 0 votes
# Japt, ~~7~~ ~~6~~ 5 bytes

```
Íê1 ë

```

Try it

# Answer
> 0 votes
# TI-Basic, 49 bytes

```
Prompt A
SortA(ʟA
dim(ʟA
seq(2fPart(I/2)(I-Ans-.5)+Ans-I/2+1,I,1,Ans→B
SortA(ʟB,ʟA

```

Input is sorted in-place.

# Answer
> 0 votes
# Charcoal, ~~23~~ 18 bytes

```
Ｗ⌈⁻θυＦ№θι≔⮌⊞ＯυιυＩυ

```

Try it online! Link is to verbose version of code. Explanation: Port of @KevinCruijssen's answer.

```
Ｗ⌈⁻θυ

```

Repeat until the output contains all of the floors in the input list (fortunately floors are 1-indexed in the US, so the maximum only becomes falsy when the set difference is empty).

```
Ｆ№θι

```

Repeat once for each occurrence of the maximum floor in the input list.

```
≔⮌⊞Ｏυιυ

```

Push the maximum floor to the predefined empty list, then reverse it.

```
Ｉυ

```

Output the resulting list.

# Answer
> 0 votes
# Arturo, 36 bytes

```
$=>[x:sort&map x++reverse x[a,b]->a]

```

Try it

Sort, append reverse, take every other element.

# Answer
> 0 votes
# Thunno, \\$ 8 \log\_{256}(96) \approx \\$ 6.58 bytes

```
z:DrA+Zl

```

Attempt This Online!

Outputs both possible results. For the first, add a trailing `AJ`, and for the second, add a trailing `AK`.

#### Explanation

```
z:DrA+Zl  # Implicit input
z:        # Sort
  Dr      # Bifurcate
    A+    # Concatenate
      Zl  # Uninterleave
          # Implicit output

```

---
Tags: code-golf, array
---


title: Dad jokes are fun

text:
# Question
Title: Dad jokes are fun
We all know the classic dad joke that goes something like this:

1. Somebody says a sentence to describe their self (e.g. `I'm tired` or `I'm confused`).
2. A dad-joke enthusiast comes along and replies `Hi <adjective>, I'm Dad!`, because introductions follow the same format (`I'm Peter` follows the same format as `I'm hungry`).

Your job is to take in an input in the form of a self-descriptor, and output the appropriate dad-joke form, but instead of using the word "Dad", you'll use the name of the programming language you're programming in.

Test cases (assume that they are being parsed by Python):

```
I'm amazing                  Hi amazing, I'm Python!
I'm tired                    Hi tired, I'm Python!
I'm hungry                   Hi hungry, I'm Python!
I'm fat                      Hi fat, I'm Python!

```

Now assume that these test cases are being parsed by Golfscript:

```
I'm a programmer             Hi a programmer, I'm Golfscript!
I'm a question-writer        Hi a question-writer, I'm Golfscript!
I'm a Stack-Overflow-er      Hi a Stack-Overflow-er, I'm Golfscript!

```

The exact challenge:

1. Take in a string in the self-descriptor format (`I'm <adjective>` or `I'm a(n) <noun>`) using standard input or through a function.

* Assume there is no ending punctuation.
* Assume the word `I'm` is used and not `I am`.

2. Convert it to a dad-joke format - see the above examples for exactly how that should look.

Other stuff:

# Answer
# , 13 bytes

```
cEHi<esc>A, <C-r>" V!
```

Try it online!

Inspired by tsh's answer

This takes advantage of the fact that `I'm` is yanked from the start of the string when deleting the text from the start, and pastes it to the end with `<C-r>"` while in insert mode.
> 30 votes

# Answer
# C (gcc), ~~59~~ ~~42~~ 33 bytes

-17 bytes thanks to @Conor O'Brien noticing that the import wasn't necessary

-9 bytes thanks to @tsh pointing out a shorter, UB way of writing the function

```
a(x){printf("Hi%s, I'm C!",x+3);}

```

Try it online!

Chops off the first 3 characters of the input (removes `I'm`) and surrounds it with the desired text.
> 21 votes

# Answer
# , 13 bytes

```
cEHi<Esc>A, <C-O>p V!

```

Try it online!

New to `V`. Just knew it about 30 minutes ago. Anyway, this language is chosen just because its name only cost 1 byte. I'm not sure how to send `<End>` key in V. Most vim environment would accept `<End>` as a replacement of `<Esc>A` in this example. But, you know, V is 2 characters shorter than vim. :)

Thanks to @Candy Gumdrop, saves 1 byte.
> 19 votes

# Answer
# Excel, ~~36~~ 34 bytes

-2 bytes thanks to Johan du Toit.

Input goes into A1.

```
="Hi "&MID(A1,4,99)&", I'm Excel!"

```

First attempt:

```
=REPLACE(A1,1,3,"Hi")&", I'm Excel!"

```
> 13 votes

# Answer
# brainfuck, 164

```
,-.+>,>,----.++++>,.>,[.,]<<<+++++.----->>.[<]>[.>]<[->+++<]>++.[--->+<]>----.+++[->+++<]>++.++++++++.+++++.--------.-[--->+<]>--.+[->+++<]>+.++++++++.+[++>---<]>-.

```

Try it online!

The "brainfuck!" part of the string is generated with this tool, can probably be golfed further by hand.
> 12 votes

# Answer
# Stax, 13 bytes

```
â∞¿φ‼0▲(─ƒSqÄ

```

Run and debug it

Unpacked, ungolfed, and commented, it looks like this.

```
.Hip        print "Hi" with no newline
3tp         trim 3 characters from start of input and print with no newline
            final line is to print the unterminated compressed literal ", I'm stax!"
`dYgAwg_

```

I moved the final comment up one line since nothing may follow an unterminated string literal.

Run this one
> 11 votes

# Answer
# Python 3, ~~35~~ 34 bytes

```
lambda s:"Hi%s, I'm Python!"%s[3:]

```

Try it online!

-1 byte thanks to Embodiment of Ignorance

Also 34 bytes, using the newer formatted strings, thanks to Gábor Fekete:

```
lambda s:f"Hi{s[3:]}, I'm Python!"

```

Try it online!
> 10 votes

# Answer
# Ruby `-p`, ~~32~~ ~~27~~ 26 bytes

-5 bytes by leveraging Nick Kennedy's Jelly answer.

-1 byte from splitting on a different point in the string. Also realized my old bytecount was wrong.

```
~/m/;$_="Hi#$', I'm Ruby!"

```

### Explanation

```
                            # -p gets line of input and saves to $_
~/m/;                       # Find first 'm' in $_ using regex
     $_="Hi#$', I'm Ruby!"  # Save modified string to $_
                            # ($' is the string AFTER the most recent regex match)
                            # -p outputs $_ to screen

```

Try it online!
> 9 votes

# Answer
# x86, ~~37~~ 36 bytes

```
00000000: d1ee ac8a d8c6 0024 adc7 0448 698b d6b4  .......$...Hi...
00000010: 09cd 21ba 1901 cd21 c32c 2049 276d 2078  ..!....!., I'm x
00000020: 3836 2124                                86!$

```

Unassembled:

```
D1 EE       SHR  SI, 1                  ; point SI to DOS PSP (80H)
AC          LODSB                       ; load string length into AL, advance SI
8A D8       MOV  BL, AL                 ; put string length into BL
C6 40 24    MOV  BYTE PTR[BX][SI], '$'  ; add string terminator to end of string
AD          LODSW                       ; advance SI two chars
C7 04 6948  MOV  WORD PTR[SI], 'iH'     ; replace second and third char with 'Hi'
8B D6       MOV  DX, SI                 ; load offset for INT 21H string function
B4 09       MOV  AH, 9                  ; display a '$'-terminated string function
CD 21       INT  21H                    ; call DOS API
BA 0119     MOV  DX, OFFSET S           ; load offset for second part of string
CD 21       INT  21H                    ; call DOS API
C3          RET                         ; return to DOS
S  DB ", I'm x86!$"

```

A standalone executable DOS program. Input from command line, output to screen.

* The exact "language" name here is a little ambiguous as CPU machine code isn't really a language in a formal sense. Going with "x86" as a generally understood and accepted name for the target platform.
> 9 votes

# Answer
# R ~~45~~ ~~44~~ 39 bytes

@Giuseppe Edit

```
sub("I'm(.*)","Hi\\1, I'm R",scan(,""))

```

---

@AaronHayman Edit

```
function(s)sub("I'm (.*)","Hi \\1, I'm R",s)

```

---

Try it online!
> 8 votes

# Answer
# Java, 36 bytes

```
s->"Hi"+s.substring(3)+", I'm Java!"

```

Try it online.
> 7 votes

# Answer
# Whitespace, 267 bytes

```
[S S S T    S S T   S S S N
_Push_72_H][T   N
S S _Print_as_character][S S S T    T   S T S S T   N
_Push_105_i][T  N
S S _Print_as_character][S S S N
_Push_0][S N
S _Duplicate_0][S N
S _Duplicate_0][T   N
T   S _Read_STDIN_as_character][T   N
T   S _Read_STDIN_as_character][T   N
T   S _Read_STDIN_as_character][N
S S N
_Create_Label_INPUT_LOOP][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S N
S _Duplicate_input][S S S T S T S N
_Push_10][T S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_TRAILING][T N
S S _Print_as_character][N
S N
N
_Jump_to_Label_INPUT_LOOP][N
S S S N
_Create_Label_TRAILING][S N
N
_Discard_top][S S T T   S S S T S T N
_Push_-69_!][S S T  T   N
_Push_-1_e][S S T   T   T   N
_Push_-3_c][S S T   T   S T N
_Push_-5_a][S S S T S T S N
_Push_10_p][S S S T T   S T N
_Push_13_s][S S T   T   N
_Push_-1_e][S S S T T   T   S N
_Push_14_t][S S S T T   N
_Push_3_i][S S S T  S N
_Push_2_h][S S T    T   T   T   T   N
_Push_-15_W][S S T  T   S S S T T   S N
_Push_-70_space][S S S T    T   T   N
_Push_7_m][S S T    T   T   T   T   T   T   N
_Push_-63_'][S S T  T   T   T   S T N
_Push_-29_I][S T    S S T   T   N
_Copy_0-based_3rd_-70_space][S S T  T   T   T   S T S N
_Push_-58_,][N
S S T   N
_Create_Label_PRINT_TRAILING_LOOP][S S S T  T   S S T   T   S N
_Push_102][T    S S S _Add][T   N
S S _Print_as_character][N
S N
T   N
_Jump_to_Label_PRINT_TRAILING_LOOP]

```

Letters `S` (space), `T` (tab), and `N` (new-line) added as highlighting only.
`[..._some_action]` added as explanation only.

Since Whitespace inputs one character at a time, the input should contain a trailing newline so it knows when to stop reading characters and the input is done.

Try it online (with raw spaces, tabs, and new-lines only).

**Explanation in pseudo-code:**

```
Print "Hi"
Read three characters from STDIN, and do nothing with them
Start INPUT_LOOP:
  Character c = STDIN as character
  If(c == '\n'):
    Call function PRINT_TRAILING
  Print c as character
  Go to next iteration of INPUT_LOOP

function PRINT_TRAILING:
  Discard the top of the stack (the c='\n' that was still on the stack)
  Push "!ecapsetihW m'I ," one character at a time
  Start PRINT_TRAILING_LOOP:
    Print as character
    Go to next iteration of PRINT_TRAILING_LOOP

```

The characters of `", I'm Whitespace!"` are pushed in reversed order, and then printed in a loop. All values of these characters are also lowered by 102, which are added in the loop before printing to save bytes. This constant 102 to lower each character with is generated with this Java program. Also, instead of pushing the value `-70` for both spaces twice, the second space in `"!ecapsetihW m'I ,"` is copied from the first with the Copy builtin to save a few bytes.
> 7 votes

# Answer
# PHP, ~~34~~ 32 bytes

```
Hi<?=substr($argn,3)?>, I'm PHP!

```

Try it online!

Input via `STDIN`, call with -F.

```
$ echo I'm a Stack-Overflow-er|php -F dad.php
Hi a Stack-Overflow-er, I'm PHP!

$ echo I'm hungry|php -F dad.php
Hi hungry, I'm PHP!

```
> 7 votes

# Answer
# Perl 5 `-p`, ~~31~~ 24 bytes

*Cut down based on clarifications from OP and a suggestion from @NahuelFouilleul.*

```
/ /;$_="Hi $', $` Perl!"

```

Try it online!
> 6 votes

# Answer
# IBM/Lotus Notes Formula Language, ~~61~~ 62 bytes

+1 because I hadn't noticed the `!` at the end of the output.

```
"Hi"+@Right(i;"I'm")+", I'm IBM/Lotus Notes Formula Language!"

```

Computed field formula that takes it's input from an editable field `i`. It would fail for "I'm an I'm" but since that wouldn't make any sense at all I'm assuming that it won't happen.

Shame that at 32 bytes, the name of the language is more than half the total length of the formula!

Screenshot below showing an example input and output:
> 6 votes

# Answer
# sed (`-r`), ~~31~~ ~~28~~ 25 bytes

-3 bytes thanks to Shaggy -3 bytes because `-r` not needed in output

```
s/I'm(.*)/Hi\1, I'm sed!/

```

TIO
> 6 votes

# Answer
### TeX, ~~48~~ ~~43~~ 30 bytes

Yes I *could* save a byte by writing `TeX` instead of `\TeX`, but it seems a shame.

```
\def\s[#1]#2#3#4{}\def~[#1]{Hi\s[]#1, I'm \TeX!}

```

**Update:** saved ~~3~~ 5 bytes thanks to fixed pattern matching.

```
\def\s[]I'm{}\def~[#1]{Hi\s[]#1, I'm \TeX!}

```

**Update:** -13 bytes (thanks, Jairo A. del Rio).

```
\def~I'm #1~{Hi #1, I'm \TeX!}

```

Test file

```
\def~I'm #1~{Hi #1, I'm \TeX!}
~I'm amazing~
~I'm hungry~
~I'm tired~
~I'm fat~
~I'm a programmer~
~I'm a question-writer~
~I'm a Stack-Overflow-er~
\bye

```

Output:

Try it online!
> 6 votes

# Answer
# Japt, 18 bytes

```
`Hi{s3}, I'm Japt!

```

When Japt's string compression library achieves a 0% compress rate...

Try it

Another 18-byte alternative:

```
`Hi{Å¤}, {¯4}Japt!

```
> 5 votes

# Answer
# Octave, 35 bytes

```
@(s)["Hi" s(4:end) ", I'm Octave!"]

```

Try it online!

```
@(s)                                 % Anonymous function taking a string input
    [                             ]  % Concatenate everything inside the brackets
     "Hi"          ", I'm Octave!"]  % The fixed parts of the output string
          s(4:end)                   % The input, except "I'm"

                                     % Returns the concatenated string

```

### 42 bytes:

I tried retrieving "Octave" somehow, without writing it out, since 6 chars is quite a lot compared to some of the other language names here. Unfortunately, I could only find `ver`, which outputs a struct with comma separated fields. Takes way more than 6 bytes. :(

```
@(s)["Hi" s(4:end) ", I'm " {ver.Name}{1}]

```

Try it online!
> 5 votes

# Answer
# Malbolge, 24477 bytes

Mors sum, Dominus Pestifer Mundi

*Hi, Dominus Pestifer Mundi, I'm dad!*

```
bP&A@?>=<;:9876543210/.-,+*)('&%$T"!~}|;]yxwvutslUSRQ.yx+i)J9edFb4`_^]\yxwRQ)(TSRQ]m!G0KJIyxFvDa%_@?"=<5:98765.-2+*/.-,+*)('&%$#"!~}|utyrqvutsrqjonmPkjihgfedc\DDYAA\>>Y;;V886L5322G//D,,G))>&&A##!7~5:{y7xvuu,10/.-,+*)('&%$#"yb}|{zyxwvutmVqSohmOOjihafeHcEa`YAA\[ZYRW:U7SLKP3NMLK-I,GFED&%%@?>=6;|9y70/4u210/o-n+k)"!gg$#"!x}`{zyxZvYtsrqSoRmlkjLhKfedcEaD_^]\>Z=XWVU7S6QPON0LKDI,GFEDCBA#?"=};438y6543s1r/o-&%*k('&%e#d!~}|^z]xwvuWsVqponPlOjihgIeHcba`B^A\[ZY;W:UTSR4PI2MLKJ,,AFE(&B;:?"~<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\xwvoXsrqpRnmfkjMKg`_GG\aDB^A?[><X;9U86R53ONM0KJC,+FEDC&A@?!!6||3876w4-tr*/.-&+*)('&%$e"!~}|utyxwvutWlkponmlOjchg`edGba`_XW\?ZYRQVOT7RQPINML/JIHAFEDC&A@?>!<;{98yw5.-ss*/pn,+lj(!~ff{"ca}`^z][wZXtWUqTRnQOkNLhgfIdcFaZ_^A\[Z<XW:U8SRQPOHML/JIHG*ED=%%:?>=~;:{876w43210/(-,+*)('h%$d"ca}|_z\rqYYnsVTpoRPledLLafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(DCB%@?"=<;|98765.3210p.-n+$)i'h%${"!~}|{zyxwvuXVlkpSQmlOjLbafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(D'%A@?"=<}:98y6543,1r/.o,+*)j'&%eez!~a|^tsx[YutWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U86R53O20LKJ-HG*ED'BA@?>7~;:{y7x5.3210q.-n+*)jh&%$#"c~}`{z]rwvutWrkpohmPkjihafI^cba`_^A\[>YXW:UTS5QP3NM0KJ-HGF?D'BA:?>=~;:z8765v32s0/.-nl$#(ig%fd"ca}|_]yrqvYWsVTpSQmPNjMKgJHdGEa`_B]\?ZY<WVUTMR5PO20LK.IHA))>CB%#?87}}49zx6wu3tr0qo-nl*ki'hf$ec!~}`{^yxwvotsrUponQlkMihKIe^]EEZ_B@\?=Y<:V97S64P31M0.J-+GFE(C&A@?8=<;:{876w43s10qo-&%kk"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNiLgf_dcba`C^]\?ZY;WV97SLK33HM0.J-+G*(D'%A$">!};|z8yw543t1r/(-,+*)(i&%fd"!~}|_t]xwvutslqTonmPNdchKIeHFbaD_AWV[><X;9U86R53ON1L.DCH+)EDC&;@#>=<;|98x6wu32s0p(',mk)(i&f|{"ca}`^z][wZXtWUqTRnmPNjcbJJ_dcbEDYB@@?ZSX;VUTS6QPO11F..CHGF)(C<A$?>=<}:98xx/uu,10/po,+$kiih%$#z!b}|{z]xwvXXmUUjonmPOjihafIdcbaD_^]??T<<QVUT76QPONG0..-HGFED=B%@?>=~|438yw5vt21r/o'&+lj(ig%fd"ca}`^z][wZXtWUqpoRQlkjihafIdcbaD_^]??T<<QVUT76QPONMLE.,,+FEDCBA@9>!<;:9zx0/uu,10/po,+*)('&}$e"!~}`{zy[[pXXmrqpSRmlkjihgf_Hcba`_AW\[ZY;Q:OTSRKPIN1//.CH+FEDC&A@?>=~|:327xv43tr0)(-nl*ki'hf$ec!b`|_]y\ZvYWsVTponQPejMhgfeHcbaCCX@@UZYX;:UN7554ONGL/JIHG*ED&BA$?!76;|zyy054us1*).om+lj(ig%fd"ca}`^z][wZXWWlqpoRQlkdiLgfedGba`BBW??TYXW:9TSRK4221LKJIBG*EDCB%@?>~~5{{2765vu210/(-n+*)(i&%$ddyaav{zy\[vutsrkTRRQlkjihg`eHcba`C^]\>>S;;PUTS65PONMLKDI,GFED'%;:?"~<}{9zx6wu3tr0qo-nl*ki'hfeez!~}`_zyxwvutmVTTSnmlkjihg`eHcba`C^]?>>SXW:8TMLQPO21LKJIHGFE>C&A@?>=}5:987w/v-210).',m*)('h%$#ccx``uzyx[ZoXVVUpinQlkjiLgfeGG\DDY^]\?>YRW:UTSR5PON00E--BGFE('BA:#!!~;:927x5432s0/.nn%kk"'&%fe"!~w|_zyxwZutsUUjRRglkjMLgfed]FDDC^]\[ZSX;VUTS6QPO11FKJ-H*@?D'%A$">!}||387xv4-,1rp.om+lj(ig%fd"ca}`^zyx[ZutsrqjoRmlkjMhgfHH]EEZ_^]@?ZYXWVUN7554ONMLKJIBG*EDCB%@?>~~5{{2765vu210/.-,%*k('&%f#"b~a_{^\x[YutWUqjinQOkNLhKIeHFbEC_B@\?=<<QVUT76QPONMLKJC,GFEDC%;@?>=}5|381654-2sqqp',m*)('h%$#ccx``uzyx[ZotWrqpoRmlkMMbJJ_dcbED_XA??>YXQV9TSRQ4ON0L/-IH+F(>=B%#?>!<|438yw5vt2sq/pn,mk)jh&%fd"yx``uzyx[ZutmrUponmPkjiKK`HH]ba`CB]\[T=;;:UTSRKP3NMLK.IHG))>&&;@?>!~;:9816w4321r/.-mm$jj!&%$ed!~}|{t][[ZutsrqpinQlkjiLgfeGG\DDY^]\?>YXWVUTMR5PONM0KJI++@((=BA@#"=<;:9870wuut10/.-,+*#(i&%$#d!~}__t\\qvutWVqponmlkjchKfedcbDZ_^]\>T=RWVUNSLQ4ONML/-CBG*(D'%A$">=~|:327xv43tr0)(-nl*ki'hf$ec!b`|_]\\qvutWVkTRRQlejMhgfeHcbD`_B]?UTY<:99NSR5P2HGL/-IH+F(>=B%#""7<;|9y105vt2sq/pn,mk)jh&%$ed!x}`{z]xwYuXVrUSoRPlkNLha`eHFbEC_B@??TYX;V8NMR53ON1L.DCH+)ED'B$:9>!};|z876wv32+r/.-n+*j(ig%$ec!xw|_]yx[YunmrUSonQOkdchKIeHFbEC_B@\?=Y<:99NSRQ43NMLKD-++*EDCBA:?"=<;|z21ww.321rq.-,+*#(i&%$e"!~``uzy\ZvonsrqTSnmlkjibKIIHcba`_^]V[>YXW:UTS55JON1L.DCH+)E(&BA$?!76;|z8ywvv-21r/o'&+lj(ig%fd"ca}`^z][ZZotsrUTonmlkjibgJedcFa`_^]@>ZSRW:877LQP31MFEJ-+GF)'C<;@#!=~|:{y76wu3,+0qo-nl*ki'hf$ecbbw|{z]\wvutsrqpiRmlkjiKafedcE[DY^]\UZSX;998MR5PON1LK-,,AFE(C%;:?"~<;|9y105vt2sq/pn,+l)i!~%fd"ca}`^z][wZXtsrUTinQlkNihgII^FF[`_^A@[T=XWV9TSR44INM0K-CBG*(D'%$$9>=~|:327xv4usrr).-nl*#"'hf$ec!b`|_]y\ZvYWsrqTSnmleNLLKfedc\aD_^]@[ZYXW:8TMLQ42NM0K-CBG*(DC&A#98=~|:9z7w/.3tr0/p-m%$)jh&ge#db~a_{^\x[YXXmrqpSRmlkjchKfedGbaC_^A\>TSX;9UT75QJIN1/KJ-+G@?D'%A@#!=65:{y7xv4us1rp.om+lj('&gf#"!~}v_]]\wvutsrkpSnmlOjihJJ_dcFaCYX]@>Z=;WV9T6LKP31M0.--BGF)D&<;@#!=~|:{y7xv4us1rpoo&+*)ji&%$#"!x}`{zy\ZpotWUTTinmPNjcbgJHdGEaDB^A?>>SXW:8TMLQ42N1/K.,H+)E(&%%:?>=~}:987654-trrq.-,+*)('~%f#"!b}|{]]rwvYWslkpSQPPejiLgI_^cFD`CA]@>Z=;::OTS6Q3IHM0.J-+G*(D'%A$">=<}|98765432+0q.-,+*j"'&%$dzcx}|uzyrwZutsrUponPPeMMbgfeHGbaZCAA@[ZYRW:UTSR5PONML/-IBAF)'C&$##8=<}{9216wu3tr0qo-nl*ki'hf$ec!b`__tyxwZYtsrkpSnmlkNihgII^cbE`BXW\?=Y<:VU8S5KJO20L/-I,*F)'C&$@#!=~|:9z7w/.321rq.-,+$kiih%$#"!x}`{zyx[vuWsVTSShmlOMibafIGFF[`_B@\UTY<:VU8S5KJO20L/-I,*F)'C&$@#!~~5:98yx54321*/p-,+*k('&ff{ccx}|{^]xwvutsrqjSnmlkjLbgfedF\EZ_^]V[TY<::9NS6QPON1LK-I,*FE(C%;:?"~}}498y6v.-2sq/pn,mk)jh&ge#db~a_^^sxwvYXmrUponmPkjLhKIHH]baDB^WV[><X;9U86R53O20L/-I,*FED'&A:#!!~;:38y65vt,+qq(-,+lk('~%f#"cawv{^\x[YuXVrUSoRPOOdihKfH^]bEC_B@\?=<<QVU86RKJO20LKJ-,GFE>'%%$?>=<5:{87x54t21r/o'&+lj('h%e{z!b`|{^\xqpuXVrUSoRPlOMiLJfIGcFDCCX]\[>=XWVUNS6443NMLKJC,GFE(CB$@#!=~|{{276w4t,+0qo-nl*)j'g}|#db~a_{^\xwZuWmlqpoRQlkjihaJHHGba`_^]V[>YXW:UTSRQ42NGFK.,HG*E'=<A$">!};:{y70/4us10qo-&%*ki'hf$ec!b`|_]y\ZvutWVqponmlejMhgJedcEEZ_^A\>TSX;9UT7R4JIN1/KJ-H*@?D'%$$9>=~;{327xv4us1rp.om+lj(ig%fd"!~a`{zyxwvunWUUTonmlkjihafIdcbE`_A]\?=YRQV9766KPO2M/EDI,*F)'C&$@#!=~|:{y7xv4usrr).-,ml)('&%$#"y~a|{zyxZputsrTjShmlkdibgJedcbE`_^@@U==RWVU87L5332MFK.IHGF)DC%A$">=~;{327xv4us10q.n&%*ki'hf$ec!b`|_]y\ZvutWVqjoRmlkjMhgIHH]baDB^WV[><;;PUT75QJIN1/K.,H+)E(&B%#?"~<}{987xw43,sqqp-,+$)j'&%f#"!aav{z]xZpotWUqTRnmPkMcbgJHdGEaDB^A?[><X;9U86R5322GLKJ-,GFE>C&A@#>=<;:{y70/4us10qo-&%*ki'hf$ec!~a|^tsx[YuXVUUjonQOkdchgfIHcba`YB]\[>YX:99NSR5P2HGL/-IH+)E>=B%#?"~<}{9zx6wu3tr0qo-nlkk"'&%fe"!~}|{t][[ZutsrqpohmPkjiLgfHdGEa`C^@VUZ=;WV9T6LKP31ML/J,BAF)'C&$@#!=~|:{y7xvuu,10/po,+*)('&}$e"!~a|{zyx[YunmrUSoRPlkNLha`eHFbaDB^WV[><XW:8TMLQ42N1/K.,H+)E(&B%#?>=~}:9876543,s0/.-,l$)('&f|ez!~w|{ty\ZZYnsVqpoRmlkMMbgfIdF\[`CA]@>ZY<W9ONS64P3100EJI,G)?>C&$@#!=~|:{y7xv4usrr).-,ml#(i&%$e"!a}`^z][wZXtWUqpSQmfejMKgJHdGEaDB^A?>>SXWV98SL5332MLEJ-HGF)DCBA@#!=65:{y7xv4us1rp.om+*k(h~}$ec!b`|_]y\ZvYWsrqTSnmfkNLLKfed]Fa`_B]\>ZY<:VONS64P31M0.J-+G*(D'%A$">!};|zyy0543ts0/.'nllk('&%|#d!~}`{zy[[putWrTjinQONNchgJeG]\aDBAAV[Z=;WPOT75Q42N1/KJ-H*@?D'%A$">!};:{8x0/432sr/.-,%*kiih%$#"!xa|{z]xwvutWUqjinQOkNLKK`edGEaZY^A?[Z=X:POT7544INM0K-CBG*(DC&A#98=~|:{y7xv4usrr).-,ml)('&%|eccb}|{zyxqvYtsrUpoQmPNMMbgfIGc\[`CA@@UZY<W9ONS64P31M0.--BGF)'C<;@#!=~|:{y7xv4us10/po,+*)('~%fddc~}|{zyxqZutsVqpRnmPkMcbgJHdGEa`C^@VUZ=;WV9T6LKP31M0.J-+G*(D'%A$"!!6;:9zy6543210)pnnm*)('&%$#z!b}|{^yxZvuXsUkjoRPlkNiKa`eHFbECBBW\[><XQPU86RQ4O1GFK.,H+)E(&B%#""7<;:{z76543210).o,+*)(h~%$#"bxav{zyrwpuXsrqTonPlkNiKa`eHFbEC_B@\?=Y<:V97S64P31M0.--BGFE('<%##"=6;|987x54t2sq/pn,mk)(ig%|{"ca}|_z\rqvYWsVTSShmlOMibafIGcFD`CA]@>Z=;WVU87RKP3NML/JI+GF)D&<;@#!=~|:9z7w/.3tr0qo-nl*ki'hf$ec!b`|{z]\wvoXVVUponglOjiLgfHdcFaCYX]@>Z=;WV9T6LKP31M0.J-+G*(D'%A$">!};:9zy654-2s0/p-,+kk"'&g$dzy~}|_^yxwvoXVVUponmlejMhgfIG]\aDB^A?[><XW:U7MLQ42N1/..CHG*E'=<A$">!};|z8yw5vt210qp-,+*)"'h%$#d!~`|{^\xqpuXVrUSoRPlkNLha`eHFbaDB^WV[><XW:U7MLQ42N1/K.,H+)E(&BA@#"=<;:981xvvu210/.-,%*k('h%$d"!b}_uty\ZvYWsrUpRhglOMLLafeHcE[Z_B@??TYX;V8NMR53O20LK.I+A@E(&B%#?>!<|43876wv3210/.-&+l)('hf|{ccx}|{^]xwvutsrqjSnmlkjLbgfedF\EZ_^]V[TY<::9NS6QP3NMLKJ-+G@?D'%A$">=~;{327xvuu,10qo-&%*ki'hf$ec!~a|^tsx[YXXmrqTRngfkNLKK`edGEaZY^]\?>SX;998SRKP3NM0.DC++@EDC&%@?8=~;:9z765uu,10qo-&%*)(ih%$#zcaa`{zyxqvYtsVTjinQOkjMhJ`_dGEa`C^@VUZ=;W:8T75Q42N1/KJ-H*@?D'%A$"!!6;:{8x0/4us10/po,+*)"'h%$#dbxw__tyxwZYtsrqpiRPPOjihgfe^cFa`C^]\[Z=;WPOT75QP3N0FEJ-+**?DC&$@98=~|:{y7xv4us1rp.-n+k#"'hf$ecbbw|{^\xqpuXVUUjonmPOjihgfe^cFDDC^]\[ZYXWPU8SR53IH00EJIH+*EDCBA@?>7<}:9876v.3210p(o&+$)('~%f#"c~}|^^sxwZXtmlqTRnQONNchgJeG]\aDB^]@[=SRW:877LQP31MFEJ-+G*(D'%A$">!};|zyy0543ts*q.-nl$#ii~%$#dc~}v_]]\wvunsVqpSnmlNNchgJHd]\a`_BA\[ZSX;998SRQPOHM0KJ-+A@((=BA@#"=<;:927x54u210pp',+lj(!~%$#dc~}|{zyr[vuXVlkSShmlkNMhgfedcbaZC^]\[Z<RWVUT6L5JONMFKDI,**)>C&A@#!76;|z8yw54u2r*).om+lj(ig%fd"ca}`^z][wZXtsrUTinQOONibKfedGE[Z_B@\?=Y<:99NSR5P2HGL/-IH+F(>=B%#?>!<|438yw5vt2sq/pnmm$)('hg${dbba|{ty\wvYtsrqpSQmfeMMbgfeHGbaZ_B]\[>YX:VU86RKJO20L/-I,*FE(&B;:?"~<;|z8105vt21r/o'&+lj(ig%fd"ca}`^zyx[ZutslUSSRmlkjchKfedGE[ZBBW\[Z=<WVUTSL5332MLKJIHAF)DCB%@?!=~|:{y7xv4us10qo-&%*ki'&g$dzy~a_{^\x[YuXVrUSonmPOjihgfe^cFa`C^]\>>SXW:U7MLQPO21LKJIHGF?(&&%@?>=<;:927x543tr*).om+lj(ig%$e"bxw|_]y\ZvYWsVTpSQmPNjMKgfeHGba`_^]\[TY<WVUTS5KPONM/E.CHGF?D=B%@?"=<;:9zx6/.3tr0/pn,%$)jh&ge#db~}`{]srwZXtWUqpoRQfOMMLg`eHcbECYX]@>Z=;W:8T75Q4211FKJ-H*@?D'%A$">!}||387xv4-,1rp.-,ml)"'h%$e"!a}|_z\rqvYWsrUpRhglOMihKIe^]bEC_B@\?=Y<:V97S64P3100EJIH+*ED=&$$#>=<5:{876wu-,1rp.-n+k#"'hf$ec!~a_{tsx[YuXVrUSoRPlOMiLJfIGFF[`_^A@[ZYRW:UTS6QPONM0.JCBG*(DC&A#98=~|:{y7xv4us1rp.om+lj(ig%fd"!~a`{zyxqZXXWrqponglOjiLgfeGG\a`C^@VUZ=;WV9T6LKP31ML/J,BAF)'&&;@?"=}549zx6wu3tr0qo-nl*ki'hf$#"cb}|{zyrwZutsVqpRnQOkjMhJ`_dGEa`C^@VUZ=;W:8T75Q42N1/K.,H+)EDC&%@?>=<;4{yyx543210/(-n+*k('&%$ec!xw|_]yx[YunmrUSoRPlOMihKfH^]bEC_B@\[Z=<WVUTSRQJO2ML/-CBG*(D'%A$">!};|zyy054u2r*).om+lj(igff{"!b`|uty\ZvutWVqponmlkjcLgfedcE[`_^]?U>SXWPUTMR5332GL/JI,GF(DC&A#98=~|:9z7w/.3tr0/pn,%$)jh&ge#db~a_{^\x[YuXVUUjonmPOdiLJJId]Fa`_B]\>ZY<:VONS64P31M0.--BGF)D&<;@#!=~|:{y7xv4us1rpoo&+*)ji&}fddc~}v{^yxwZutVUUjonQlNdchKIHH]baDB^WV[><XW:8TMLQ42NM0.JCBG*(D'%A$">!};|z8yw543ts0/(-n+*k('&ff{"!b}_uty\ZvuXsUkjoRPlkNiKa`eHFEEZ_^A\>TSX;9U86R53O20L/-I,*F)'CBA$#>=<5|zzy6543,1r/.-n+*)ii~%$e"bxw|_]yx[vXnmrUSRRglkNiKa`eHFbECBBW\[>Y;QPU86R53O20L/-I,*F)'&&;@?>!~;:9816w43t10/.-nl*#"'hf$#db~wv{^\x[YuXVrqToQgfkNLhKIedcFE`_^]\U><<;VUTSRQJO2ML/-CBG*(D'%A$">!};|zyy054u2r*).om+lj(igff{"!b`|uty\ZvutWVqponmlejMhgJedFbaD_AWV[><XW:U7MLQ42NM0.JCBG*(D'%A$">!};|z8yw5vtss*/.-nm*)('&%${dbba|{zyxwvunsVqpoRPfejMKgfIdF\[`CA]\?Z<RQV97S64P31M0.J-+G*(D'%A$"!!6;:9zy6543210/(-n+*)('g}$#"!aw`uzyxqvotWrqTonPlkNiKa`eHFbEC_^A\>TSX;9U86R53O20L/-I,*F)'CBA$#8!<;|z21ww.321rq.-&mkkj'&%|#d!~}`{zy[[putWUqjinQOkNLhgJeG]\aDB^A?[><X;9U86R53O20L/-,,AFED'&A@?8=~;:{y105vt2sq/.o,l$#(ig%fd"ca}`^z][wZXtWUqTRnmlONihgf_HFFE`_^]\UZ=XWV97MLQ42N1/KJ-+G@?D'%$$9>=~;{327xvuu,10qo-&%*ki'hf$ec!b`|_]y\ZvutWVqponmfkNihgfIdcbDDYAAV[ZY<;VUTSRQPOH1LKJIH*@EDCB$:#8=<;4927xvvu,1r/.-,m*)i'hf$ec!~a|^tsx[YuXVrqToQgfkNLhKIeHFbEC_B@\?=Y<:VUT76KP3NMLK.IH*FE(C%;:?"~<}{98yw5.-2sq/pn,mk)jh&ge#db~a_{zy\[voXsrqpSnmlNNcKK`edcFE`_^W@>>=XWVUNS6QPON1/EDI,*F)'&&;@?"=}549zxww.32s0p(',mk)jh&ge#db~a_{^\x[YXXmrqpSRmlkjchKfedcFa`B^A?>>SXW:8TMLQ42N1/K.,H+)E(&B%#?"~<;:{z76543,sqqp-,+*)(!&g$#d!~}|{^\xqpuXVrqTRngfkNLhKIeHFbaD_AWV[><X;988MRQ42NGFKJI,+FEDCBA:?"~~}:9876543,1r/.-n+*j(igff{"!b}_uty\ZvYWsrUpRhglOMiLJfeHcE[Z_B@\?=Y<:V97S64PON10KJIHGFED=B%@?>=<|49876v.u,10).-&+l)('h%$d"ca}|_]yrqvYWsrUpRhglOMihKIe^]bEC_B@\?=Y<:V97S6433HMLK.-B+))(C<A$?>=~;:987xv4-,1rp.omll#('h%e{z!b`|_]yx[vXnmrUSonQlNdchKIeHFbEC_B@??TYXW:9TMR5PO2ML.JI,*F?>C&$@#!=~|:{y7xv4us1rp.om+ljii~%$#dc~}v_]]\wvunsVqponQlkMiLJfeHcE[Z_B@\?=YX;9UNMR53O20L/-I,*F)'C&$@?>!~;:927xvvu210/.',m*)('h%$d"ca``uzy\ZvonsVTSShmlOjLbafIGcFD`CA]@>Z=;W:8T75QPO21LKJIHAF)''&A@?>=<;49z76w432rr).-n+k#"'hf$#d!awv{^\x[YutWrTjinQONNchgJeG]\aDBAAV[Z=X:POT75Q42NM0K-CBG*(''<A@?"!<;:9876/4u210/.n&+*)(h~g|#"!x}v{^yxwvYtsUqTRnQOkjMKg`_dGEaDB^A?[><X;9U86R5322GLKJ-,AF)DC&A@">!};|z8ywvv-21rp.'&+lj('hf${z!b`|_]y\ZvYWsVTSShmlkNMhg`eHFFE`_^]V[>YXWV9TS5Q42N1/..CHG*E'=<A$">!};|z8yw5vt2sq/pn,+*kj'&%${"caa`{zyxwvotWrqTonPlOMiLJfIGcFD`_B]?UTY<:VU8S5KJO20L/-I,*F)'C&$##8=<}:z216wu321rq.-,+*)"'hffe"!~}|{zyrwZutWrqponQOkdchKIeHFbEC_^A\>TSX;988MRQ42NGFK.,H+)E(&B%#?"~<;:{z76543210).o,+*)(h~%$#"bxav{zyrwpuXsrUponmlOMibafIGcFD`CA]\?Z<RQV97S6433HML/J,BAF)'CBA$#>7<}{{z765.3t10q.-m+lj('h%e{z!b`|{^y[qpuXVrUSRRglkNiKa`eHFEEZ_^A?[TSX;9U86R53O20L/-IHG*)DCB;@#>=~;:z8yw5vt2sq/pn,mk)(ig%|{"ca}`^z][wZXtWUTTinmlONihgfe^cFa`C^]?[><;;PUT7R4JIN1/K.,H+)E(&B%#?"~<}{9zx654ut10/.-,+$)j'&%$#cy~}|{]s\qputsrkpSQQPejMhgJedcEEZ_^A?[TSX;988MRQ42NGFK.,HG*E'=<A$">!};|z87x5u-,1rp.om+lj(ig%$#dcx}`^^]xwpuXsrUpoQmlOjLbafIGcbE`BXW\?=Y<:V97S64P31M0.J-+G*(DCB%$?>7<}{{z7654-2s0/.-n+*j('h%e{z!b`__tyx[vXnmrUSoRPlOMiLJfIGcFD`CA]@>==RWVU87RQPOHM0KJIH+FE'C&$##8=<}{9216wu3tr0qo-nl*ki'hf$ec!b`|_]yxwZYtsrqpohmPkjMKa`eHFbaDB^WV[><XW:8TMLQ42N1/K.,++@ED'B$:9>!}||387xv4-,1rpoo&+*ki'~}$#"cb}|{zyxwpYWWVqponmlkjchKfeHcbaCCX]\?Z<RQVUT76QPONMLKJCH+FEDCB$:?>=<|4{2765.3,1rppo&m*)(ig}|#db~a_{^\xwZuWmlqTRnQOkNLKK`edcFEZCAA@[TY<WVU8SR4P31ML/-IBAF)'&&;@?"~<549zx65vt2+*/pnmm$)(i&f|{"ca}`^z][wZXtWUqpoRQlejMKKJed]Fa`_B]\[ZY<:VONS64P31M0.--BGF)D&<;@#!=<}:z216wu32s0p(',mk)jh&ge#dbaav{zy\[vunWUUTonmfkNihgJedFbEC_B@\?=<<QVU86RKJO20LK.,HA@E(&BA$?!76;|z8yw5vt2sq/pn,+*kj'&%|#dbba|{zyr[vutWrqpRRglkNiKa`eHFbEC_^A\>TSX;9U8655JON1L.DCH+)E(&B%#?"~<}{9zxww.321rq.-,+$kiih%$#"!x}`{zy\wvXtsVTpihmPNjiLgI_^cFD`CA]@>Z=;::OTS64PIHM0.J-+G*(D'%A@#>~65:{yxx/432sr/.-,+$)jhhg$#"!~}v_zyx[vutVVkpoRmOediLJfeHcE[Z_B@\?=Y<:V9766KPO2M/EDI,*F)'C&$@#!=<}{921654ut10/.-,%ljji&%$#"!~w|_zyx[vuWsrUSohglOMiLJfIGcFD`CA]@>Z=;W:8T7544INML/.IHGFEDC<A$?>=~|438yw54u2r*).om+lj('h%e{z!b`|_]\\qvuXVrkjoRPlOMiLJfIGcFDCCX]\[>=XWVUTSRQJ3NMLKJ,BGFED&<%:?>=6;49zxxw.3t10/p-,l*)jh&}|#db~a_{z][wpotWUqTRQQfkjMhJ`_dGEaDB^A?[><X;9UTS65JO2MLK.IH*F)'&&;@?"~<549zxww.32s0p(',mk)jh&geddy~}`^zsrwZXtWUqTRnQOkNLhgfIHc\ECCB]\UZ=XWV9TS5Q42N1/KJ-H*@?D'%A$">=~;{327xvuu,10qo-&%kk"'&%fe"!x}`{zy\wvXtWUqpSnPfejMKgJHdGEDDY^]@[=SRW:8T75Q42N1/..CHGF)(CBA:#!!~;:9816w432s0/o-,m*j"!&ge#db~a_{^\x[YuXVrUSoRPlOMLLafedGFa`_^W\?ZYX;VU7S64P3100EJI,*F?>C&$@#!=~|{{276wu3,+0qo-nl*ki'hf$ec!~}`_zyxwvoXVVUponmlkdiLgfeHF\[`CA]@>Z=;WV9T6LKP3100EJI,G)?>C&$@#!=~|:{y7xv4us10/po,+*)('~%f#"!b`vuz][wvYtVlkpSQmPNjMKgfIGc\[`CA]@>Z=;W:8T75Q4211FKJI,+FEDCBA@9"~~}:9876543,1r/.-n+*)ii~%$ec!xw|_]yx[vXnmrUSRRglkNiKa`eHFbaD_AWV[><X;9U86R53O20L/-I,*FED'&A@?>=<;:38y65432r*/.-,l$k"'&}$#z!b}|{^yxwYYnsrUpRhglOMiLJfIGcbE`BXW\?=Y<:V97S64P31M0.J-+**?DCB%$9"~~}:38y654u21q/.om+$#(ig%fd"ca}`^z][wZXtWUqTRnQONNchgfIHc\aD_^]@[Z<X;988MRQ42NGFK.,++@ED'%A:9>!};|z87x5u-,1rp.om+lj(igff{"!~a`{zs\ZZYtsrkpSnmlOjihJJ_dcFD`YX]@>ZY<:VONS6433HML/J,BAF)'&&;@?"=}549zx6wu3tr0qo-nl*ki'hfeez!~}`_zyxqvYtsrUpoQPPejiLgI_^cFD`_B]?UTY<:V9766KPO2M/EDI,*))>CB%@"87<}{9zx6wu3tr0/p-m%$)('hg$#"!xa__^yxwvunsVqpoRmlNjiLgI_^cFDCCX]\?=YRQV9766KPO20LEDI,*FE(&B;:?"~<}{9zx6wu3trqq(-,mk)"!&%$ed!~}|{ty\wvuXsrTpSQmlOjLbafIGcbE`BXW\?=YX;V8NMR5322GLK.I+A@E(&B%#?"~<}{98yw5.-210qp-,+*)(!hffe"!~}|{zsx[vutWrqSonQlNdchKIeHFbEC_B@\?=Y<:V97S64P3100EJIH+*EDCBA@?8=~;:9z76v4us1rp.-nl*#"'hf$ec!b`|{^\xqpuXVUUjonQOkdchKIeHFbEC_^A\>TSX;9U8655JONM0/JIHGFEDC<%@?>=<|49876v.u,10/(-&+ljji~%f#"!b}|^]]rwvYtVlkpSQmPNjMKgfIdF\[`CA@@UZY<W9ONS64P31M0.--BGFE('<A$?>=~;:9yy054us1*).om+lj('hf${z!b`|_]\\qvuXVrkjoRPlOMiLJfIGcFD`CA@@UZYX;:UN7554ONGL/JIH+FE'C&$@?"=}549zxww.32sq/(',mk)jh&ge#db~a_{^\[[putsVUpohmPkjiLgfHdcFaCYX]@>Z=;WV97SLKP3100EJI,G)?>C&$@#!=~|:{y7xv4us1rp.-,ml)('~geed!~}|uz]xwZutsrqTRngfkNLhgJHd]\aDB^A?[><XW:U7MLQ42N1/KJI,+FEDC<A$?>!}549zx6wu3tr0qo-nlkk"'&g$dzy~a_{^\x[YXXmrqTRngfkNLhgfIHcba`_XA??>YXWVUTMR5PON1LK-I,*F)'C&$@?"=}549zx65vt2+*/pn,mk)(i&f|{"ca}`^z][wZXtWUTTinmlONihgfed]bE`_B]\[==RWV9T6LKPON10KJIHGFE>'%%$?>=<;:9816w432s0/o-,mk)"!&ge#db~a_{z][wpotWUqTRnQOkNLhKIeHFba`CB]\[ZYXWVOT7RQPON0FKJIH*@)>CBA:?8=~;:{87654us1*).om+*ki'~}$ec!b`|_]yx[vXnmrUSoRPlkjMLaJHHGb[`C^]@>TSX;9U86R53O20L/-,,AFE(C%;:?"~<}{9zxww.32sq/(',mk)('hg${"caa`{zs\wvuXsrTSShmlOjLbafIGcFD`CA]\?Z<RQV97S64P31M0.J-+G*(''<A@?"!<;4{yyx543,1r/.o,+*jj!&%f#cyx}|{^]xwvotWrqpSnmOkNLhKIHH]baD_AWV[><;;PUT75QJIN1/K.,H+)E(&B%#?"~<;:{z7654-trrq.-,+*#(i&%f#"!~}`^zsrwZXtsVTpihmPNjMKgJHdcFaCYX]@>Z=;WVU87RQPONGL/JI,*@?D'%A$">!};|z8ywvv-21r/o'&+lj(ig%fdccx}|_]yrqvYWsrqTSnmlkjibKIIHcba`_^]V[>YXW:UT6R53O20LK.,HA@E(&%%:?>!<|438yw5vt2sq/pn,mk)jhgg|#"!ba|{zyxwvotWrqTonmOOdihKfH^]ba`CB]\[ZYXWVO8SRQPO1GLKJI+A*?DC<A@9>!}}|38y654u210pp',+l)i!~%fd"!b}_uty\ZvYWsVTpSQmPNjMKgJHdGEaDBAAV[ZY<;PU8SRQP3NM/KJ-H*@?D'%A$">!};|z8yw5vt2sq/pnmm$)('hg$#"yb``_zyxwpuXsrqpSnmOkjMKg`_dGEaDBAAV[Z=;WPOT7544INM0K-CBG*(D'%A$">!};|z8yw5vtss*/.-nm*)('~%f#"!~a|{]yx[vXnmrUSoRPlkNLha`eHFbEC_B@\?=Y<:V97S64PON10KJIHG@)DCBA$?>=}}4zz1654ut10/.-,+$kiih%$#"!~}|uz]xwvuXVlkpSQmPNMMbgfIdF\[`CA@@UZY<W9ONS64P31M0.J-+G*(D'%A$"!!6;:9zy6543210/(-n+*)('g}$#"!aw`uzyxqvotWrqpoRmlNjMKJJ_dcFD`YX]@>Z=;W:8T75Q42N1/K.,HGF)(=&$$#>7<}:9z76543tr0)(-nl*)jh&}|#db~a_{^\xwZuWmlqTRnQOkjiLKf_dGbaDBXW\?=Y<:V97S64P3100EJI,G)?>C&$@#!=~|{{276wu3,+0qo-,+lk('~geed!~}v{^yx[vutVVkSShmlkNMhgf_dGbaD_^]??T<<QVUT76QPONG0..-HGFED=B%@?>!<;:98yw5.-2sq/.om+$#(ig%$e"bxw|_]y\ZvuXVrkjoRPlOMiLJfIGcFD`CA]\[>=XWVUTMR5332MLKJIHA*(('BA@?>=<5:{876wu-,rr).-,ml)('&%$#z!b``_zyxwvutslUponQlkMiLJfeHcE[Z_B@\?=<<QVU8S5KJO20L/-I,*F)'C&$@#!~~5:98yx543210/.'n+*)('g}$#"!aw`uzyxqvotWUUTinQlkNihgII^cbE`BXW\[Z=<QV9776QJ3NML/-CBG*(''<A@#>~65:{y7xv4us1rp.om+lj(ig%fd"ca``uzyx[ZunWUUTonglOjiLgfedcFD`YX]@>ZY<:VONS64P31M0.JI,G)?>C&$@#!=<;|{8705v32sq)(-nl*ki'hf$ec!b`__tyx[vXnmrUSoRPlOMLLafeHFb[Z_B@\[Z=<WVUN7554ONMLEJ-HGF)DCBA@#!=65:{y76wu3,+0qo-,m*j"!&ge#db~}`^zsrwZXtWUqTRnQOkNLhKIedcFE`_^]V[><<;VUTSRK4ON1LKJ,HG*)DCBA@9"~~}:98765.3t10/pn&%kk"'&%fe"!~}|{ty\wvuXsrTpSQmPNjiLgI_^cFD`_B]?UTY<:VU86RKJO20L/-I,*F)'C&$##8=<;|{8765432+rppo,+*)('&%|#d!~a|{z\\qvuXsUkjonmPOjihgfedc\aD_^]\[=SXWVU7M6KPINMLEJ-++*?(CBA$?>~<}{9zx6wu32s0p(',mk)jh&ge#"c~`vuz][wZXtWUqTRnmPkMcbgJHGG\a`_BAV?==<WPU8SR5PONML/-IBAF)'CB%#?87<}{9zx6wu32s0p(',mk)jh&%$ed!x}`{z][qpuXVrUSoRPlOMiLJII^cbE`BXW\?=Y<:V9766KPO20LEDI,*FED'&A@9"~~}:9816w432sq)(-nl*)jh&}|#db~a_{^\x[YuXVrUSoRPlOMiLJfedGFa`_X]@[Z=XWV88MRQ4O1GFKJI,+FEDC<%##"=<;:927x543tr*).om+lj(ig%fd"!b`|uty\ZvYWsVTpSQmPNjMKgfeHGba`_^W\?ZYX;9ONS64P31ML/J,BAF)'C&$@#!=~|:{y7xv4us1rp.-,ml)('&%${dbba|{zyxwvotWrqTonmlkNLha`HH]ba`CB]\[ZYXWPU8SRQ4ON0//DIH+F(>=B%#?"~<}{98y6v.-2sq/pn,+lj(!~%fd"ca}`^z][wZXtsrUTonmlkjihaJedcbaCY^]\[=S<QVUTMRKP3110EJ-HG*EDC%%:?>!<|43876wv-2sqqp-&m*)(ig}|#db~}`{]srwZXtWUqTRnQOkjMhJ`_dGEaDB^A?[><XW:U7MLQPO21LE.,,+FE>C&A@#>=<;:{y70/4us10qo-&%*ki'hf$ec!~a|^tsx[YuXVrqpSRmlejMhgJH^]bEC_B@\?=Y<:V9766KPO2M/EDI,*F)'C&$##8=<}{9216wu321rq.-,%ljji&%$#z!b}|{^yxwvuXVrkjoRPlkNLha`eHFbaD_AWV[><X;9UT75QJIN1/K.,H+)E(&B%#?"~<;:{z7654-2sqqp-,+*)"iggf#"!~}|uz]xwvYWmlTTinmlONihgfed]bE`_^A\[=<<QVU8S5KJO20L/-I,*F)'C&$@?"=}549zx65v3s+*/pn,+l)i!~%fd"!~a`{zyxwvunWUUTonmlkjihafIdcFa`_AAV[Z=X:POTSR54ONMLKJIHAF)DCBA@"8=<;:z2y0543,1*/pnnm$k('&g$#c!b`|_]y\ZvYWsrUpRhglOMihKfH^]bEC_B@\?=Y<:VU8S5KJO20//DIHG*)>'%%$?8=~;:{87654us1*).om+*ki'~}$ec!b`|_]yx[vXnmrUSoRPlkjMLg`eHcbECYX]@>Z=;W:8T75Q4211FKJ-H*@?D'%A$">!}||387xv4-,1rp.-,ml)(!hffe"!~w|_zyx[vutsrUSohglOMihKfH^]bEC_B@\?=<<QVU86RKJO20L/-I,*F)'C&$@#!=<;|{876/4u210q.-m+*k(h~}$ec!b`|{^y[qpuXVrUSonQOkdchKIeHFbEC_B@\?=<<QVUT76QPONG0..-HGFED=B%@?"=<;{{276w4t,+0/.on+*)('~%f#"!b}|^]]rwvYWslkpSQmPNjMKgJHdcFaCYX]@>Z=;W:8T75QP31MFEJIH+*EDCBA@9"~~}:987654-2s0/.o,+*jj!&%f#cyx}`^]]rwvYtVlkpSQmPNjMKgfIdF\[`CA@@UZY<W9ONS64P31M0.J-+**?DCB%$?>=<;:927x543t10p.om+lj(igff{"!b`|uty\ZYYnsrUSohglOMiLJfIGcFD`CA]\[>=XWVUTSRQJ3NMLKJ,BGFED&<%:?>7<;49zxxw.3t10q.-,ll#ii~%$#dcx}`{zy\wvXtWUqTRnQOkNLhKIeHFbECBBW\[><XQPU86R53O20LK.I+A@E(&BA$?!76;|z876wv3,sqqp-,%*k('&g$#c!b`__tyx[vXnmrUSRRglkNLha`eHFEEZ_^A?[TSX;988MRQ4O1GFK.,H+)E(&B%#?"~<;:{z76/4u21rp.-,+*kj'&%|eccb}|{zsx[vutWUkjRRglkjMLgfed]bE`_B]\[ZY<:VONS64PO20LEDI,*F)'C&$@?"=}549zx6wutt+0/pn,%$)('hg$#"!~w`^^]xwvutslqTonQOejihgJIdcba`_X]@[Z=;QP88MRQP32MLKJIHG@)''&A@?>=<;:38y654u210pp',+lj(!~%fd"ca}|_z\rqvYWVVkpoRmOediLJfIGFF[`_B@\UTY<:V97S64P31M0.--BGFE('BA@?>=<;49z76543s+0/.-m%l#('&}${"c~}`^tsx[YutWrTjinQOkNLKK`edGbDZY^A?[><X;9U86R53O20L/-IHG*)>'%%$?8=~;:9z76v43t1q)(-nl*)j'g}|#db~a_{z]xZpotWUTTinmPkMcbgJHdGEa`C^@VUZYX;:UNS6QP3NMLKJ-+G@?D'%A@#!=65:{y7xv4us10q.n&%*ki'hf$#"cb}|u^\\[vutmrUpoRPfejMKgJHdGEaDB^A?>>SXW:U7MLQ42N1/K.,++@ED'%A:9>!};:9zy654-2s0/.o,+*)(ig%|{"ca}|_]yrqvYWsrUpRhglOMiLJfeHFb[Z_B@\?=Y<:V97S64P31MLK.-HGFE>'BA$">=<;:{z76543,1r/.-nl$#ii~%$#dc~}|{zyr[YYXsrqponmfkNihgJedFbEC_^A?[TSX;9UT7R4JIN1/..CHG*E'=<A$">!};|z8yw5vt2sq/pn,+*kj'&%$#"!x}`{z]xwvXXmrqToQgfkjiLKfedcba`_XA\[ZYX:PUTSR4J3HMLKDIBG*(('<A$?>=~;:z87x5u-,1rp.om+*k(h~}$ec!~a|^tsx[YuXVrUSonQlNdchgfIH]bE`_B]\[ZY<:VONS64PO20LEDI,*F)'C&$@?"=}549zx6wu321rq.'nllk('~%f#"cawv{^\x[YuXVrUSoRPOOdihKfH^]bEC_B@\?=<<QVU86RKJO20LKJ-,GF?D'BA@#>=<;:{y70/4us10qo-&%*ki'&g$dzy~a_{^\xwZXtmlqTRnQOkNLhKIeHFbEC_^]@?ZYXQ:UT75QPONM0/JIHG@E(CBA$"87}}4987xw43210)pnnm*)('&%|#d!~a|{]\\qvuXVrkjoRPlOMiLJfeHcE[Z_B@\?=<<QVU86RKJONM0/JIHGFE>C&$$#>=<;:981x54us+0/.-nm*)('&%${dbba|{zyxwvunsVqpSQgfNNchgfIHcba`_^]\UZ=XWVUT6LQPON0F/DIHAFE>C&A@?"=<|{{276w4t,+0qo-nlkk"'&g$dzy~a_{z]xZpotWUqpSnPfejMKgJHdGEaDB^]\?>S<::9TMR5PO20FEJ-+GF)D&<;@#!=~|{{276w4t,+0qo-nl*ki'hf$ec!b`|_]yxwZYtmrUSSRmleNihgJedFbEC_^A?[TSX;9UT7R4JIN1/K.,H+)E(&B%#?"~<;|9y10vv-210qp-,%ljji&%${"c~}`{zyxwZXtmlqTRnmPNjcbgJHdGEaDB^]@[=SRW:8T75QPO21LKJCH+FE(&<;@#!=~|:{y7xv4usrr).-n+k#"'hf$ec!b`__tyx[YunmrUSonmPOjihg`IGGFa`_^]V[>YXW:UTSRQ42NGFK.,HG*(D=<A$">=~;{327xv4us10qo-&%*ki'hf$ec!b`|_]y\ZvutWVqponmfkNLLKfedcbaZCAA@[ZYXWVUNS6QPO20FE--BGFE('BA@?>=<5:{87x54tss*/.om+$#(ig%fd"ca}|_z\rqvYWsVTSShmlOMibafedGFa`_^]\[ZS<WVUTS5KPONM/E.CHGF?D=B%##"7<}:987x54t21r/o'&+lj(ig%$e"bxw|_]yxwZYnsVqpSQgfNNchgfIHc\ECCB]\UZ=XWV9TS5Q42N1/K.,HG*E'=<A$">=~;{327xv4us1rp.om+*)ji&%|#d!~a_uty\ZvuXsUkjoRPlOMLLafeHcE[Z_B@\?=Y<:V97S64P31M0.JIH+*EDC<%##"=<;:38y654u21q/pn,mk)(i&f|{"ca}|_z\rqvYWsVTpSQmPNjMKgfIdF\[CCX]\[>=XWVUNS6QPON1LK-I,*FE(&B;:?"~<}{9zx6wu3tr0qo-nlkk"'&%fe"!~}|{zs\ZZYtsrqponmfkNihgfIdcba`CA]VUZ=;W:877LQP31MFEJ-+**?DC&A#98=~|:{y7xv4us1rp.om+ljii~%$#dc~}|{zyxwpuXsrqpoQglkjiKaJ_dcb[`Y^A\[ZY<WV8TS6Q3IHM0.J-+GF)'C<;@#!=~|:{y7xv4us1rp.om+*)ji~g$#"!b}|{]]rZZotsrUTongPNNMhgf_dGba`_B@VUZ=;W:877LQP3N0FEJ-+**?DC&A#98=~|:{y7xv4us1rp.om+ljii~%$#dc~}|uz]xwvuXsrTpSQPPejiLJf_^cFD`CA]@>Z=;W:8T75Q42NML/.IHGF?(&&%@?>=<5:{87x54321rp.'&+lj('hf${z!b`|_]y\ZvuXsUkjoRPlOMihgJIdcba`Y^A\[><RQV97S64P31M0.J-+**?DC&A#98=~|:{y7xvuu,10qo-&%*ki'&%fe"!~}|{t][[ZutsrqpohmPkjMhgfHH]baD_AWV[ZY<;VUTSRQPIN1//.IHGFEDCB;$?>=~;:987xv4-,rr).-,ml)('&%$#"yb}|{zy[qvutsUkTinglkjchKIIH]bE`_B]\[ZY<:VON66KPON10EJ-HGF)DC%$$9>=~|:327xv43t1q)(-nl*ki'&ge#zy~a_{^\x[YuXVrUSoRPlkjMLg`IGGFa`Y^A\[>YXW9UT76QPIN1LKJ-+A@((=BA@#"=<;4{yyx5432+0q.-,m*)i'hf$ec!~a|^tsx[YutWrTjinQOkjMKg`_dGEaDB^A?[><X;988MRQP32MLKJCH+FE(CBA##8=<}:z21654ut10/.-&mkkj'&%$#"y~a|{z]xwYuXVrqTRngfkNLhKIHH]baDB^WV[><X;9UT7R4JIN1/K.,H+)E(&B%#?>=~}:98765.3t10q.-,+*ki'~}$ec!~a_{tsx[YuXVrUSonQlNdchKIeHFba`CB]\[ZYXWP9776QPONMLKJCH+FE(&<;@#!=~|:{y7xv4usrr).-n+k#"'hf$ec!b`__tyx[YunmrUSonmPOjihgfedc\aD_^]\[=SXWVU7M6KPONGLEJ-HGF)DC%A$">=~;{327xv4us1rp.om+lj(ig%fd"ca``uzyx[ZoXVVUpinQlkNihgIedGFaZ_B]\[><RQ99NSRQ43NMF/--,GFE>C&A@?"=<|{{276w4t,+0qo-nl*ki'&g$dzy~a_{^\xwZXtmlqTRnQOkNLhKIeHFba`CB]\[TY<WV9TSR44INM0K-CBGFE('BA@?8!}}|98765.3t10/p-,l*)jh&}|#db~a_{^\[[putWUqjinQOkNLhgJeG]\aDB^A?[><X;9UT7R4JIN1/..CHGF)(CBA@?8=~;:{87654us1*).om+*ki'~}$ec!b`|_]yx[vXnmrUSoRPlkjMLgfedcb[DBBA\[ZYXWVOT7RQ42HGL/-I,*F)'C&$@#!~~5:9z7w/.3tr0qo-nlkk"'&ge#zy~a_{zy\[vutsrqpinQlkNihJfIGFF[`_B@\UTY<:VU8S5KJO20LK.I+A@E(&B%#?"~<}{9zx6wu321rq.-,+*)('~g$#"!~`v{zyxZpYnsrqjohmPkjMKa`HH]ba`CB]V?==<WVOT7RQ42HGL/-I,*))>CB%@"87<}{98y6v.-2sq/.om+$#(ig%fd"ca}`^z][wZXWWlqpoRQlkdiLgfeHcbD`CA]@>Z=;::OTS6Q3IHM0.JI,G)?>C&$@#!=~|:{y76w4t,+0/.on+*)"i&%fd"!~}|_t]xwvutslqTonmPkjLKK`edGbDZY^A?>>SXW:U7MLQ42NM0K-CBG*(DC&A#98=~|{{2765v-2s0/.-n+*)ii~ff{"!~a`u^\\[votWrqpoRmlNMMbgfIGc\[`CA]\?Z<RQV97S64P31M0.J-+G*(D'%A$">!}||3876wv3,1r/.-,m*)i'&g$dzy~a_{^\xwZXtmlqTRnQOkNLhKIeHFbEC_B@\[Z=<WVO8SRQP3NML..C++@EDC&%@?>=6}{{z76543,1r/.-,mk#"'hf$ecbbw|{^y[qpuXVUUjonQlNdchKIeHFbEC_B@\?=Y<:V9766KPON10KJIHG@E(CBA@#>=};|zyy054us1*).om+lj(ig%fd"ca}`^z][wvuXWrqponmfOjiLJfedcbEZC^]\[ZYRW:UTS6QP2N1/KJ-H*@?D'%$$9>=~|:327xv4us10qo-&%*ki'hf$ec!b`|_]y\ZvutWlqTonmlOjihJJ_GG\a`_BAV?==<WPU8SRQP3NM/..CHG*(D=<A$">=~;{327xv4us1rp.om+lj(ig%fd"ca}`^]]rwvuXWrkpSnmlkNihJfeHcE[Z_B@\?=YX;9UNMR53O20L/-I,*F)'C&$@#!=<;|{870w4321r/.-mm$jj!&%$ed!~}|u^\\[vutsrkpSnmlkNLbafIGcFDCCX]\?Z<RQV9766KPO2M/EDI,*F)'C&$@#!=~|:{y7xvuu,10/po,+*)(!&g$#"!b}|^z][ZZotsVTpihmPNjMKgJHdGEaDB^A?[><XWV98SRQPONG0KJ-+GFEDC&;$?>=<;:38y654u21qpp',+lj(!~%fdccx}|_z\rqvYWsVTpSQmPNjMKgJHdGEaDB^]@[=SRW:877LQPO2GL/JIHG*EDC%%:""7<;:{z1xvvu2+0q.-,+l)(hgg|#"ca}vuz][wvYtVlkpSQmPNjMKgJHdGEaDB^A?[><X;988MRQP32MFK.IHGF)DC%A@#>~65:{y7xv43tr0)(-nl*ki'hf$ec!b`|_]y\ZvutWVqpiRmlOMihgfeH]Fa`_^]\UZ=;W:UNSRQP3HM0KJIH+FE'CB%@"87<}{9zxww.32s0p(',mk)jh&ge#db~a_{^\x[YXXmrqpSRgPNNchKIIH]bE`_^]\?ZYX::O77LQPO21FK.IHG*(DCBA@#8!<;:98705v321r/.n,+l)i!~%fdccx}|_]yrqvYWsrUpRhglOMiLJfIGcFD`CA]\?Z<RQ99NSRQ4I2MLKJIH+dd'&s_@?"![|k9EUC54tPPq)(Ln%I)"h3g1B@y~>O;M\[87o#WE2pSh.?,=iu:s&Gc\"~~XjzUgfwd:ss7L533!1}KhIH+@d>P<$$?![6}X9yUCBvQ,1=Mo',I*6"iDVfA@.?`<_M\r8IHXV31So/.lkjvLt`H%F#!DC1|?>gSXuPb'6p4n2mGFEi-yTFcD=%_#"8J<}{Fyx05SRPPa/L-,lH)F43fCAc!aaOu;:xZpH533TCBQzlOMvKgfe$]"D!C^j/>-w+u)O'6%$J\mM}E{,fx@E'=<_$po!6lkjz7wvAR,1a/.^&l$#Yig}|d/yx}=NM:9w%u5m3D0|.@-ewcKgsI7G#n`BA0/.yxeWtb'6pK43lkkEW-,Gdcb&&r_pK7~5|W2UgTR-sba/_^Jl$6F!hV1TAcQP<;;9977uWmEDS0.gfxdv;gsHH6\!`B|0i.xYvvPU7&_5]2ll}ihgHfeRQC&A#^!!}|Y9iVCSuQQPN<L^JJHGFF&V$AcyQw_{t\\J6H5sU1}Bhg?+*L(aJ%dGF!32|j{zT<w*P8'S%oJm[0k.i,g*e(c&a$_"]~[|YzWxUvStQrOpM:JJljFF&V1{@RQ

```

Try it online!
> 5 votes

# Answer
# Jelly, ~~20~~ 17 bytes

```
ṫ4;“'ṫṗḶ/÷!Ṗ»⁾Hi;

```

Try it online!

A monadic link taking the input as its argument and returning a Jelly string.

### Explanation

```
ṫ4                | everything from 4th character on
  ;“'ṫṗḶ/÷!Ṗ»     | concatenate ", I’m Jelly!" to the end
             ⁾Hi; | concatenate "Hi" to the beginning

```
> 4 votes

# Answer
# Perl 6, ~~30 28~~ 27 bytes

```
{S/.../Hi/~", I'm Perl 6!"}

```

Try it online!
> 4 votes

# Answer
# JavaScript, ~~38~~ 37 bytes

```
x=>`Hi${x.slice(3)}, I'm JavaScript!`

```

Try it online!
> 4 votes

# Answer
# Rust, 41 bytes

```
|x:&str|print!("Hi{}, I'm Rust!",&x[3..])

```

Try it online!
> 4 votes

# Answer
## VBA (Excel), 27 ~~28~~ bytes

```
?"Hi"Mid([A1],4)", I'm VBA!

```

Input goes in cell A1 of the Active Sheet in Excel, run code in the Immediate Window

Takes advantage of the fact that `"SomeString"SomeValue` and `SomeValue"SomeString"` will implicitly concatenate, and that omitting the third argument from the `MID` function will take all characters from the end of the input - turning it into a "dump initial characters" function

(-1 byte thanks to Shaggy, but +1 when OP confirmed that all answers should end with an exclamation mark)
(-1 byte thanks to Taylor Scott reminding me that the final double-quote was optional)
> 4 votes

# Answer
## Batch, 22 + 3 = 25 bytes

```
@echo Hi %*, %0 Batch!

```

+3 bytes for naming this file `I'm` (with the required `.bat` extension for Batch files). Invoke as `I'm hungry`, when it will echo `Hi hungry, I'm Batch!`.
> 4 votes

# Answer
# Jelly,  ~~16~~  15 bytes

```
Ḋa⁾Hi“'ṫṗḶ/÷!Ṗ»

```

A full program accepting a (Python formatted) string argument which prints the result.

**Try it online!**

### How?

```
Ḋa⁾Hi“'ṫṗḶ/÷!Ṗ» - Link: list of characters    e.g. "I'm a programmer"
Ḋ               - dequeue                          "'m a programmer"
  ⁾Hi           - pair of characters               "Hi"
 a              - logical AND (vectorises)         "Hi a programmer"
     “'ṫṗḶ/÷!Ṗ» - list of characters               ", I'm Jelly!"
                -  - since this is a new leading constant chain the previous result
                -    is implicitly printed (with no trailing newline)
                - program result is implicitly printed (again with no trailing newline)

```

Note: `Ḋ⁾Hio...` works too.
> 4 votes

# Answer
# AWK, 28 25 bytes

```
$1="Hi",$0=$0", I'm AWK!"

```

Try it online!

This program modifies the contents of field "$1" and "$0" in a range pattern. Because no actions are specified after the pattern, the default action `{print $0}` is executed.
> 4 votes

# Answer
# , 22 bytes

```
', I''m J!',~'Hi',3}.]

```

Try it online!
> 3 votes

# Answer
# 05AB1E, ~~23~~ 21 bytes

Saved 2 bytes thanks to *Kevin Cruijssen*

```
',«#À„Hiš"05AB1E!"ªðý

```

Try it online!

**Explanation**

```
',«                    # append ","
   #                   # split on spaces
    À                  # rotate left
     „Hiš              # prepend "Hi"
         "05AB1E!"ª    # append the language name
                   ðý  # join on spaces

```
> 3 votes

# Answer
# bash, 24 bytes

```
echo Hi ${@:2}, $1 bash!

```

TIO
> 3 votes

# Answer
# Retina 0.8.2, ~~26~~ ~~25~~ 23 bytes

```
^...
Hi
$
, I'm Retina!

```

-1 byte thanks to *@attinat*.
-2 bytes by porting *@Adám*'s QuadR answer, so make sure to upvote him!!

PS: *@Neil* posted a shorter Retina answer in the new version, so I've changed this answer to Retina 0.8.2 explicitly.

Try it online.

**Explanation:**

Replace the first three characters with "Hi":

```
^...
Hi

```

And then append a trailing ", I'm Retina!" (by replacing the end of the string):

```
$
, I'm Retina!

```
> 3 votes

# Answer
## Javascript (Node.js in TIO), 60 bytes

```
s=>"Hi"+s.slice(3)+", I'm J"+process.argv[0].slice(6,15)+"!"

```

Try it online
> 3 votes

# Answer
# QuadR, 22 bytes

```
^...
$
Hi
, I'm QuadR!

```

Try it online!

This replaces:

`^...` three initial characters
and
`$` the end-of-line

with

`Hi`
and
`,I'm QuadR`
respectively
> 3 votes

# Answer
# Retina, ~~22~~ 21 bytes

```
3L$`
Hi$', $` Retina!

```

Try it online! Link includes test cases. Does not work in Retina 0.8.2, so adapt @Adám's QuadR answer instead. Explanation: The pattern is empty, so it matches at every position in the input string. We only need the third (or fourth would work) match however. The substitution is then applied to that match. Within that substitution, `$'` refers to the rest of the string and `$`` refers the the beginning of the string.
> 3 votes

# Answer
# VSL, 51 bytes

```
fn f(s:String){print("Hi "+s[from:4]+", I'm VSL!")}

```

Glad VSL can now participate in some golfs :)

Try it online! (doesn't have latest VSL so might not work just yet)
> 3 votes

# Answer
# Ed, 30 bytes

I couldn't leave a `sed` answer without an `ed` answer!

```
%s/I'm\(.*\)/Hi\1, I'm ed!
wq

```

Try it online!
> 3 votes

# Answer
# Haskell, 34 bytes

```
f x="Hi"++drop 3x++", I'm Haskell"

```

Try it online!
> 3 votes

# Answer
# Knight, 24 bytes

```
O++'Hi 'P", I'm Knight!"
```

Try it online!
> 3 votes

# Answer
# Bash, 32 Bytes

```
read i;echo Hi${i:3}, I\'m Bash!

```

Try it online
> 3 votes

# Answer
# Red, 39 bytes

```
func[s][rejoin["Hi"at s 4", I'm Red!"]]

```

Try it online!
> 2 votes

# Answer
# Wolfram Language (Mathematica), 43 bytes

```
"Hi"<>#~StringDrop~3<>", I'm Mathematica!"&

```

Try it online!
> 2 votes

# Answer
# Befunge-93, 45 bytes

```
"iH",,~~~>~# :1+#,_0"!39-egnufeB m'I ,">:#,_@

```

Try it online!

Dissected:

```
"iH",,                                           Push then output constant "Hi"
      ~~~                                        Read "I'm" from output, which gets unused
         >~# :1+#,_                              Non-wrapping cat program
                   0"!39-egnufeB m'I ,"          Push null-terminated constant string to stack
                                       >:#,_@    Output string and exit

```
> 2 votes

# Answer
# C (gcc), 49 bytes

+3 Bytes: was not working
-3 Bytes: K&R style function. thanks JohanduToit

This is similar to the answer from Neil A. but takes the input as commandline arguments instead of a function parameter.

```
main(b,a)char**a;{printf("Hi%s, I'm C!",a[1]+3);}

```

Try it online!
> 2 votes

# Answer
# PowerShell, ~~42~~ ~~41~~ ~~40~~ 37 bytes

<sup>-1 byte thanks to Spitemaster</sup>

```
"Hi$($args|% s*g 3), I'm PowerShell!"

```

Try it online!

There might be a cheaper automatic variable holding the PowerShell version hiding somewhere but I'm not sure. Answer takes the `s`ubstrin`g` after `I'm` to the end and builds a string with it.
> 2 votes

# Answer
# T-SQL, 44 bytes

```
SELECT STUFF(v,1,3,'Hi')+', I''m SQL!'FROM t

```

Input is taken via pre-existing table **t** with text field **v**, per our IO standards.

`STUFF` is shorter than variations using `SUBSTRING` or `RIGHT`.

Can handle multiple inputs (as separate rows in **t**), although that's not required.
> 2 votes

# Answer
# Canvas, 19 bytes

```
ｊｊｊHiŗ, I'm Canvas!

```

Try it here!

18 bytes only handling single letter names
> 2 votes

# Answer
# SNOBOL4 (CSNOBOL4), 55 bytes

```
	INPUT "I'M" REM . X
	OUTPUT ="HI" X ", I'M SNOBOL"
END

```

Try it online!
> 2 votes

# Answer
# GFortran, 73 bytes

As usual, Fortran string handling is clunky and annoying!

try it online

```
character(99)S;read'(A)',S
print*,'Hi',trim(S(4:)),', I''m GFortran!'
end

```
> 2 votes

# Answer
# PowerShell Core, 53 bytes

```
Filter f{$_-replace"(...)(.*)",'Hi$2, $1 PowerShell'}

```

Try it online!

Probably could do more improvement on the regex. Oh well.
> 2 votes

# Answer
# Sinclair ZX80 BASIC, 92 tokenized BASIC bytes

As the Sinclair ZX80 character set only allows for upper-case and 'inversed' characters, and doesn't include a single-quote, `shifted-E` is substituted here. There is no exclamation mark in the ZX80 character set either - Source.

```
 1 INPUT A$
 2 FOR I=0 TO 2
 3 LET A$=TL$(A$)
 4 NEXT I
 5 PRINT "HI";A$;","
 6 PRINT "I'M SINCLAIR ZX80 BASIC"

```

How it works:

Line 1 takes the input as a string value to `A$`; Line 2 - 4 creates a loop to remove the first three characters of the entered value; Line 5 - 6 then outputs the ultimate Dad joke.
> 2 votes

# Answer
# naz, 122 bytes

```
2a2x1v7a8m1o3d4m9a1o3d3s1o1x1f5r3x1v2e1o1f0x1x2f0a0x1f0m9a2a4m1o9s3s1o2m9a1o2d3a1o3m8s1o3d4s1o3m9a5a1o9s4s1o9a9a7a1o3d7s1o

```

Uses a lot of arithmetic instructions to set the register to each of the character values in the dad-joke format.

Works for any input file terminated with the control character STX (U+0002).

**Explanation** (with `0x` instructions removed)

```
2a2x1v           # Set variable 1 equal to 2
7a8m1o           # Output "H"
3d4m9a1o         # Output "i"
3d3s1o           # Output a space
1x1f5r3x1v2e1o1f # Function 1
                 # Read the 5th byte of input, then remove it from the input
                 # This has the effect of skipping over the self-descriptor's "I'm "
                 # Jump to function 2 if the value of the byte is equal to variable 1
                 # Otherwise, output the byte and jump back to the start of function 1
1x2f0a           # Function 2
                 # Add 0 to the register
1f               # Call function 1
0m9a2a4m1o       # Output ","
9s3s1o           # Output a space
2m9a1o           # Output "I"
2d3a1o           # Output an apostrophe (')
3m8s1o           # Output "m"
3d4s1o           # Output a space
3m9a5a1o         # Output "n"
9s4s1o           # Output "a"
9a9a7a1o         # Output "z"
3d7s1o           # Output "!"

```
> 2 votes

# Answer
# Pip, 21 bytes

```
["Hi"a@>3k"I'm Pip!"]

```

Try it online!

### Explanation

Constructs a list containing:

* Literal string `"Hi"`
* The input, minus its first three characters (`a@>3`)
* A string containing a comma and a space (which happens to be the initial value of the variable `k`)
* Literal string `"I'm Pip!"`

By default, lists are concatenated together when they are output.

Alternately, we can reuse the `I'm` from the input for a different 21-byte solution:

```
["Hi"a@>3ka@<4"Pip!"]

```
> 2 votes

# Answer
# Zsh `-c`, 21 bytes

```
<<<"Hi${1:3}, I'm $0"

```

Try it online! (includes wrapper script to run with `-c`)
> 2 votes

# Answer
# Scala, 36 bytes

```
{case s"$a $b"=>s"Hi $b, $a Scala!"}

```

Try it online
> 2 votes

# Answer
# JavaScript/Python (polyglot), <sup>149</sup> 141 bytes

```
a=1//2;import sys
eval(["print('Hi'+sys.argv[1][3:]+', I\\'m Python!')","console.log('Hi'+process.argv[2].slice(3)+`, I'm JavaScript!`)"][a])

```

## Example input (First arg)

```
I'm bored

```

## JavaScript output (Try it Online!)

```
Hi bored, I'm JavaScript!

```

## Python output (Try it Online!)

```
Hi bored, I'm Python!

```

## Explanation

* `a=1//2;import sys`:
    + What Python see: `a=1//2`= `0` (integer division/no-reminder), `;import sys`
    + What JavaScript see: `a=1` (the rest commented)
* `["print('Hi'+s`\[...\]`","console.log(`\[...\]`"]`: Array with the code in Python, and the code in JavaScript respectively.
* `[a]`: Select the index of it (Python:0', JavaScript:1)
> 2 votes

# Answer
# APOL, 32 bytes

`+("Hi " +(V(i 4) ", I'm APOL!"))`
> 2 votes

# Answer
# Lexurgy, 44 bytes

```
a:
I'm=>Hi
*=>\,\ I'm\ Lexurgy\!/_ $//_ $$

```

Ungolfed explanation:

```
a:
I'm => Hi               # Swap "I'm" to "Hi"
* => \,\ I'm\ Lexurgy\! # the tack on the joke...
         / _ $          # when at the end of a word...
              // _ $$   # but not in between words.

```
> 2 votes

# Answer
# C# (Visual C# Interactive Compiler), 33 bytes

```
n=>$"Hi{n.Substring(3)}, I'm C#!"

```

Try it online!
> 1 votes

# Answer
# APL+WIN, ~~31~~ 21 bytes

10 bytes saved by taking on board Adam's comments. Thanks.

```
"Hi",3↓⎕,", I'm APL!"

```

Prompts for input string.

Try it online! Courtesy of dzaima/APL
> 1 votes

# Answer
# K (ngn/k), 21 bytes

```
{"Hi",3_x,", I'm K!"}

```

Try it online!
> 1 votes

# Answer
# Nim, 32 bytes

```
s=>"Hi"&s[3..s.len]&", I'm Nim!"

```

Try it online!
> 1 votes

# Answer
# Icon, 52 bytes

```
procedure d(s);return"Hi"||s[4:0]||", I'm Icon!";end

```

Try it online!
> 1 votes

# Answer
# Haxe, ~~57~~ 54 bytes

```
function(x:String)return'Hi${x.substr(3)}, I\'m Haxe!'

```

Try it online!
> 1 votes

# Answer
# Charcoal, 21 bytes

```
Hi✂Ｓ³Ｐ, I'm Charcoal!

```

Try it online! Link is to verbose version of code. Explanation:  is the `Slice` operator which normally takes four arguments, however the use of the `P` command to output the suffix allows Charcoal to deduce that the last two arguments were omitted.
> 1 votes

# Answer
# Clojure, 36 bytes

```
#(str"Hi"(subs % 3)", I'm Clojure!")

```
> 1 votes

# Answer
# Lua, ~~68~~ 59 bytes

```
function d(s)return(s:gsub("(I\'m)(.*)","Hi%2, %1 Lua"))end

```

Uses a pattern to swap in the I'm in the original and then returns the joke. Having chucks on a single line like this is valid, but ugly.

Edit: More efficient use of gsub
> 1 votes

# Answer
# **Kotlin, 34 bytes**

```
"Hi${i.substring(3)}, I'm Kotlin!"

```

Try it online!

# **Kotlin, 26 bytes**

Is this a loop hole ?

```
"Hi${i.s(3)}, I'm Kotlin!"

```

Try it online!

The 26 is definitely a loophole else I can golf it to *5* bytes with:

```
i.k()

```

which is meaningless.

Try it online!
> 1 votes

# Answer
# Forth (gforth), 40 bytes

```
: f 3 -3 d+ ." Hi"type ." , I'm Forth!";

```

Try it online!

### Code Explanation

```
: f                 \ start a new word definition
  3 -3 d+           \ add 3 to the starting address and subtract 3 from the string length
  ." Hi"type        \ output "Hi" followed by all but the first 3 characters of the input string
  ." , I'm Forth!"; \ output ", I'm Forth!" and end the word definition

```
> 1 votes

# Answer
# ReRegex, 31 bytes

```
^I'm/Hi/[^!]$/$0, I'm ReRegex!/

```

This assumes input doesn't end on `!`.

**TIO**
> 1 votes

# Answer
# Julia 1.0, 30 bytes

```
s->"Hi$(s[4:end]), I'm Julia!"

```

Try it online!
> 1 votes

# Answer
# JavaScript (V8), 37 bytes

```
s=>`Hi${s.slice(3)}, I'm JavaScript!`

```

Try it online!
> 1 votes

# Answer
# Pyth, 21 bytes

`++"Hi">z3", I'm Pyth!`

Try it here
> 1 votes

# Answer
# k, 21 bytes

```
,[;", I'm k!"]"Hi",3_

```
> 1 votes

# Answer
# Runic Enchantments, 35 bytes

```
iiil2="Hi "$5*?S$' $", "$" Runic!"@

```

Try it online!

Spaces only need to be escaped if you want to use an adjective or noun-phrase as your `<I'm!>`. Runic splits input on spaces and newlines and as the challenge specified input as either `an <adj>` or `<noun>` as single word tokens, I used this feature to avoid parsing and splitting input with code.
> 1 votes

# Answer
# Wren, 37 bytes

```
Fn.new{|x|"Hi%(x[3..-1]), I'm Wren!"}

```

Try it online!

# Explanation

```
Fn.new{|x|                          } // New anonymous function
          "Hi                         // The hi section
             %(x[3..-1])              // THe input sliced, without the "I'm"
                        , I'm Wren!"  // THe third part, the remaining of the string

```
> 1 votes

# Answer
# 05AB1E, 20 bytes

```
3.$”ŒÞÿ, I'm 05AB1E!

```

Try it online!

```
3.$”ŒÞÿ, I'm 05AB1E!  # full program
   ”ŒÞÿ, I'm 05AB1E!  # "Hiÿ, I'm 05AB1E!"...
                      # (implicit) with ÿ replaced by...
                      # implicit input...
 .$                   # excluding the first...
3                     # literal...
 .$                   # chars
                      # implicit output

```
> 1 votes

# Answer
# Nim, 43 bytes

```
echo "Hi",stdin.readAll[3..^1],", I'm Nim!"

```

Try it online!
> 1 votes

# Answer
# Vyxal , 16 bytes

```
3ȯ‛Hi$`, I'm ₴ŀ!

```

Try it Online!

I'm assuming I don't need to include the flag, since the ruby answer doesn't.
> 1 votes

# Answer
# Perl 5 (`-p`), 26 bytes

```
s/I'm(.*)/Hi$1, I'm Perl!/

```

No deep magic, just a straight regex substitution
> 1 votes

# Answer
# FerNANDo, 381 bytes

Outputting language name as `ferNANDo`, as in esolang page title.

```
0 A S D F G H J K
0 Q W E R T Y U I
1 0 1 1 0 1 1 0 1
0 1 0 0 1 0 0 0
0 1 1 0 1 0 0 1
? a b c d e f g h
?
a b c d e f g h
? a b c d e f g h
?
0 0 1 0 1 1 0 0
0 0 1 0 0 0 0 0
A S D F G H J K
Q W E R T Y U I
0 1 1 0 1 1 0 1
0 0 1 0 0 0 0 0
0 1 1 0 0 1 1 0
0 1 1 0 0 1 0 1
0 1 1 1 0 0 1 0
0 1 0 0 1 1 1 0
0 1 0 0 0 0 0 1
0 1 0 0 1 1 1 0
0 1 0 0 0 1 0 0
0 1 1 0 1 1 1 1
0 0 1 0 0 0 0 1

```

Try it online!

## How it works

```
# accepts I
0 A S D F G H J K
# accepts '
0 Q W E R T Y U I
# accepts m
1 0 1 1 0 1 1 0 1
# outputs H
0 1 0 0 1 0 0 0
# outputs i
0 1 1 0 1 0 0 1
# cat begins
? a b c d e f g h
?
a b c d e f g h
? a b c d e f g h
?
# cat ends
# outputs rest
# characters .
0 0 1 0 1 1 0 0
0 0 1 0 0 0 0 0
A S D F G H J K
Q W E R T Y U I
0 1 1 0 1 1 0 1
0 0 1 0 0 0 0 0
0 1 1 0 0 1 1 0
0 1 1 0 0 1 0 1
0 1 1 1 0 0 1 0
0 1 0 0 1 1 1 0
0 1 0 0 0 0 0 1
0 1 0 0 1 1 1 0
0 1 0 0 0 1 0 0
0 1 1 0 1 1 1 1
0 0 1 0 0 0 0 1

```
> 1 votes

# Answer
# jq, 21 bytes

```
"Hi\(.[3:]), I'm jq!"

```

Try it online!
> 1 votes

# Answer
# nroff, 34 bytes

Using a hack NOT to quote the input with quotation marks for usage to split an argument into words.

```
.de x
.shift
Hi \\$* I'm nroff!
..

```

Attempt This Online!

## Usage examples

```
.x I'm a programmer

.x I'm tired

.x I'm bored

```
> 1 votes

# Answer
# Vyxal, 15 bytes

```
3ȯ`HiΠ, I'm ₴ŀ!

```

Try it Online!
> 1 votes

# Answer
# Nibbles, 16.5 bytes

```
"Hi "`>4@", "$"Nibbles!"

```

Attempt This Online!

## Explanation

```
"Hi "`>4@", "$"Nibbles!"
"Hi "                    Output "Hi "
     `>                  Drop the first
       4                  4 characters
        @                 from input
     `>                   and remember them
         ", "            Output ", "
             $           Output the remembered string
              "Nibbles!" Output "Nibbles!"

```
> 1 votes

# Answer
# AutoHotkey, 43 bytes

```
s := "I'm tired"
MsgBox % "Hi"SubStr(s,4)", I'm AutoHotkey!"

```

Not sure what's considered an output in AutoHotkey and I guess input string is not counted, so in that case the second line is 43 bytes.
> 0 votes

# Answer
# Dart, ~~40~~ 39 bytes

```
f(s)=>"Hi${s.substring(3)}, I'm Dart!";

```

Try it online!
> 0 votes

# Answer
**AutoIt, 45**

```
Msgbox(0,0,"Hi "&$cmdLine[2]&", I'm AutoIt")

```

Grabs the second word from the command line and puts it in a popup. (Must be compiled to exe)
> 0 votes

# Answer
# Gema, ~~20~~ 19 characters

```
<G>*=Hi*, $1 Gema\!

```

Sample run:

```
bash-4.4$ echo -n "I'm amazing" | gema '<G>*=Hi*, $1 Gema\!'
Hi amazing, I'm Gema!

bash-4.4$ echo -n "I'm a programmer" | gema '<G>*=Hi*, $1 Gema\!'
Hi a programmer, I'm Gema!

```

Try it online!
> 0 votes

# Answer
# Rexx (Regina), 35 bytes

```
say"Hi"substr(arg(1),4)", I'm Rexx"

```

Try it online!
> 0 votes

# Answer
# Bean, 30 bytes

```
00000000: 56d8 8100 d3d0 80a0 5d20 8081 253c 5881  VØ..ÓÐ. ] ..%<X.
00000010: 01c8 69ac a0c9 a7ed a0c2 e5e1 ee21       .Èi¬ É§í Âåáî!

```

Original JavaScript:

```
`Hi${a.slice(3)}, I'm Bean!`

```

The program takes the first line of raw input implicitly in `a`, removing the first three characters, and outputs the template above using that string.

Demo

---

## Test Suite

```
00000000: 53d0 80d3 d080 a078 2080 8840 a05d 56d8  SÐ.ÓÐ. x ..@ ]VØ
00000010: 8100 d3d0 80a0 5d20 8081 253c 5881 0120  ..ÓÐ. ] ..%<X..
00000020: 807b 2381 02c8 69ac a0c9 a7ed a0c2 e5e1  .{#..Èi¬ É§í Âåá
00000030: ee21 0a                                  î!.

```

Original JavaScript:

```
_.map(a=>`Hi${a.slice(3)}, I'm Bean!`).join('\n')

```

The test suite takes all the lines of raw input implicitly in `_`, applies the first program to each line using `map()`, then outputs each result per line.

Demo
> 0 votes

# Answer
# 아희 (Aheui), 319 bytes

```
밦밚따밬다발빠받밠따따빠따따밟밢밙다다다분
뭏떠벓벑떠떠벐벌벋떠떠벉더너벅번뻐떠뻐떠벊
맣＠섹뵗솬밯삭밧타뿌싿삳빠맣박밯빠싸주마붗
반밚따따두쪼＠썽선처손＠＠＠오섣멓서차소빠
성멓뻐섣멓＠＠＠＠＠＠희＠먛＠셔멓섣멓멓멓

```

Try it online!

Prints `아희`(official Korean name of the language) instead of `Aheui`, so the code is quite long.
> 0 votes

# Answer
# Assembly (gcc, x64, Linux), 315 bytes

```
h:.int 26952
s:.int 32
g:.asciz ", I'm GNU Assembler!\n"
.globl main
main:
mov %rdi, %r13
mov %rsi, %r14
lea h, %rdi
mov $0, %rax
call printf
mov $2, %r15
l:
lea s, %rdi
mov $0, %rax
call printf
mov (%r14, %r15, 8), %rdi
mov $0, %rax
call printf
inc %r15
cmp %r15, %r13
jg l
lea g, %rdi
mov $0, %rax
call printf
ret

```

Try it online!

Ungolfed:

```
.section .bss

.section .data

hi:
.asciz  "Hi"

space:
.asciz  " "

imgnuasm:
.asciz  ", I'm GNU Assembler!\n"

badArgumentCount:
.asciz  "Requires at least two arguments\n"

.section .text
.globl main
main:

cmpq $3, %rdi # must have at least two arguments
jl .error

movq %rdi, %r13 # save argc
movq %rsi, %r14 # save argv

leaq hi, %rdi
movq $0, %rax   #%rax holds how many xmm regs to be used in x86-64
call printf

movq $2, %r15 # because (%r14, %r15(==0), 8) is the program path and (%r14, %r15(==1), 8) is "I'm"

.loopbegin:

  leaq space, %rdi
  movq $0, %rax
  call printf

  movq (%r14, %r15, 8), %rdi #(%r14, %r15, 8)
  movq $0, %rax
  call printf

  incq %r15
  cmp %r15, %r13
  jg .loopbegin

  leaq imgnuasm, %rdi
  movq $0, %rax
  call printf

  jmp .done

.error:
  leaq badArgumentCount, %rdi
  movq $0, %rax #%rax holds how many xmm regs to be used in x86-64
  call printf

.done:
  movq $0, %rax # return 0 (success)
  ret

```
> 0 votes

# Answer
# C# .NET, 94 bytes

```
class P{static void Main(string[]a){System.Console.Write($"Hi {a[0].Substring(4)}, I'm C#");}}

```

Try Online
> 0 votes

# Answer
## Clojure - 36 Bytes

`#(str"Hi "(subs %4)", I'm Clojure!")`

Trivial solution is trivial, probably has room for improvement
> 0 votes

# Answer
# VBScript, 51 bytes

```
Msgbox "Hi "&Wscript.Arguments(1)&", I'm VBScript!"

```

Test like:

```
ScriptFile.vbs I'm tired

```
> 0 votes

# Answer
# TI-Basic, 47 bytes

```
Input Str1
"Hi"+sub(Str1,4,length(Str1)-3)+", I'm TI-Basic!

```

Output is stored in `Ans` and displayed at the end.
> 0 votes

# Answer
# Pxem (don't break loop when items are insufficient), ~~46~~ 38 bytes, filename only.

It's been a while. As usual, `\0001` is not such a string but a character 0x01.

```
.z.im.a_iH.w.i.c\0001.+.a.s!mexP m'I ,.v.p

```

Try it online!

## With comments

```
XX.Z
.A.zXX.Z
  # push(getchar())
  .A.iXX.Z
  # constant 'm' charcode
  .AXXm.Z
# break loop if pop==pop
.A.aXX.Z
# "Hi" and dummy
.AXX_iH.Z
# dummy is popped before entering loop
.A.wXX.Z
  # keep pushing until EOF (-1) is met
  .A.i.c\0001.+.aXX.Z
# discard final EOF
.A.sXX.Z
# ", I'm Pxem!"
# reverse stack before printing each item
.A!mexP m'I ,.v.p

```
> 0 votes

# Answer
# CLC-INTERCAL, ~~356~~ 352 bytes.

Assumes adjective and noun has \<100 characters.

```
DO;1<-#3DO;2<-#99DOWRITEIN;1+;2DO;3<-#2DO;3SUB#1<-#29DO;3SUB#2<-#1118DO;4<-#1DO;4SUB#1<-#127DO;6<-#1DO;6SUB#1<-#117DO;5<-#13DO;5SUB#1<-#16DO;5SUB#2<-#368DO;5SUB#3<-#368DO;5SUB#4<-#274DO;5SUB#5<-#103DO;5SUB#6<-#376DO;5SUB#7<-#217DO;5SUB#8<-#374DO;5SUB#9<-#356DO;5SUB#10<-#374DO;5SUB#11<-#375DO;5SUB#12<-#1353DO;5SUB#13<-#276DOREADOUT;3+;2+;4+;6+;1+;6+;5

```

Copy and paste to try it online!

## With comments

```
DONOTE ;1 for "I'm", ;2 for rest of input
DO;1<-#3
DO;2<-#99
DOWRITEIN;1+;2
DONOTE ;3 for "Hi"
DO;3<-#2DO;3SUB#1<-#29DO;3SUB#2<-#1118
DONOTE ;4 for ","
DO;4<-#1DO;4SUB#1<-#127
DONOTE ;6 for " "
DO;6<-#1DO;6SUB#1<-#117
DONOTE ;5 for "CLC-INTERCAL!"
DO;5<-#13DO;5SUB#1<-#16DO;5SUB#2<-#368DO;5SUB#3<-#368DO;5SUB#4<-#274DO;5SUB#5<-#103DO;5SUB#6<-#376DO;5SUB#7<-#217DO;5SUB#8<-#374DO;5SUB#9<-#356DO;5SUB#10<-#374DO;5SUB#11<-#375DO;5SUB#12<-#1353DO;5SUB#13<-#276
DONOTE concatenate those strings
DOREADOUT;3+;2+;4+;6+;1+;6+;5

```
> 0 votes

# Answer
## Python 3 (34 Bytes)

```
lambda m:"Hi%s, I'm Python!"%m[3:]

```

### Python 3 (35 Bytes)

```
lambda m:"Hi"+m[3:]+", I'm Python!"

```
> 0 votes

# Answer
# Python 3, 46 bytes

```
s=input()
print("Hi "+s[4:]+", I'm Python 3!")

```

Try it online!
> 0 votes

# Answer
## Pascal (ISO standard 10206, “Extended Pascal”), 103 characters

```
program d(input,output);var s:string(99);begin readLn(s);writeLn('Hi',subStr(s,4),', I''m Pascal!')end.

```

## FreePascal, 83 characters

The FPC (FreePascal Compiler) in its *default configuration* (specifically `{$mode FPC}`), discards and doesn’t need a `program` header (the `program d(input,output);`). Instead a `program` *always* has the `text` files `input` and `output` at its disposal. Furthermore `string` is shorthand for `string[255]`. However, the `subStr` `function` is not (yet) supported (as of FPC version 3.2.0) and `copy` will necessarily require a length specification (can only be omitted in `{$mode Delphi}`). Thus we can condense the above `program` to:

```
var s:string;begin readLn(s);writeLn('Hi',s[4..length(s)],', I''m FreePascal!')end.

```

```
var s:string;begin readLn(s);delete(s,1,3);writeLn('Hi',s,', I''m FreePascal!')end.

```
> 0 votes

# Answer
# Thunno `KJ`, \\$ 22 \log\_{256}(96) \approx \\$ 18.11 bytes

```
3Zx", I'm Thunno!"s"Hi

```

Attempt This Online!

## Thunno, \\$ 23 \log\_{256}(96) \approx \\$ 18.93 bytes

```
3Zx"Hi%s, I'm Thunno!"$

```

Attempt This Online!

#### Explanation

```
               # Implicit input
3Zx            # Remove first three characters
   "..."       # Push the string literal
        s"Hi  "# Swap and push "Hi"
               # Implicit output of joined stack

           # Implicit input
3Zx        # Remove first three characters
   "..."   # Push the string literal
        $  # Replace "%s" with ^^
           # Implicit output

```
> 0 votes

---
Tags: code-golf, natural-language
---


# Question
Title: Is there any less code way to make a leaf (eye) shape in CSS?
I'm trying to solve a CSS challenge. It contains a rotated leaf shape (looks like an eye). Score for the challenge depends on amount of characters of the code. Here's my way to make a leaf shape:

```
div {
  width: 200px;
  height: 200px;
  border-radius: 99% 0;
  rotate: 45deg;
  background: #d9d9d9;
}
```

```
<div></div>
```

Here's my whole solution for the challenge if you need a bigger picture:

```
* {
  background:#E3516E;
}
p {
  height:99px;
  width:99px;
  background:#d9d9d9;
  border-radius:0 0 81q;
  margin:-31px;
}
[i] {
  rotate:45deg;
  margin:55px 142px;
  border-radius:99%0;
}
p+p {
  margin:-30px 316px;
  scale:-1;
}
```

```
<p><p i><p>
```

Minified version of the above:

```
<p><p i><p><style>*{background:#E3516E}p{height:99;width:99;background:#d9d9d9;border-radius:0 0 81q;margin:-31}[i]{margin:55 142;rotate:45deg;border-radius:99%0}p+p{margin:-30 316;scale:-1

```

Is there any way with less code for the eye shape? Maybe with clip-path, borders or something like that? Please help.

# Answer
# 77 bytes

```
<p style=width:5em;height:5em;border-radius:99%0;rotate:45deg;background:#080

```

```
<p style=width:5em;height:5em;border-radius:99%0;rotate:45deg;background:#080
```
* Use a `p` tag instead of a `div`
* Omit the closing `>`
* Remove all white space within the CSS
* Use an inline `style` attribute
* Use `em` instead of `px` for units of measurement
* Use 3 digit hex colours instead of named colours
* Omit the last `;`

You can save another byte using `4rad` in place of `45deg`, but the angle won't be *exactly* right:

```
<p style=width:5em;height:5em;border-radius:99%0;rotate:4rad;background:#080
```
> 1 votes

---
Tags: code-golf, tips, css
---


title: Do I need a win streak?

text:
# Question
Title: Do I need a win streak?
You have played \\$N\\$ matches in some game where each match can only result in one of the two outcomes: win or loss. Currently, you have \\$W\\$ wins. You want to have a win percentage of \\$P\\$ or more, **playing as few matches as possible**. Output the minimum win streak that you need. Assume the current win streak is at \\$0\\$.

For example: If \\$N=10, W=2, P=50\\$, then you can win \\$6\\$ matches in a row, bringing your win percentage to \\$\frac{2+6}{10+6} = \frac{8}{16} = 50\\%\\$. You cannot have a win percentage of \\$50\\$ or more earlier than this. So the answer for this case is \\$6\\$.

# Examples

```
W, N, P ->
2, 10, 50%      -> 6
3, 15, 50%      -> 9
35, 48, 0.75    -> 4
19, 21, 0.91    -> 2
9, 10, 50%      -> 0
0, 1, 1/100     -> 1
43, 281, 24/100 -> 33
0, 6, 52%       -> 7

```

# Rules

* \\$N\\$ and \\$W\\$ will be integers with \\$0 \le W \< N\\$.
* The percentage \\$P\\$ will be an integer between \\$1\\$ and \\$100\\$ inclusive. You can also choose to take a decimal value between \\$0\\$ and \\$1\\$ inclusive instead, which will contain no more than \\$2\\$ decimal places, or take it as a fraction.
* You can take the inputs in any convenient format.
* Standard loopholes are forbidden.
* This is , so the shortest code in bytes wins.

# Answer
> 9 votes
# Python 3, 35 bytes

```
lambda w,n,p:-min(0,(w-p*n)//(1-p))

```

Try it online!

-4 bytes thanks to pajonk

Some simple math: if \\$X\\$ is the number of wins we need, then we have:

\\$\frac{W+X}{N+X}\geq P\\$

\\$W+X\geq PN+PX\\$

\\$X-PX\geq PN-W\\$

\\$X(1-P)\geq PN-W\\$

Since \\$P\<1\\$, then \\$1-P\>0\\$, so we can divide from both sides without division by zero or flipping the sign.

\\$X\geq\frac{PN-W}{1-P}\\$

# Answer
> 4 votes
# 05AB1E, ~~13~~ ~~15~~ 11 bytes

```
∞<.Δ¹+.«/²@

```

Try it online!

Why aren't I using Vyxal? Because I'm leaving the chance for others so they can claim the bounty.

*+2 due to bug fix :(*

*but -4 thanks to @ovs*

## Explained (old)

```
∞0š.ΔD²+s¹+s/³@
∞0š.Δ            # get the first integer n where:
     D²+s¹+s/    #     (wins + n) / (matches + n)
             ³@  #     >= percentage

```

# Answer
> 4 votes
# Jelly, 10 bytes

```
Ḣ_Ḣ×$÷’Ċ»0

```

Try it online!

## Explanation

This uses the same formula as my Python answer: \\$X\geq\frac{W-PN}{P-1}\\$

Takes the input as a list of three numbers, \\$W,N,P\\$.

```
Ḣ_Ḣ×$÷’Ċ»0  Main Link
Ḣ           W (pops from the list)
 _          minus
  Ḣ×$       N (pops from the list) times the list (now only has P)
     ÷’     divided by (P - 1)
       Ċ    ceiling
        »0  maximum of that and 0

```

## In-depth explanation

This is an even more in-depth explanation of this answer. If you are familiar with Jelly, you should probably skip this. I won't do these often.

Since this link is called with one argument each time, it is a monadic chain. Hence, as we walk down the chain, the following patterns are matched in this order: `dyad-monad`, `dyad-nilad`, `nilad-dyad`, `dyad`, and `monad` (nilads take 0 arguments; you can think of them as constants) (monads take 1 argument) (dyads take 2 arguments).

Since the link doesn't start with a nilad, the evaluation value starts equal to the argument, `[W, N, P]`.

First, we see , a monad meaning "pop and return the first element". This matches the last rule, so it applies as a monad to the current value, which is `[W, N, P]`. Thus, the current value is now `W`, and this also modifies the left argument object itself to `[N, P]`.

Here, it is important to note the function of `$` \- it takes the last two links and groups them into a monadic link. Here, the two links are  and `×`. We'll get back to this.

Next, we see `_`, a dyad (subtraction). It is followed by a monad, namely the one formed by the `$` grouping two links, thus matching the first pattern. The dyad-monad pattern, if we have some dyad `+` and some monad `F`, computes `v + F(a)` where `v` is the current value and `a` is the right argument. Thus, this computes `W - F([N, P])`. Here, `F(a)` computes `Ḣ×` as a monadic chain whose argument is `a = [N, P]`. The value starts at `v = [N, P]` as well.

The first link is a monad and thus the value becomes `N`. Also, since "pop" mutates, the argument (to both the sub-link and the main link) is now `[P]`. Then, the second link is a dyad and nothing else follows, so the value becomes `N × [P]` which is `[NP]`. This is a singleton list, not a value, but that's fine because everything else vectorizes.

Now, the value is `W - [NP]` which vectorizes to `[W - NP]`, and the argumnt is `[P]` since it was mutated within the sub-link.

`÷’` is a dyad-monad chain, which computes `[W - NP] ÷ P÷’`.  decrements, so this computes `[W - NP] ÷ (P - 1)`, which vectorizes to `[(W - NP) / (P - 1)]`.

Penultimately, `Ċ` is a monad meaning "ceiling", which just rounds all of these values up. Finally, `»0` is a dyad-nilad chain which takes the maximum of this value and 0, thus preventing negative outputs.

Here's a shitty hand-drawn visualization of how chaining works out here:

# Answer
> 4 votes
# , ~~45~~ ~~43~~ ~~42~~ 38 bytes

*Edit: simultaneous discovery of -1 byte by Kirill L., and then -4 bytes thanks to pajonk*

```
function(W,N,P)-min((W-P*N)%/%(1-P),0)

```

Try it online!

# Answer
> 3 votes
# PowerShell, 44 bytes

Every answer of Wasif inspires me to make the right one. Thanks.

```
param($w,$n,$p)for(;$w++/$n++-lt$p){$k++}+$k

```

Try it online!

# Answer
> 3 votes
# Clojure, 39 bytes

```
#(max(Math/ceil(/(-(* %2%)%3)(- 1%)))0)

```

Try it online!

Takes arguments in reverse order compared to the provided test cases (\\$P, N, W\\$).

# Answer
> 3 votes
# Jelly, 9 bytes

```
0+÷/:⁴ʋ1#

```

Try it online!

Full program that takes `[w, n]` on the left and `P` on the right.

## How it works

```
0+÷/:⁴ʋ1# - Main link. Takes [w, n] on the left and P on the right
      ʋ   - Previous 4 links as a dyad f(x, [w, n]):
 +        -   Yield [w+x, n+x]
  ÷/      -   Yield (w+x)÷(n+x)
     ⁴    -   Yield P
    :     -   Floor divide (w+x)÷(n+x) by P,
               returning 0 if P < (w+x)÷(n+x), and 1 otherwise
0      1# - Count up x = 0, 1, 2, ..., and find the first x such that f(x, [w, n]) is 1

```

# Answer
> 2 votes
# PowerShell, 51 bytes

```
param($w,$n,$p)while(($w+$k)/($n+$k)-lt$p){$k+=1}$k

```

Try it online!

What? It beat my python answer? oO

# Answer
> 2 votes
# JavaScript, ~~44~~ ~~40~~ 34 bytes

```
f=(w,n,p)=>w/n>=p?0:f(w+1,n+1,p)+1

```

Takes all three parameters as integers except `p` which is a decimal.

*-4 bytes, thanks to @DominicvanEssen* *-6 bytes, thanks to @Arnauld*

Try it online

# Answer
> 2 votes
# Ruby, 34 bytes

```
->w,n,p{[0,-(w-p*n).div(1-p)].max}

```

Try it online!

# Answer
> 2 votes
# Retina 0.8.2, 68 bytes

```
\d+
$*
\G1
100$*
1(?=1*,(1*)%)
$1
+`^(1*,)(1+\1(1+))
100$*1$1$3$2_
_

```

Try it online! Link includes test cases. Takes `P` as a percentage (including `%` sign). Explanation:

```
\d+
$*

```

Convert `W`, `N` and `P` to unary.

```
\G1
100$*

```

Multiply `W` by `100`.

```
1(?=1*,(1*)%)
$1

```

Multiply `N` by `P`.

```
+`^(1*,)(1+\1(1+))

```

While `100W<NP`...

```
100$*1$1$3$2_

```

increment `W` and `N`, i.e. add `100` to `100W` and `P` to `NP`.

```
_

```

Count the number of increments made.

# Answer
> 2 votes
# Haskell, 37 bytes

```
(n,w)#p|100*w<p*n=1+(n+1,w+1)#p|1>0=0

```

Try it online!

# Answer
> 2 votes
# Pari/GP, 31 bytes

```
f(W,N,P)=-min(-(P*N-W)\(1-P),0)

```

Try it online!

# Answer
> 1 votes
# Python 3, 55 bytes

```
f=lambda w,n,p,c=0:(w+c)/(n+c)>=p and c or f(w,n,p,c+1)

```

Try it online!

Simple recursion, I am beaten by few minutes....

# Answer
> 1 votes
# Charcoal, 24 bytes

```
ＮθＮηＮζ≔⁰εＷ‹⁺θε×ζ⁺ηε≦⊕εＩε

```

Try it online! Link is to verbose version of code. Explanation:

```
ＮθＮηＮζ

```

Input `W`, `N` and `P`.

```
≔⁰ε

```

Start with `X=0`.

```
Ｗ‹⁺θε×ζ⁺ηε

```

Until we reach the desired win percentage...

```
≦⊕ε

```

... increment `X`.

```
Ｉε

```

Output `X`.

A port of @hyper-neutrino's solutions is of course much shorter at 13 bytes:

```
Ｉ⌈⟦⁰±÷⁻×ＮＮＮ⊖θ

```

Try it online! Link is to verbose version of code. Takes input in the order `P`, `N`, `W`. Explanation:

```
        Ｎ       `P` as a number
       ×        Multiplied by
         Ｎ      `N` as a number
      ⁻         Subtract
          Ｎ     `W` as a number
     ÷          Floor divided by
           ⊖θ   `P` decremented
    ±           Negated
 ⌈⟦⁰            Maximum of that and 0
Ｉ               Cast to string
                Implicitly print

```

# Answer
> 1 votes
# Japt, 11 bytes

```
@°*L¨V°*W}a

```

Try it

# Answer
> 1 votes
# Vyxal 2.4.1, 8 bytes

```
λ¹+ɖ⁰≥;ṅ

```

Try it Online! Here's what I managed to come up with. It doesn't seem like anyone else is going to give this a go using Vyxal, so here's my solution.

## Explained

```
λ¹+ɖ⁰≥;ṅ
λ        # start a lambda that, given a single argument "n":
 ¹+      #     adds n to the list [wins, matches]
   ɖ     #     reduces that list by division
    ⁰≥;  #    and returns whether that number is greater than the percentage
       ṅ # take that lambda, and find the first integer (starting at 0) where it evaluates as truthy

```

# Answer
> 1 votes
# Wolfram Language (Mathematica), 25 bytes

```
0//.x_/;x+#-##2<x#3:>x+1&

```

Try it online!

We can also directly compute the number of needed wins:

### Wolfram Language (Mathematica), 25 bytes

```
⌈Min[#-##2,0]/--+#3⌉&

```

Try it online!

# Answer
> 1 votes
# CSASM v2.4.0.1, 123 bytes

A function which pops three values from the stack (`[N, W, P]`) and pushes the result as an `f64`.
The function expects the types of all three values to be `f64`.

```
.include <stdmath>
func a:
pop $3
pop $2
pop $1
push $3
dup
push $2
swap
push $1
mul
sub
neg
swap
push 1.0
sub
div
neg
push 0.0
call max
ret
end

```

**Explanation + Full Program:**

<pre><code>.include <stdmath>

func main:
    ; Get the three inputs
    in "N: "
    conv f64

    in "W: "
    conv f64

    in "P: "
    conv f64

    call a

    ; Truncate the result and print it
    conv i32
    push "Wins needed: "
    swap
    add
    print.n

    ret
end

func a:
    pop $3 ; P
    pop $2 ; W
    pop $1 ; N

    push $3
    ; [ P ]
    dup
    ; [ P, P ]

    push $2
    ; [ P, P, W ]
    swap
    ; [ P, W, P ]
    push $1
    ; [ P, W, P, N ]
    mul
    ; [ P, W, P*N ]
    sub
    ; [ P, W-P*N ]
    neg
    ; [ P, P*N-W ]
    swap
    ; [ P*N-W, P ]
    push 1.0
    ; [ P*N-W, P, 1 ]
    sub
    ; [ P*N-W, P-1 ]
    div
    ; [ (P*N-W)/(P-1) ]
    neg
    ; [ -(P*N-W)/(P-1) ]
    push 0.0
    call max

    ret
end
```
</code></pre>

# Answer
> 1 votes
# Japt, 9 bytes

Takes `P` as a decimal.

```
@°/V°<W}f

```

Try it

# Answer
> 1 votes
# JavaScript, 28 bytes

Takes `P` as a decimal and outputs `false` for `0`.

```
w=>n=>g=p=>w++/n++<p&&g(p)+1

```

Try it online!

---
Tags: code-golf, number, rational-numbers
---


title: Do absolutely nothing

text:
# Question
Title: Do absolutely nothing
Write a program that has at least one byte that, when run, does absolutely nothing. I thought this would be done by now, but I can't find any other challenges like this.

How to tell if it does nothing:

* No variables are declared
* Nothing is returned
* Input does nothing
* You could run a program after it and it would run normally
* It's like you never ran it in the first place

That's it.

# Answer
> 1 votes
# Polyglot, 1 byte

```

```

Just a newline. This program does nothing in many languages, including JavaScript, Python 3, the list goes on

---
Tags: code-golf
---


title: How far is the Sun?

text:
# Question
Title: How far is the Sun?
# Introduction

**tl;dr**

Continuously output the current distance from the Earth to the Sun.

---

Simplified, the orbit of the Earth around the Sun is an ellipse. So the actual distance between both is constantly changing. This distance can be calculated for any given day using this formula:

The equation can be split into the following parts2:

* `1` represents *1 AU* (astronomical unit), equals `149,597,870.691 km`
* `0.01672` is the orbital eccentricity between the Earth and the Sun
* `cos` is of course the cosine function, **but with argument in degrees rather than radians**
* `0.9856` is *360° / 365.256363 days*, a full rotation in one year, where `365.256363` is the length of a sidereal year, in mean solar days
* `day` is the day of the year `[1-365]`
* `4` represents the offset to the perihelion, which is between 4th and 6th of January

The formula takes a whole day but for the purpose of this challenge – a continuously output – you have to be more accurate; or nothing much will happen till the next day. Simply add the percentage of the past time to the current day, like1:

```
day + (h * 3600 + m * 60 + s) / 864 / 100

```

A few Examples:

* 1 January, 23:59:59 `1.99998842592593`
* 1 January, 18:00:00 `1.75`
* 1 January, 12:00:00 `1.50`
* 1 January, 06:00:00 `1.25`

# Input

This challenge has no input.

---

If your language can't get the current time, you can get it as an input to your program. Valid inputs are *timestamps* or complete *date-time strings* that suits the language best. Passing the current day alone (like `5` for 5th January or `5.25` for the same day at 6 o'clock) is not allowed.

# Output

Output the current distance from the Earth to the Sun:

* Output the value in `km`.
* Update the value *at least every second*.

Example output:

```
152098342

```

If it doesn't increase your byte count, you can also pretty print the result:

```
152,098,342
152,098,342 km

```

# Requirements

* You can write a program or a function. If it is an anonymous function, please include an example of how to invoke it.
* This is so shortest answer in bytes wins.
* Standard loopholes are disallowed.

# Example implementation

I've prepared an example implementation in JavaScript. It's neither competitive nor golfed.

```
// dayOfYear from http://stackoverflow.com/a/8620357/1456376
Date.prototype.dayOfYear = function() {
    var j1= new Date(this);
    j1.setMonth(0, 0);
    return Math.round((this-j1)/8.64e7);
}

// vars
var e = document.getElementById('view'),
    au = 149597870.691,
    deg2rad = Math.PI/180,
    date = now = value = null;

// actual logic
function calculate() {
    date = new Date();
    now = date.dayOfYear() + (date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds()) / 864 / 100;
    value = 1 - 0.01672 * Math.cos(deg2rad * 0.9856 * (now - 4));
    // supported in Firefox and Chrome, unfortunately not in Safari
    e.innerHTML = Math.round(value * au).toLocaleString('en-US') + ' km';

    setTimeout(calculate, 1000);
}

// let's do this
calculate();
```

```
<div id="view"></div>
```

---

1 To not unreasonably increase complexity, you don't have to convert your local time to UTC. If you use UTC please add a note to your answer.

2 For more details see "Earth-Sun distance on a given day of the year" over at Physics

# Answer
> 5 votes
## TI-BASIC, 38 bytes

```
Disp 25018086(59.8086-cos(5022635.4⁻¹checkTmr(83761
prgmA

```

For a TI-84+ series calculator. Name this `prgmA`. Note that this overflows the stack after a few thousand iterations; use a `While 1:...:End` instead if this is a problem, for two extra bytes.

This uses the perihelion on January 1, 1997, 23:16 UTC for reference, and is accurate to within a few dozen kilometers (about 7 digits of accuracy) for the next few years.

# Answer
> 5 votes
# Java - 185 180 bytes

```
static void d(){while(true){System.err.println(149597870.691*(1-.01672*Math.cos(Math.toRadians(.9856*(Calendar.getInstance().get(6)+LocalTime.now().toSecondOfDay()/8.64e4-4)))));}}

```

This uses the fact that there are 86,400 seconds in a day and is using local time, not GMT. Output happens much more than once per second. Not sure if import statements should be included in byte count.

To include a 1 second delay adds about 26 bytes e.g.

```
static void d(){try{while(true){System.err.println(149597870.691*((1-.01672*Math.cos(Math.toRadians(.9856*(Calendar.getInstance().get(6)+LocalTime.now().toSecondOfDay()/8.64e4-4)))));Thread.sleep(1000L);}}catch(Exception e){}}

```

Java definitely isn't the most golfable language. :)

Removed a few bytes thanks to @insertusernamehere

# Answer
> 4 votes
## Python, 101 bytes

```
import time,math
a=149597870.691
while 1:print(a-a*.01672*math.cos((time.time()-345600)/5022635.53))

```

345600 = 4\*24\*3600 (four days)

5022635.53 ≌ (365.256363\*24\*3600)/(2π) (seconds in year/2π)

# Answer
> 3 votes
# Bash/coreutils/bc, 101 bytes

```
#!/bin/bash
bc -l <<<"149597870.691*(1-.01672*c((`date +%s`-`date -d 4-Jan +%s`)/5022635.5296))"
sleep .5
exec $0

```

This computes the offset from the 4th of January in seconds, so uses a corresponding constant to convert to radians. Half a year converts to roughly pi:

```
$ bc -l <<<"(365.256363/2*86400)/5022635.5296"
3.14159265361957033371

```

The rest of the calculation is straight from the question.

# Answer
> 2 votes
## F#, 178 bytes

```
open System
Seq.initInfinite(fun _->
let n=DateTime.Now
(1.-0.01672*Math.Cos(0.0172*((n-DateTime.Today).TotalDays+float(n.DayOfYear-4))))*149597870.691)|>Seq.iter(printfn"%f")

```

This is an F# script that runs well in F# Interactive. For simplicity's sake, the "continuous output" requirement is taken to literal levels, although I did lose a byte to make the output print on a new line every iteration so that it wasn't *too* bad. =P

Ungolfed and explained:

```
Seq.initInfinite (fun _ ->            // Create an infinite sequence, with each element being defined by the following function
    let n = DateTime.Now
    let dayOffset = n.DayOfYear - 4   // Day of year returns the day as a number between 1 and 366
    let today = n - DateTime.Today    // Extract the current day, so the hours, minutes and all
    let partialDay = today.TotalDays  // Get the value of 'today' as a floating point number of days
                                      // so between 0 and 1 in this case - exactly what I needed
    // And now, the formula - note that 0.9856 has been combined with the conversion from degrees to radians, giving 0.0172
    (1. - 0.01672 * Math.Cos (0.0172 * (partialDay + float dayOffset))) * 149597870.691
)
|> Seq.iter (fun i -> printfn "%f" i) // For each of the (infinity of) numbers, print it

```

# Answer
> 2 votes
# Mathematica, 97 bytes

```
Dynamic[1496*^5-2501*^3Cos[.9856#&@@Now~DateDifference~{DateValue@"Year",1,4}],UpdateInterval->1]

```

**Explanation**

`{DateValue@"Year",1,5}` represents 5th of January this year, and `...~DateDifference~...` gives the temporal distance.

`Dynamic[...,UpdateInterval->1]` update the expression once per second.

# Answer
> 1 votes
## Pyth, 51 bytes

```
#*149597870.691-1*.01672.t*c-.dZ86400 31558149*2.nZ1

```

### Alternate formula

d/AU = 1 - 0.01672 cos ( 2π \[time since perihelion\]/\[orbital period\] )
This formula is essentially the same as the OP's formula, except it is generalized to be able to use any perihelion as a reference date.

The OP's formula has \[time since perihelion\] as ( day - 4 ) and has ( 2π rad / \[orbital period\] ) pre-calculated as 0.9856deg/day.

In my solution I am using the perihelion closest to the Unix epoch, 2nd January 1970.

### The code

Hand-compiled to pythonic pseudocode:

```
#                        while 1:
  *149597870.691             print( 149597870.691 * (                 # implicit print
    -1                           1 - (
      *.01672                        0.1672 * (
        .t                               trigo(
          *                                  multiply(
            c                                    divide(
              -.dZ86400                              unixTime-86400,
              31558149                               31558149
                                                 ),
            *2.nZ                                2*pi
                                             ),
          1                                  1                        # 1 means cos
                             )))))

```

This is essentially just turning the following formula into code:
d = ( 1 - 0.01672 cos ( 2π (t - 86400)/31558149 ) ) * 149597870.691
where t is the Unix time.

# Answer
> 1 votes
# Python 2.4 - 158 bytes

```
import time,math
while 1:t=time.localtime();print(int(149597870.691*(1-.01672*math.cos(math.radians(.9856*(t[7]+(t[3]*3600+t[4]*60+t[5])/864.0/100.0-4))))))

```

Takes the local time and spits out the distance. time.localtime() returns a tuple and can be referenced here.

# Answer
> 0 votes
## C, 338

```
#include <stdio.h>
#include <time.h>
#include <math.h>
int main ()
{
  time_t rt;
  struct tm * ti;
  while(1) {
  time(&rt);
  ti = localtime(&rt);
  double d = 1.0 - .01672*cos(0.0174533 * .9856*((ti->tm_yday + (ti->tm_hour * 3600.0 + ti->tm_mday * 60.0 + ti->tm_sec) / 86400.0) - 4));
  printf ("%f\n", d * 149598000.0);}
}

```

# Answer
> 0 votes
## HP‑41C series, 78 Bytes

This program requires an HP‑41CX or an HP‑41C/CV with a time module plugged in. It works only correctly from October 15, 1582 through September 10, 4320. Ensure the display format allows for displaying 9 digits (e. g. `FIX 4`, the default setting). You may set flag 29 to enable the insertion of a thousands separator for every group of three digits in the integer part. Set flag 28 to use commas as thousands separators (as opposed to periods). Flag 28 and 29 set are the default setting.

```
01♦LBL⸆S           5 Bytes  global label requires 4 + (length of string) Bytes
02 DEG             1 Byte   ensure Degree mode is selected
─── get day number (zero-based) ────────────────────────────────────────────────
03 DATE            2 Byte   today’s date: has MM.DDYYYY or DD.MMYYYY format
04 ENTER↑          1 Byte   replicate value
05 ENTER↑          1 Byte   again because `ENTER↑` disables stack lift
   NULL            1 Byte   invisible Null byte before numbers
06 1 E6            3 Bytes  put 1,000,000 on top of stack
07 *               1 Byte   multiply so X = MMDDYYYY or DDMMYYYY
   NULL            1 Byte
08 1 E4            3 Bytes  put 1,000 on top of stack
09 MOD             1 Byte   isolate YYYY
   NULL            1 Byte
10 1 E6            3 Bytes
11 /               1 Byte   divide YYYY by 1,000,000
   NULL            1 Byte
12 1.01            4 Bytes
13 +               1 Byte   X = January 1, current year
14 X≷Y             1 Byte   swap X and Y so difference is positive
15 DDAYS           2 Bytes  difference of days – accounts for leap year
─── get fractional time of day ─────────────────────────────────────────────────
16 TIME            2 Bytes  obtain time in HH.MMSSss format
17 HR              1 Byte   convert HH.MMSSss into decimal hours format
   NULL            1 Byte
18 24              2 Bytes  24 hours
19 /               1 Byte
─── compose `day` as in specification ──────────────────────────────────────────
20 +               1 Byte   combine day number and time
   NULL            1 Byte
21 3               1 Byte   perihelion bias for zero-based day numbering
22 −               1 Byte
─── perform calculation ────────────────────────────────────────────────────────
   NULL            1 Byte
23 .9856           5 Bytes  use .985609113 for improved precision
24 *               1 Byte
25 COS             1 Byte
   NULL            1 Byte
26 −.01672         7 Bytes
27 *               1 Byte
   NULL            1 Byte
28 149,597,870.7  11 Bytes
29 +               1 Byte
30 PSE             1 Byte   delay execution for about one second
31 GTO⸆S           3 Bytes  `PSE` displays contents of X-register

```

NB: The actual calculator (in hardware) is too slow to perform all operations within one second. It needs roughly 3 seconds + 1 second for `PSE`. However, this is a circumstance *outside* the realm of the programming language.

---
Tags: code-golf, physics, astronomy
---


# Question
Title: Shortening this Code to process nested tuple even further without the use of max()
I have the code:

```
marks = tuple(tuple((input("Enter subject: "), input("Enter marks: "))) for _ in range(int(input("Enter number of tuples: "))))
print(tuple((s[:3].upper(), max(int(m) for t, m in marks if t == s)) for s in set(t for t, m in marks)))

```

```
#INPUT
(("Physics",131),("Chemistry",30),("Physics",100),("Computers",50),("Chemistry",20))
#OUTPUT
(('COM', 50), ('PHY', 131), ('CHE', 30))

```

As you can see, the output is a nested tuple of the first three capitalized letters of the subject and the maximum mark given for each subject.

You can assume that Physics, Chemistry and Computers are the only subjects that the user inputs, and that they always use the same spelling for the subjects.

The order of the subjects in the output does not matter.

Is there anyway I can do the same without using the max function? The length of the code should optimally be at 2 lines or if at all possible, a single line. The maximum limit of the number of lines of code is 3.

The solution should try to contain no built in functions if possible. Functions like sort(), sorted() and max() are strictly not allowed.

# Answer
# Python,  ~~204~~ 188 bytes

-16 bytes thanks to @WheatWizard

```
m=[*((input("Enter subject: "),int(input("Enter marks: ")))for _ in'*'*int(input("Enter number of tuples: ")))]
print((*((i[:3].upper(),j)for i,j in m if all(y!=i or z<=j for y,z in m)),))

```

Attempt This Online!

# Python, 212 bytes

1 line

```
print((*[m:=[*((input("Enter subject: "),int(input("Enter marks: ")))for _ in range(int(input("Enter number of tuples: "))))]][:0],*((i[0][:3].upper(),i[1])for i in m if all(z[0]!=i[0]or z[1]<=i[1]for z in m)),))

```

Attempt This Online!

These are just some trivial golfs on your approach. It could probably be made much shorter. If there are ties this will print both.
> 4 votes

# Answer
# 1 line, ~~180~~ ~~173~~ 171 bytes

*7 bytes saved thanks to Jonathan Allen*

```
exec("x={}\n"+"if x.get(a:=input('Enter subject: ')[:3].upper(),b:=int(input('Enter marks: ')))<=b:x[a]=b\n"*int(input("Enter number of tuples: "))+"print((*x.items(),))")

```

Attempt This Online!

# 3 lines, ~~171~~ ~~163~~ 160 bytes

*8 bytes saved thanks to Jonathan Allen*

```
x,i,e={},input,'Enter '
exec("if x.get(a:=i(e+'subject: ')[:3].upper(),b:=int(i(e+'marks: ')))<=b:x[a]=b\n"*int(i(e+"number of tuples: ")))
print((*x.items(),))

```

Attempt This Online!

Here's another approach that yields fewer bytes. It can be done in 1, 2 or 3 lines, with more lines enabling shorter overall programs. There's probably still even some improvements to be made here.
> 5 votes

---
Tags: code-golf, array, tips, python
---