54
\$\begingroup\$

Long-time lurker, first-time poster. So here goes.

In the Wikipedia page for quine, it says that "a quine is considered to be 'cheating' if it looks at its own source code." Your task is to make one of these "cheating quines" that reads its own source code.

This is , so the shortest code in bytes - in each language - wins. This means that a 5-byte Pyth script would not beat a 21-byte Python script - but a 15-byte Python script would.

You must use file I/O to read the source code, so the following JavaScript code, taken from the official Wikipedia page, is invalid:

function a() {
    document.write(a, "a()");
}
a()

It must access the source code of the file on disk.

You are not allowed to specify the file name. You must make it detect the filename itself.

Everyone clear? Go!

\$\endgroup\$
  • 1
    \$\begingroup\$ Is a trailing newlines not present in the original file allowed? \$\endgroup\$ – isaacg Oct 29 '15 at 22:04
  • 3
    \$\begingroup\$ @isaacg IMHO That's not a quine, since it is not the source code. \$\endgroup\$ – mınxomaτ Oct 29 '15 at 22:05
  • 3
    \$\begingroup\$ You should state a requirement that it determine the actual filename instead of assuming a hard-coded string for the source location. \$\endgroup\$ – feersum Oct 29 '15 at 22:26
  • 3
    \$\begingroup\$ I agree with @feersum though, that requiring a specific file name makes this challenge way to trivial. \$\endgroup\$ – mınxomaτ Oct 29 '15 at 22:33
  • 1
    \$\begingroup\$ Can we assume that (for compiled languages) the source code is in the same folder (i.e. we can just add ".cpp" or ".hs" to arg[0] to get the source). \$\endgroup\$ – HEGX64 Nov 1 '15 at 9:15

62 Answers 62

60
\$\begingroup\$

Zsh, 4 bytes

<$0

The Z shell has feline functionalities built in. The fourth character is a linefeed.

Try it online!

The code does not depend in any way on the file name; it works even if the file name contains special character, such as spaces or newlines.

Test run

$ cat "my quine.sh"
<$0
$ zsh "my quine.sh" 
<$0
$ diff -s <(zsh "my quine.sh") <(cat "my quine.sh")
Files /dev/fd/63 and /dev/fd/62 are identical
\$\endgroup\$
  • 28
    \$\begingroup\$ feline functionalities :) \$\endgroup\$ – theB Oct 31 '15 at 10:51
48
\$\begingroup\$

Bash, 6 bytes

cat $0

Basically.

\$\endgroup\$
  • 3
    \$\begingroup\$ It does not print a newline. \$\endgroup\$ – Addison Crump Oct 29 '15 at 22:06
  • 2
    \$\begingroup\$ cat does not append a newline (at least on my system). \$\endgroup\$ – a spaghetto Oct 29 '15 at 22:06
  • 7
    \$\begingroup\$ @isaacg cat prints the content of the supplied file byte per byte. \$\endgroup\$ – Dennis Oct 29 '15 at 22:17
  • 2
    \$\begingroup\$ @LukStorms But wouldn't this be a cat solution then, instead of a bash solution? And cat does not really qualify as programming language \$\endgroup\$ – Fabian Schmengler Oct 29 '15 at 23:07
  • 30
    \$\begingroup\$ Will this work if the file is named -e ? \$\endgroup\$ – Mark Plotnick Oct 30 '15 at 6:05
32
\$\begingroup\$

UNIX executable loader, 10 bytes

#!/bin/cat

If you don't care about spam on standard error, you can make it one byte shorter:

#!/bin/dd
\$\endgroup\$
  • 7
    \$\begingroup\$ I like this. Not sure if it qualifies as a "language," though. \$\endgroup\$ – Kevin Oct 29 '15 at 23:39
  • \$\begingroup\$ Perhaps cheating a bit, but couldn't you rename your bin folder and the cat program to shorten the path? \$\endgroup\$ – James Webster Oct 30 '15 at 9:54
  • 3
    \$\begingroup\$ I'm not suggesting you do btw. I'm suggesting you could \$\endgroup\$ – James Webster Oct 30 '15 at 9:54
  • 3
    \$\begingroup\$ @Kevin The "language" (that is, interpreter) is cat. And I guess if you want to be very specific, a cat program simply prints itself, and is compatible with every file format in existence :) \$\endgroup\$ – l0b0 Oct 30 '15 at 10:38
  • 1
    \$\begingroup\$ @JamesWebster sudo install /bin/cat /c. Y'know, just in case /bin isn't on the root filesystem. Gotta have that cat in singleuser… \$\endgroup\$ – Blacklight Shining Oct 30 '15 at 23:08
