Hack into a Lottery

Question

You've recently made an account on a dodgy gambling site, where for a fee of 25 dollars, they will pay you back a random amount between 0 and 50 dollars. After getting around 5 dollars twice, you decide to prove the site is a scam. After accessing their external firewall with the default password, you find your way onto their database server, and find where the values for the minimum and maximum amounts are held. You decide to plug 25 '9's in as the maximum value, but get an error message saying the maximum value must be of type 'uint64'. However it is now that you notice some number keys don't seem to type into the remote console correctly. The challenge appears before you almost as if typed up on a Q+A site.

using only the conveniently installed programs for testing and executing your particular language, output the maximum size of an unsigned 64-bit integer value, however almost everything except the programming tools are broken on this machine, leaving you without the use of the numbers 1,2,4,6,8 - in either source code or literals, you also notice that it seems to take an exponentially longer amount of time to execute the program for each additional piece of code, so you'd better keep it short if you want to get rich before the drawing!

---

The Challenge

• Write a program which outputs 18446744073709551615, the maximum value of an unsigned 64-bit integer, as either a number, or a single string.

• Your source code cannot contain any of the characters '1','2','4','6' or '8'

• if your language does not have an unsigned 64-bit integer or equivalent, the output can be in string format or otherwise, but must be the above number.

• this is code-golf so shortest code in each language wins!

Answer 1

Beeswax, 3 bytes