25
\$\begingroup\$

C, 52

s[99];main(){read(open(__FILE__,0),s,99);printf(s);}

Of course, this reads the source code and not the compiled program - I assume that's within spec.

\$\endgroup\$
  • \$\begingroup\$ You could use printf instead of puts to avoid a trailing newline. \$\endgroup\$ – feersum Oct 29 '15 at 22:51
  • \$\begingroup\$ @feersum yes, good catch \$\endgroup\$ – Digital Trauma Oct 29 '15 at 22:52
  • 19
    \$\begingroup\$ @DigitalTrauma It's because of your avatar, of course \$\endgroup\$ – Peter Olson Oct 30 '15 at 6:27
  • 3
    \$\begingroup\$ Actually, puts can be used, you just need to read fewer characters. \$\endgroup\$ – user4098326 Oct 31 '15 at 1:41
  • 2
    \$\begingroup\$ @kasperd Yes, guaranteed by C89 \$\endgroup\$ – Digital Trauma Nov 1 '15 at 0:06
13
\$\begingroup\$

PHP, 21 Bytes

<?=file(__FILE__)[0];

file reads a file line by line into an array and the file only has one line. This saves a byte in comparison to readfile(__FILE__).

\$\endgroup\$
  • \$\begingroup\$ Notice that this only works from PHP5.4 and up, which was the first version to support array de-referentiation. But other than that, quite a nice answer! \$\endgroup\$ – Ismael Miguel Nov 3 '15 at 9:19
  • 1
    \$\begingroup\$ readfile is also 21: <?readfile(__FILE__);. \$\endgroup\$ – primo Nov 3 '15 at 15:42
  • 1
    \$\begingroup\$ Right, it doesn't need <?= \$\endgroup\$ – Fabian Schmengler Nov 3 '15 at 15:55
12
\$\begingroup\$

Perl, 15 bytes

open 0;print<0>

Saved 3 bytes thanks to @ThisSuitIsBlackNot!

\$\endgroup\$
  • 2
    \$\begingroup\$ You can save 3 bytes with open 0;print<0> \$\endgroup\$ – ThisSuitIsBlackNot Nov 2 '15 at 3:45
  • \$\begingroup\$ @ThisSuitIsBlackNot I was sure there was a shorter way to do it, but I couldn't for the life of my work it out... Using 0 assumes $0 then? \$\endgroup\$ – Dom Hastings Nov 2 '15 at 5:44
  • 3
    \$\begingroup\$ Yep. See perldoc -f open: "As a shortcut a one-argument call takes the filename from the global scalar variable of the same name as the filehandle: $ARTICLE = 100; open(ARTICLE) or die "Can't find article $ARTICLE: $!\n";" \$\endgroup\$ – ThisSuitIsBlackNot Nov 2 '15 at 6:41
11
\$\begingroup\$

Perl 6, 20 bytes

print slurp $?FILE

I haven't worked with Perl 6 very long so I'm not sure if there are any tricks to make this shorter.

\$\endgroup\$
  • 2
    \$\begingroup\$ can you remove the second space? \$\endgroup\$ – Eevee Nov 1 '15 at 2:03
  • 3
    \$\begingroup\$ @Eevee nope, it gets angry \$\endgroup\$ – Hotkeys Nov 1 '15 at 9:25
11
\$\begingroup\$

osascript (AppleScript from the command line), 40 33 32 bytes

(read path to me)'s paragraph 1

Executing on a file called a with osascript a.

Gets the first paragraph (line) of the file and prints it to STDOUT with a trailing newline, therefore the newline in the code.

\$\endgroup\$
  • 1
    \$\begingroup\$ See my edit to the OP \$\endgroup\$ – TheInitializer Oct 29 '15 at 23:03
  • \$\begingroup\$ Working on getting it to work. \$\endgroup\$ – Addison Crump Oct 29 '15 at 23:07
  • \$\begingroup\$ read path to me seems to work for me. El Cap. \$\endgroup\$ – Digital Trauma Oct 29 '15 at 23:15
  • \$\begingroup\$ Didn't see this, but this is the way I ended up doing it. :P Thanks, @DigitalTrauma. EDIT: trailing newlines must be considered, so you add the newline and use paragraphs 1. \$\endgroup\$ – Addison Crump Oct 30 '15 at 7:30
11
\$\begingroup\$

Python 2, 32 bytes

There's a newline at the end of the file.

print open(__file__).readline()

Python 3, 33 bytes

There's a newline at the end of the file.

print(open(__file__).readline())

Thanks to feersum for catching a problem and supplying __file__, Loovjo for a new approach to the Python 2 solution that saved 17 bytes, and Skyler for a solution that saved yet another byte and worked in both Python 2 and 3 (pending print being a function in Python 3)!

Doc link for readline

\$\endgroup\$
  • \$\begingroup\$ This would also save 2 bytes in python3 because you could discard the end parameter. \$\endgroup\$ – Skyler Nov 2 '15 at 21:24
  • \$\begingroup\$ @Skyler You're absolutely correct. \$\endgroup\$ – Celeo Nov 2 '15 at 21:34
  • \$\begingroup\$ How does this work in Python 3, which needs parens for print? \$\endgroup\$ – Doorknob Nov 2 '15 at 21:36
  • \$\begingroup\$ Python 3 should be print(open(__file__).readline()) followed by a newline. \$\endgroup\$ – Skyler Nov 2 '15 at 21:37
  • \$\begingroup\$ Your Python 3 example says Python 2 rather than Python 3 \$\endgroup\$ – TheInitializer May 25 '16 at 22:39
10
\$\begingroup\$

Batch, 9 8 Bytes

@type %0

Saved a byte thanks to @Joshua

\$\endgroup\$
  • 3
    \$\begingroup\$ You can save a byte by eliminating the trailing %. \$\endgroup\$ – Joshua Oct 30 '15 at 4:02
10
\$\begingroup\$

Python 2.7, 30 bytes

print open(__file__).read(29)

Edit: Just to be clear, the code above is supposed to have a newline at the end as the 30th byte. I'm not familiar with markdown enough to figure out how to display it in the code block.

I'm using the same trick here as the one in my C submission. This reads the whole source file excluding the trailing newline to account for the additional newline which print will append to the output.

\$\endgroup\$
  • \$\begingroup\$ Does this run into the same problem with the trailing newline that the other submission did? \$\endgroup\$ – cole Oct 30 '15 at 0:21
  • \$\begingroup\$ No. There's supposed to be a trailing newline that makes the 30th byte in the source code but I can't get it to display in the code block. My submission works because it reads the first 29 bytes of the source code so that the newline from print won't be extraneous. \$\endgroup\$ – xsot Oct 30 '15 at 0:25
  • 4
    \$\begingroup\$ That's not what the comma does. It appends a space instead of a newline. \$\endgroup\$ – xsot Oct 30 '15 at 1:00
  • 2
    \$\begingroup\$ could use ␤ to indicate a semantically-important newline \$\endgroup\$ – Eevee Nov 1 '15 at 2:02
9
\$\begingroup\$

Java, 212 196 Bytes (171 Bytes with questionable hard-coding rules)

Thanks to @Cruncher for shortening it by ~15 bytes!

I have no doubt this can be golfed.

import java.nio.file.*;class A{public static void main(String[]a){new A();}A(){try{System.out.print(new String(Files.readAllBytes(Paths.get(getClass().getName()+".java"))));}catch(Exception e){}}}

Or, another method, using the static method (and the name of the class), I get 171 bytes. I'm not sure if this qualifies as hard-coded, though.

import java.nio.file.*;class A{public static void main(String[]a)throws Exception{System.out.print(new String(Files.readAllBytes(Paths.get(A.class.getName()+".java"))));}}

Uses a constructor to get the class name by a non-static method. Using a static method (A.class.getName()) was really hard coded, so I used the 'proper' way. Using A.class.getName(), this code shortens down to 171 bytes.

Readable versions:

Using constructor and this.getClass():

import java.nio.file.*;
class A{
    public static void main(String[]a) {
        new A();
    }
    A(){
        try{
            System.out.print(
                new String(
                Files.readAllBytes(
                Paths.get(
                getClass().getName()+".java"))));
        }
        catch(Exception e) {}
    }
}