_M{

Explanation:

_   # Create a bee going horizontally across the line, reading the code
 M  # Decrement the bee's counter, which starts at 0.
    # This will set the counter to 2^64-1, because as bees don't have a concept of
    # negative numbers, all values that are negative are translated to 2^64-n,
    # and in this case, n = -1, as we are calculating 0 - 1.
  { # Print the value

Try it online!

This language is perfect for this challenge.

Here is an extract from the Esolang page on Beeswax:

As everyone knows, bees don’t have a concept of negative numbers, but they discovered that they can use the most significant bit of an address to get around that. Thus, coordinates relative to a bee’s position are realized by the two’s complements of the coordinates. This way, half of the 64-bit address space is available for local addressing without wraparound in each direction.

The maximum positive 64-bit two’s complement address is 9223372036854775807 or 0x7fffffffffffffff in 64 bit hex. All values from 0 up to this value translate identically to the same 64 bit value. All values n in the opposite (negative) direction translate to 2^64-n. For example: n=-1 is addressed by 18446744073709551615. n=-9223372036854775808 is addressed by 9223372036854775808.

This is basically unsigned longs.

EDIT: I'm still expecting Dennis to outgolf me with a 2-byte solution.

Answer 2

C, 26 bytes

main(){printf("%lu",~0l);}

Prints a unsigned long value.

Requires the size of long to be 64 bits.

Answer 3

CJam (4 bytes)

GG#(

Online demo

This calculates 16¹⁶ - 1 using builtin G for 16 and the decrement operator (.

Answer 4

64-bit SBCL Common Lisp, 18 bytes

most-positive-word

Most positive word on 64-bit compiler is 64uint. It's something.

Answer 5

Python3 REPL, 12 bytes

In REPL: ~-(~-3<<9*7)

Outside of REPL: print~-(~-3<<9*7) <--> Python2!

Here's another one at 17 bytes: ~-(~-3<<ord("?")).

Explanation

Nothing super fancy. Here's it broken down:

~-           | Subtract 1 from the next value.
  (          | 
   ~-3       | Subtract 1 from 3, resulting in 2
      <<     | Binary shift 2's digits to left,
        9*7  | by 9*7 (63).
           ) | The value inside the parentheses is now 2**64.

The resulting expression is roughly (but not quite) ~-(2<<63) -> (2**64)-1. I use the tadpole operator twice here. A golfing tip about it is here.

There is also sys.maxint in Python2 which can be used, but I won't be looking at that.

repl.it <- testing link.

Answer 6

bc, 15 13 bytes

Saved 2 bytes thanks to manatwork.

(a=9+7)^a-3/3

Nothing fancy, just (16^16)-1.

Answer 7

dc, 7 bytes

I think it's allowed for stack based languages to leave the answer on the top cell of the stack, similar to a return value for functions. If explicit printing is needed, add p at the end of the code.

AZ5E^z-

Try it online!

It computes (2 ⁶⁴ - 1) using several tricks:

• 2 is given as the number of digits (Z) found in integer 10 (A)

• 64 is given as 5E. By default dc uses 10 as the input radix. Even so, it can accept numbers in hexadecimal notation, but they will be converted differently than you'd expect. Example: (5E)_default = (5E)_{(input radix = 10)} = (5 * 10 ¹) + (14_(E) * 10 ⁰) = 50 + 14 = 64

• 1 is given as the stack's depth (z), since only (2 ⁶⁴) was present then

Alternative story:

However it is now that you notice some number keys don't seem to type into the remote console correctly. You take a deep breath and start testing each numerical key. It is worse than you thought! Not a single one works, and you're left with the task to produce your desired integer by using only letters and symbols.

Solution in dc: computing (16 ¹⁶ - 1), still 7 bytes!

Fz+d^z-          # push 15, push 1, add, duplicate, exponentiate, push 1, subtract

Try it online!

Answer 8

05AB1E, 4 bytes

žJn<

Explanation:

žJ   # Push 4294967296
  n  # Squared
   < # Decreased by one

Finally! A chance to use 05AB1E's builtins for powers of two!

Try it online!

Another 4 byte answer:

žxo<

Explanation:

  o  # 2 to the power of
žx   # 64
   < # Decreased by one

Try it online!

(if anyone is wondering, this question is older than all the other 4-byte answers)

Answer 9

Jelly, 4 bytes

⁴*`’

Try it online!

Explanation

⁴     # 16
 *    # exponentiate
  `   # last link as a monad, repeating the argument
   ’  # decrement

Answer 10

MATLAB / Octave, 5 bytes

@Sanchises posted an excellent MATLAB answer, however this one is a considerably different approach, so I'll post it anyway:

tic/0

In MATLAB, tic returns the number of milliseconds past since the program was opened. Crucially the value it returns is a uint64 type. This gets away from having to cast a number to uint64 from MATLABs default type of double.

Any number divided by 0 in MATLAB is considered as infinity which for non-floating point types, MATLAB represents this as the maximum integer value for that type.

---

This also works with Octave though depending on which interpreter you use it may spit out a "division by zero" warning as well. You can try the code online here though as I say you get a /0 warning that doesn't appear in MATLAB.

Answer 11

bc, 18, 16 bytes

• Saved 2 bytes, thx @MrScapegrace

(9-7)^(55+9)-3/3

Answer 12

PHP, 16 bytes

This is much like the answer from Ven: https://codegolf.stackexchange.com/a/110751/38505

printf("%u",~0);

https://repl.it/Frcy/0

For this to work, you need to be in a 64-bit architecture. This is because ~0 is -1, which is 111111111111111111111111111111111111111111111111111111111111‌​1111 in binary, in 64 bits, compared to 11111111111111111111111111111111 in 32-bits, and the numbers are plataform-dependent - Ismael Miguel

Answer 13

JavaScript, 39 38 33 32 bytes

alert(0xafebff0+'737095'+0xc99f)

Edit: Saved 5 bytes thanks to @Arnauld.

Answer 14

MATLAB / Octave, 22 bytes

eye(['~rw}?='-9 ''])/0

Try it online!

eye is used to create a unit matrix (matrix with 1 on the diagonal, zero otherwise). Without arguments, this creates a 1x1 unit matrix, or in other words, just a 1. It takes an optional argument, which is the data type ('class' in MATLAB terminology) of the created matrix. We thus ask for a 1 of class uint64 , and divide it by zero which results in Inf in MATLAB, which gets clipped at intmax('uint64').

The vector ['~rw}?='-9 ''] evaluates to 'uint64'. Concatenating an empty char to a vector is 1 byte shorter than using char('~rw}?='-9).

Reasoning towards this answer: the built-in intmax sadly evaluates to the maximum of a 32 bit signed integer. The obvious next option is uint64(), which contains the forbidden characters. The alternative is to use a function that takes a string as a data type. Obvious candidates are intmax and cast, but alternatives include zeros, ones and eye.

eye(['~rw}?='-9 ''])/0    % Winning version! 22 bytes.
intmax(['~rw}?='-9 ''])   % Obvious candidate. 23 bytes.
1/zeros(['~rw}?='-9 ''])  % 24 bytes
cast(Inf,['~rw}?='-9 '']) % 25 bytes. Also an obvious candidate, but actually very long.

^{Note: MATLAB is installed by default on virtually all dodgy gambling sites.}

Answer 15

Java 8, 30 bytes

()->Long.toUnsignedString(~0L)

Test online

Answer 16

BF, 108 bytes

-[----->+<]>--.+++++++.----..++.+.---..----.+++++++.----.++++.-------.+++++++++.----..----.+++++.-----.++++.

If each command is considered as 3 bits, this is potentially 41 bytes.

Answer 17

Retina, 28 27 bytes

Saved 1 byte thanks to Kritixi Lithos

bieegheeahdhajffbgbf
T`l`d

Try it online!

Explanation

bieegheeahdhajffbgbf

Replaces the non-existent/empty input with this string. This particular string was generated by the "inverse" of this program. It encodes a through j as 0 through 9, respectively.

T`l`d

This is a Transliteration stage. The l and d are character sets used for transliteration. l represents the lowercase alphabet, d is all digits. So, it maps abcdefghij back to 0123456789.

Answer 18

Brain-Flak, 64, 62, 58, 54 bytes

(((((()()()()){}){}){}){}){({}<(({}()){}[()])>[()])}{}

Try it online!

[Try it online!]

Four bytes saved thanks to @Riley!

Explanation:

#Push a 64
(((((()()()()){}){}){}){})

#While true
{

  #Pop the top of the stack. We'll store this value for later, but first
  ({}

  #Before pushing the value
  <

    #Push (N + 1) * 2 - 1
    # (where N is the number underneath, originally 0)
    (({}()){}[()])

  >

  #And push the TOS minus one back on
  [()])

#endwhile
}

#Pop the zero left over
{}

#And decrement the number underneath
({}[()])

For the record, I tried pushing 32 and quadrupling, but it's the same byte count.

Answer 19

C++, 46 bytes.

int m(){std::cout<<unsigned long long(5+3-9);}

First time ever doing a code golf, but I'm fairly happy with myself. Will happily take any critique/suggestions :)

Answer 20

C# 6, 31 bytes

()=>System.Console.Write(~0UL);

Pretty much the same as Java.

C# 5, 56 bytes

class P{static void Main(){System.Console.Write(~0UL);}}

Answer 21

PowerShell, 29 14 bytes

0xC000PB/3-3/3

Try it online!

Thanks to @n0rd for essentially golfing this in half.

This leverages the inbuilt unary PB operator that basically functions as "multiply the preceding number by 1125899906842624" (i.e., how many bytes are in a pebibyte). That's coupled with the hex 0xC000, or 49152, so 49152 pebibytes. We divide that by 3, yielding 18446744073709551616, and subtract 3/3 to get the final value.

Answer 22

Forth (gforth), 11 9 7 bytes

true U.

Try it online

true is the same as -1. U. prints a number as an unsigned integer.

This works on TIO, possibly because it has a 64-bit architecture? I'm not sure. If I run -1 U. on repl.it, for example, I get 2**32-1. If repl.it supported double-length integers, outputting them would use UD. instead.

Answer 23

Python3 REPL, 11 bytes

~0^~0>>~077

How it works

• ~0 is -1 (two's complement, an infinite sequence of '1's)
• 077 is 63 in octal, so ~077 is -64
• Shift right with negative parameter is a shift to the left
• Putting all together, -1 xor (-1 << 64) is the number we are looking for

Answer 24

JavaScript (ES6), 50 bytes

[...'䠎ᴐIF╏ɧ'].map(s=>s.charCodeAt()).join``

Answer 25

Javascript 55 bytes

alert(""+(590300>>5)+(59530-3>>3)+7370955+(3*59*73>>3))

the code generates and then alerts the string 18446744073709551615 using bitwise operations

590300>>5 18446
59530-3>>3 7440
7370955
3*59*73>>3 1615

Answer 26

MATL, 8 bytes

l_5Z%EZD

This could probably be improved, but I'm not familiar with strings and types in MATL just yet.

Try it at matl.suever.net

Explanation:

l       % push 1
_       % unary minus
5       % push 5, corresponds to type 'uint64'
Z%      % convert 1 to this type
E       % double
ZD      % display as a string

Answer 27

Brain-Flak, 223 193 bytes

Includes +1 for -A
-30 thanks to DJMcMayhem

((((((((((((((((((((((((()()()){}){}()){}){}())[()()()()])[][]())[[]()()])[]))()()()())[[]()()])[][()])[()()()()])()()()())[(()()()){}()])()()()()))()()())[()])[()()]))()()()())[(()()()){}()])

Try it online!

This just pushed the ASCII values of and prints as characters.

For reference, it takes 338 bytes to generate the actual number using the Integer meta golfer.

((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()()()){}()){}){}()){}()){({}[()])}{}()){}()){}())){}{})){}{})()){}{})){}{})){}{})()){}{})){}{})){}{}){}){}())){}{}){}())()){}{})){}{}){}){}){}())()){}{})()){}{})){}{}){}())){}{})()){}{})){}{})){}{})){}{})()){}{})()){}{})){}{}){}())){}{}){}){}())()){}{})()){}{})){}{})