Using static method A.class.getName():

import java.nio.file.*;
class A {
    public static void main(String[] a) throws Exception {
        System.out.print(
             new String(
                  Files.readAllBytes(
                       Paths.get(
                            A.class.getName()+".java"))));
    }
}

Grabs all the bytes of the file at once and outputs it to STDOUT. Pretty straightforward.

\$\endgroup\$
  • \$\begingroup\$ Why just not use A.class.getName()? \$\endgroup\$ – Fabio F. Oct 30 '15 at 8:18
  • 3
    \$\begingroup\$ It's CodeGolf not CodeReview! ;) \$\endgroup\$ – Fabio F. Oct 30 '15 at 8:26
  • 1
    \$\begingroup\$ @FabioF. Yeah, but I think that dances on the line of being a hardcoded filename, which is against the rules. The point is, if you change the name of the file, you have to change the name of the class (obviously), but also change this line, which is like a hardcoded filename. \$\endgroup\$ – Cruncher Oct 30 '15 at 17:39
  • 1
    \$\begingroup\$ Can't you call the print statement inside the constructor and save yourself from setting a static variable? \$\endgroup\$ – Cruncher Oct 30 '15 at 17:45
  • 1
    \$\begingroup\$ @Cruncher Nah. You get java.io, I'll stick to java.nio - the point is not to win, but show ways to do it extremely concisely with different methods. \$\endgroup\$ – Addison Crump Oct 30 '15 at 18:14
8
\$\begingroup\$

AutoIt, 34 bytes

Outputs itself to the clipboard:

ClipPut(FileRead(@ScriptFullPath))
\$\endgroup\$
8
\$\begingroup\$

Ruby, 14

$>.<<IO.read$0
\$\endgroup\$
  • \$\begingroup\$ Nice use of . to avoid parentheses \$\endgroup\$ – Cyoce Jul 3 '17 at 6:21
7
\$\begingroup\$

Go, 111 105 bytes

package main
import("io"
."os"
."runtime")
func main(){_,p,_,_:=Caller(0)
f,_:=Open(p)
io.Copy(Stdout,f)}

My first code-golf in Go – just a few tricks you can use here I guess.

\$\endgroup\$
  • \$\begingroup\$ There is already an answer in Go - does this use the same method? \$\endgroup\$ – Addison Crump Oct 30 '15 at 12:20
  • \$\begingroup\$ @VoteToClose: I realise it, I was inspired by the other one indeed, but used package renaming here (cheap trick) as well as different technique for opening and piping file to stdout. Saved me a massive 22 bytes ;-) \$\endgroup\$ – tomasz Oct 30 '15 at 12:36
  • \$\begingroup\$ The method is actually a bit different, good one! \$\endgroup\$ – Fabian Schmengler Oct 30 '15 at 13:27
7
\$\begingroup\$

PowerShell, 39 36 31 25 Bytes

About as tight as I can get it:

gc $MyInvocation.MyCommand.Path | oh

Backed by popular demand this has been changed to:

gc $PSCommandPath|echo -n

prints to host shell current standard output.

\$\endgroup\$
  • \$\begingroup\$ gc $MyInvocation.MyCommand.Path is enough. It will automatically print it out. \$\endgroup\$ – Andrew Oct 30 '15 at 0:44
  • \$\begingroup\$ its not guaranteed to especially if the script is running silently \$\endgroup\$ – Chad Baxter Oct 30 '15 at 0:49
  • \$\begingroup\$ Haha yea I don't care. I was going to post if no one else had a PowerShell answer. But I forgot that gc was an alias and was just going to use cat, so you had a byte on me there anyway. \$\endgroup\$ – Andrew Oct 30 '15 at 0:51
  • \$\begingroup\$ Uh, I wouldn't be that strict about it. Otherwise every PS answer would explicitly have to pipe to the host shell, but that's up to you... \$\endgroup\$ – Andrew Oct 30 '15 at 0:57
  • \$\begingroup\$ You could instead use gc $PSCommandPath for 17 bytes. The problem I see is that this spits out a newline (which doesn't exist in the source). It's ambiguous now if trailing newline is OK or not ... depending upon how that rules, we may need to do something tricksy like gc $PSCommandPath|write-host -n for 31 bytes. \$\endgroup\$ – AdmBorkBork Oct 30 '15 at 13:03
5
\$\begingroup\$

Ruby, 15 bytes

$><<IO.read($0)

Source: https://stackoverflow.com/questions/2474861/shortest-ruby-quine

\$\endgroup\$
  • 11
    \$\begingroup\$ I've converted this to a community wiki because it isn't your own work. \$\endgroup\$ – Alex A. Oct 29 '15 at 23:58
5
\$\begingroup\$

C, 49 bytes

s[];main(){read(open(__FILE__,0),s,48);puts(s);}

Edit: To clarify, the 49th byte is a newline.

This reads the source code minus the newline at the end to account for the newline which puts will append to the end of the output.

\$\endgroup\$
  • \$\begingroup\$ This code invokes undefined behavior twice. \$\endgroup\$ – Joshua Oct 30 '15 at 4:03
  • 5
    \$\begingroup\$ Well, this is code golf. My code produces the desired output so it's a valid submission. \$\endgroup\$ – xsot Oct 30 '15 at 4:16
  • 1
    \$\begingroup\$ @xsot In that case, you should probably list the compiler version + options; otherwise this might not be verifiable. \$\endgroup\$ – Justin Oct 30 '15 at 7:16
  • 1
    \$\begingroup\$ If having undefined behavior is permitted as long as you can have some compiler that produces the desired output on some machine during some phase of the moon, then I propose int main(void) { *0; } as a solution. After all, the standard would permit an implementation that compiles that into a program that solves the problem. I'd be fine with using implementation-dependent behavior as long as you specify the compiler, but with undefined behavior, you can't even guarantee that you wouldn't get ten different answers if you ran that ten times in a row on the same machine. \$\endgroup\$ – Ray Nov 3 '15 at 0:44
  • 1
    \$\begingroup\$ @MDXF I wasn't seriously suggesting that we write that solution. I was arguing against allowing undefined behavior. int main() {*0;} might work even on existing compilers, since it contains undefined behavior. Similarly, xsot's solution might work on existing compilers, since it contains undefined behavior. Neither one is guaranteed to solve the problem. (Although xsot's is admittedly more likely to do so, it might just as easily crash). My actual argument is that we should permit solutions that depend on implementation-dependent or unspecified behavior, but not undefined behavior. \$\endgroup\$ – Ray May 31 '17 at 19:43
5
\$\begingroup\$

Mathematica, 16 bytes

FilePrint@$Input

Run it in script mode.

\$\endgroup\$
  • \$\begingroup\$ I've been using Mathematica for many years and had never even heard of script mode. \$\endgroup\$ – Michael Stern Nov 13 '15 at 18:04
4
\$\begingroup\$

Pyth, 25 bytes

$import sys$h'e$sys.argv

This reads its file name. Essentially, it looks up argv, opens the file corresponding to its last argument, and prints its first line.

\$\endgroup\$
  • \$\begingroup\$ Can't you just do h'$__file__$? \$\endgroup\$ – kirbyfan64sos Oct 29 '15 at 23:34
  • \$\begingroup\$ @kirbyfan64sos That gives me the error NameError: name '__file__' is not defined. Pyth is compiled to Python, and then the resultant string is executed. So I wouldn't expect that to work. \$\endgroup\$ – isaacg Oct 29 '15 at 23:41
4
\$\begingroup\$

Go, 133 Bytes

Everyone clear? Go!

package main
import("fmt"
"io/ioutil"
"runtime")
func main(){_,f,_,_:=runtime.Caller(0)
s,_:=ioutil.ReadFile(f)
fmt.Print(string(s))}
\$\endgroup\$
  • 2
    \$\begingroup\$ This inspired me to write my own (and the very first) code-golf solution in Go. Looking for some general tricks, you can easily go down to 123 characters here by applying single-letter names for packages, for example r"runtime". \$\endgroup\$ – tomasz Oct 30 '15 at 12:27
4
\$\begingroup\$

><>, 13 Bytes

0:0go:c=?;1+!

Tested both on the online and offline interpreters. The g command is the closest to being able to read from the source file and if it doesn't count for the purpose of this challenge I'll mark my entry non-competing; I do believe it normally considered "cheating" for quines.

Try it online.

\$\endgroup\$
4
\$\begingroup\$

Haskell, 63 bytes

For science!

import System.Environment
main=getProgName>>=readFile>>=putStr
\$\endgroup\$
  • \$\begingroup\$ Only works with the runhaskell command. Very cool though \$\endgroup\$ – HEGX64 Nov 2 '15 at 22:44
4
\$\begingroup\$

><>, 31 bytes

Disclaimer : there is no file I/O in ><>, however I thought it would be interesting to showcase its codespace I/O inherited from Befunge, one of the language that inspired ><>.

00voa0+1;!?$~<
1+> :r:@g: ?!^o$

A self-reading Quine I made some time ago, you can try it here.

I just saw there is a shorter ><> self-reading quine. While it is clearly better in code-golf standards I'd like to point out it has hardcoded code length, while mine would copy additionnal lines or columns of code (as long as they don't break the original code).

\$\endgroup\$
  • \$\begingroup\$ I was thinking of posting in ><>, but I thought ><> would be impossible due to the rule: "You must use file I/O to read the source code" \$\endgroup\$ – Sp3000 Nov 3 '15 at 11:47
  • \$\begingroup\$ @Sp3000 woops indeed, looks like I didn't read the challenge well enough. I'll add a disclaimer \$\endgroup\$ – Aaron Nov 3 '15 at 12:00
3
\$\begingroup\$

F#, 54 Bytes

printf"%s"(System.IO.File.ReadAllText __SOURCE_FILE__)

Usage:

fsi --exec a.fsx
\$\endgroup\$
3
\$\begingroup\$

Perl 5, 15 13 bytes

Credit to the Bash solution for inspiring this:

print`cat $0`

EDIT: Don't need the semi-colon or first space.

\$\endgroup\$
  • \$\begingroup\$ Not pure perl, it needs some other executable, namely cat, present and findable in the $PATH. But if it is present, it can be assumed as just a command available to perl, so why not. \$\endgroup\$ – Golar Ramblar May 12 '17 at 20:16
3
\$\begingroup\$

Node.js, 66 63 bytes

p=process;p.stdout.write(require('fs').readFileSync(p.argv[1]))

Doesn't use console.log, which appends a newline.

\$\endgroup\$
  • 1
    \$\begingroup\$ You can save a few bytes by using the synchronous api: p=process;p.stdout.write(require('fs').readFileSync(p.argv[1])) \$\endgroup\$ – TehShrike Nov 2 '15 at 19:20
  • 1
    \$\begingroup\$ Why not console.log(require('fs').readFileSync(process.argv[1]))\n for 57 bytes? \$\endgroup\$ – Conor O'Brien Sep 30 '16 at 0:14
  • \$\begingroup\$ This doesn't always work. Say the file is named test.js. It is valid to invoke it by running node test, which will cause this to throw an error. \$\endgroup\$ – Patrick Roberts Jan 10 '17 at 11:35
3
\$\begingroup\$

C, 31 bytes

main(){system("cat "__FILE__);}

The bash solution is so short, so why not base a C solution on it?

\$\endgroup\$
3
\$\begingroup\$

Haskell, 49 bytes

{-#LANGUAGE CPP#-}main=putStr=<<readFile __FILE__

Try it online!

(GHC) Haskell has an extension to use the C preprocessor (commonly used for portability between versions and architectures.) Hopefully self-explanatory.

\$\endgroup\$
3
\$\begingroup\$

HTML with JavaScript, 115 bytes (doesn't really count)

<!DOCTYPE html><html><title>x</title><script>alert(new XMLSerializer().serializeToString(document))</script></html>

Does this count? I don't mind, it was fun :)

Technically it doesn't open a file. It's also a well-formed HTML5 document. The XMLSerializer was the only tool which also returned the DOCTYPE portion, but is non-standard. Still, it works on chrome and firefox, and I bet other browsers.

And as a bonus:

JavaScript, 41 bytes

alert(document.currentScript.textContent)
\$\endgroup\$
  • \$\begingroup\$ Remove ";" at the end, save 1 byte :) \$\endgroup\$ – Евгений Новиков Jul 3 '17 at 7:44
  • 1
    \$\begingroup\$ @ЕвгенийНовиков You're right, not sure why I left that in back then. It seems like I didn't count it though. \$\endgroup\$ – Jacque Goupil Jul 4 '17 at 11:07

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.