Try it Online!

Answer 28

x64 Assembly, 7 bytes

hex (assembled): 4831C048FFC8C3

disassembled, commented:
XOR RAX,RAX ;Zero the value of 64 bit register RAX DEC RAX ;Decrement the value of RAX RET ;Return this value

RAX is a 64 bit register, and is most often used to return integer arguments (eg, C). By decrementing 1, its value rolls over from 0 to... 2^64-1, which is exactly needed.
Though, the assembled binary contains ones and fours and eights, the assembly doesn't, but the assembled file is counted in assembly, so does it count? Ow, my head.
Also, output is return value in this case.

Answer 29

Jelly, 7 bytes

3’*“@‘’

Try it online!

Answer 30

TI-Basic, 14 11 bytes

int(e
Ans^Ans²³-1

• Many commands in TI-Basic are single or two-byte tokens.

• The superscript characters are different tokens, so they are allowed.

Answer 31

Swift, 8 bytes

UInt.max

outside playground / repl - 15 bytes

print(UInt.max)

Answer 32

TI-Basic, 10 bytes

9+7
Ans^Ans-0!

Answer 33

C#, 20 bytes

()=>ulong.MaxValue;

Answer 34

Ruby, 16 12 bytes

p~0^~0>>~077

Prints out the number. In REPL mode this would be 11 bytes (without the 'p')

Answer 35

Mathematica 44 39 Bytes, No numbers

Well I could do the 22 Byte answer Print[(9+7)^(9+7)-3^0]

Here's an answer using addition to build up to the desired number with no numbers in the code:

f=Nest[#+#&,p=E/E,#]&;f@f@(f@p+f@f@p)-p

Saved 5 bytes thanks to @Martin-Ender

Answer 36

Pyth, 9 7 bytes

t^Jyh7J

Online interpreter link.

Uses Emigna's algorithm.

Thanks to Leaky Nun for digging this answer out so that I could -1 it.
-1 because I found yh7 which is shorter than +9 7.

yh7 seems to be the shortest way we can make 16 without using 12468.

Answer 37

JavaScript, 50 bytes 47 bytes

parseInt(5%3+"7nq9nb9r7b",33+7-9)+btoa("×­y")

Answer 38

Chip, 67 bytes + 3 bytes = 162 70 bytes

(+3 is for flag -w)

*Z~vZZZZvZvvZZZZvZZ-vZZvZZ-ZZvZZt
e*fad`c'`bac^^zba^^bc da^^cabca^c

Try it online!

Chip is a 2D language inspired by integrated circuits, input and output are broken down into individual bits which travel through gates and across wires.

Let's look at the ungolfed version:

*Z~-v-Z-Z-Z-Zv-Zvv-Z-Z-Z-Zvv-Zv-Zvv-Z-Zv-Zv-Zv-Z-Zv-Z-Zvt
e*f a d c c bc abc c c   abc ab abc   ad ac ac a bc a ac

The first portion has two components: *Z~ and e*f. *Z~ creates a 1-cycle pulse to kick off the circuit. e*f is equivalent to the value 0x30, which is the ASCII code for "0".

The remainder of the circuit has one portion for each ASCII digit of the output. For example:

-Zv-
 bc

The elements a, b, c, and d are the low four bits of output: a is 0x01, b is 0x02, and so on. In this sample, we have b and c, giving us 0x02 | 0x04 = 0x06. This combines with the code above to give us 0x30 | 0x06 = 0x36, which is the ASCII code for "6".

The Zs with nothing below them simply result in "0".

At the end, t causes the program to halt.

---

If instead you want the actual binary value instead, corresponding to eight 0xFF bytes, you can accomplish this in only 22 + 3 = 25 bytes:

a*ZZZZZZZt
dc
*eh
fg*b

The output of this can be verified by e.g. piping it into od -vtu8.

Answer 39

Pyth, 6 bytes

C*h7"ÿ

Try it online!

How it works

C*h7"ÿ
    "ÿ   creates the string "ÿ" (U+00FF)
  h7     creates 8 (7+1)
 *       generates "ÿÿÿÿÿÿÿÿ"
C        convert to integer from base 256

This works because 18446744073709551615 = 0xFFFFFFFFFFFFFFFF.

Answer 40

MATL, 7 bytes

I3Z%WZD

Try it online!

Do a typecast on 3 (actual number doesn't matter much) to uint64, which reinterprets the bits of the default double precision float as an unsigned integer, giving a large value. Raise that to the power of 2, overflowing the range of uint64, which makes Matlab clamp it to the upper limit of 18446744073709551615.

Answer 41

Batch, 64 59 58 54 bytes

@set a=@cmd/cset/a
%a%0xafebff0
%a%737095
%a%0xc99f

Port of my JavaScript answer. Edit: Saved 5 bytes thanks to @Arnauld.

Answer 42

MSSQL, 33 37 30 29 27 bytes

SELECT power(9.+7,9+7)-77*5

Bigint is too big, so I'm counting 2^64-1 manually. I'm not sure why, but power(2,64) gives 18446744073709552000, so I have to substract 385.

-2 bytes thanks to @ETHproductions

Answer 43

Japt, 17 bytes

GpG s r#È*A+PG+Fs

Try it online!

Answer 44

Cardinal 42 bytes

%+.+=tt.''..*."7"'.."07370955"0+.*t.0+.**.

Try it Online

Answer 45

C++, 26 24 16 bytes

26 bytes: My first submit

main(){std::cout<<(~0UL);}

[EDIT]24 bytes: () is not necessary

main(){std::cout<<~0UL;}

[EDIT]16 bytes: without main(){}

std::cout<<~0UL;

Obviously, Every c++ program must have an entry point function.

So I think we should not count it as a part of the answer.

Answer 46

Rust, 43 42 31 bytes

fn main(){print!("{}",!0usize)}

This isn't portable code (assumes a 64-bit architecture), but I can't use the u64 type due to its name containing forbidden characters.

Answer 47

J, 10 bytes

<:JSB^<:5x

JSB is a constant equal to 65536. <: is x - 1. 5x is 5 as an extended integer. ^ is exponentiation.

I spent a really long time working on this. Here are my other solutions:

<:JSB^<:5x
<:^~+:>:7x
<:^~*:<:5x
<:^~*:>:3x
<:^~+:<:9x
<:^~x:JCMPX
<:x:*:*:JSB
<:^~x:%:#a.
#.1x#~*:<:9
<:x:^~>.^^^0
<:x:^~>.^^*_
<:^~<:p:>:5x
<:^~-:x:JBOXED
<:x:^~>.^~^*_
<:x:^~>.^~^^~%_
<:%:*:^:5+:<:9x
<:x:+:+:9!:20''
<:x:^~*:+:+:*__
>:+:#.1x#~#.6#1
<:x:*:*:-:JCHAR2
<:*:*:*:*:+:<:9x
<:x:^~>.%:3 u:EAV
<:x:*:*:3!:0 s:''
<:x:^~>.^^*JCHAR4
<:JCHAR^x:+:JBOXED
<:x:^~>.^^*#dbhelp
<:x:^~>.^^*3 u:DEL
<:x:^~>.^^*#show'show'
<:x:dfh":(>:9)^x:%:#a.

Answer 48

><>, 17 15 bytes

Updates

• Replaced ab-- with i+ to achieve -1.

b5+:*:*:*:*i+n;

Try it online!

The idea is to factor 16¹⁶ into (((16²⁾²)²)², which can be easily computing by duplicating the stack and multiplying :*.

Explanation

b5+:*:*:*:*i+n;

b                     Push 11
 5                    Push 5
  +                   Add to make 16
   :*                 Square  ->  16²
     :*:*:*           .. another 3 times to make
                           16¹⁶ = (((16²)²)²)²
           i          Push -1 because no input
            +         16¹⁶ + (-1) = 16¹⁶-1
             n;       Print and Exit

Answer 49

Brain-Flak, 122 bytes

(()())({({})({}[()])}{})({({})({}[()])}{})({({})({}[()])}{})({({})({}[()])}{})({({})({}[()])}{})({({})({}[()])}{})({}[()])

Try it online! Also works in Mini-Flak

Answer 50

R, 58 bytes

R has only 32-bit integers, and with 64-bit doubles, the number 18446744073709551615 is not accurately represented, hence this will return a string. I can't even use 64-bit integer packages, because many of them have 64 in the names. Probably not the right tool for the job.

x=as.character((9+7)^(9+7))
n=nchar(x)
substr(x,n,n)='5';x

computes 16^16 and replaces the last character with a 5.

Try it online!

Answer 51

brainfuck, 99 bytes

-->>->+>->>>+>->+>>+>->>>+>+>>>+>+[>+++[-<+++++>]<[->+++<]<++]>>+>>->>+>+>++>->>->>->>>>->>>+>[+.<]

Try it online!

Uses a ternary system for numbers between 0 and 8 (and a little cheat for the 9).

-, - = 0
-, 0 = 1
-, + = 2
0, - = 3
0, 0 = 4
0, + = 5
+, - = 6
+, 0 = 7
+, + = 8
+, ++ = 9

Answer 52

JavaScript, 67 52 47 45 39 bytes

b=9+7;(b**b+'').substr(0,b)+btoa('×­y')

Answer 53

Stax, 5 bytes

üó|>b

Run and debug it

This is simply the packed version of the program 64|2v which means 2**64-1. Yes, boring.

Answer 54

Brain-Flak, 62 58 bytes

(()())((()()()){}){({}<({({})({}[()])}{})>[()])}{}({}[()])

Try it online!

This runs into a timeout, but here's the "source".

(()())                 init stack with 2
((()()()){}){          repeat 6 times
    (
        {}
        <({({})({}[()])}{})> square the value
        [()]           decrement loop counter
    )
}
{}                     pop 0
({}[()])               decrement value
                       implicitly print it

It calculates ((((((2^2)^2)^2)^2)^2)^2)-1 and prints it

Answer 55

C (clang), 26 bytes

f(){printf("%llu",-3L/3);}

Try it online!

Answer 56

Python, 19 bytes

In REPL

int('3'*(35-3),7-3)

Not in REPL

print int('3'*(35-3),7-3)

Answer 57

Pyke, 5 bytes

Zw`@t

Try it here!

 w`   -   64
Z  @  -  set_bit(0, ^)
    t - ^ -1

Answer 58

Vim, 41 bytes:

:im a <C-o><C-v><C-a>
i0a7a3a3a5a73a3a073709550a5a0a5

This uses the <C-a> command (increment) to get around the restriction of not using 1, 2, 4, 6, or 8. No TIO link since this doesn't seem to work in V, but it definitely works on vim locally.

Answer 59

Ruby, 18 bytes

p (9+7)**(9+7)-7/7

Answer 60

MUMPS, 15 bytes

w 9+7**(9+7)-'0

Answer 61

SmallTalk – 60 characters

Transcript show:(((7+9)raisedTo:(7+9))-(3/3))printString;cr.

Answer 62

SmileBASIC, 35 bytes

?POW(!.+!.,#X)LOCATE #A,0?ASC("x")

x should be replaced with CHR$(1615)

Answer 63

Groovy, 28 Bytes

{++(Long.MAX_VALUE​/0.5​)​}​

Try it: https://groovyconsole.appspot.com/edit/5145694419550208

Answer 64

GO 62 bytes

package main
import ("fmt")
func main(){fmt.Print(^uint64(0))}

(This is my first submit too)

Answer 65

AWK, 39 bytes

{$0=(a+=++a)^(a*=a*=a*a);sub(".$",5)}1

Usage:

awk '{$0=(a+=++a)^(a*=a*=a*a);sub(".$",5)}5' <<< "anything one line here"

Annoyingly AWK has trouble with integer math beyond 2^53 since it internally converts large integers to 64-bit doubles. Since 2^64 can be exactly represented as a double, its string representation should be exactly 18446744073709551616 (it is on my machine, anyway). Unfortunately, 2^64 - 1 == 2^64, so I could not simply decrement the value, hence the workaround via string substitution.

Answer 66

Java, 92 Bytes :-D

class a{public static void main(String[] a){System.out.print(Long.toUnsignedString(-3/3));}}

Answer 67

Python, 20 (or 26) bytes

(5-3)**ord('@')-3**0

ord('@') is equal to 64.

The full function/programme (@BusinessCat, I hope this is more in line with what is expected) would add 6 bytes:

print (5-3)**ord('@')-3**0

The 26 byte version would work if we wanted to pipe the output:

python -c "print (5-3)**ord('@')-3**0"

The 20 byte version would not.